Merge of usage reporting and license changes from WV CDM repo

* CdmSession unittest and license request time changes
  b/15914199
  Merge of https://widevine-internal-review.googlesource.com/#/c/10597/

* Specify OEMCrypto API version in client capabilities
  b/15388863
  Merge of https://widevine-internal-review.googlesource.com/#/c/10616/

* Report start and last play time in license request
  b/15995227
  Merge of https://widevine-internal-review.googlesource.com/#/c/10617/

* Respect can_play flag
  b/15330338
  Merge of https://widevine-internal-review.googlesource.com/#/c/10619/

* Restore offline session information
  b/16009274
  Merge of https://widevine-internal-review.googlesource.com/#/c/10641/

Change-Id: I17fdc309efbc1d44385a86a368df11b1349b29c2

libwvdrmengine/cdm/core/src/policy_engine.cpp

@@ -33,8 +33,8 @@ void PolicyEngine::Init(Clock* clock) {
   license_state_ = kLicenseStateInitial;
   can_decrypt_ = false;
   license_start_time_ = 0;
-  license_received_time_ = 0;
   playback_start_time_ = 0;
+  last_playback_time_ = 0;
   next_renewal_time_ = 0;
   policy_max_duration_seconds_ = 0;
   clock_ = clock;
@@ -76,6 +76,14 @@ void PolicyEngine::OnTimerEvent(bool* event_occurred, CdmEventType* event) {
       break;
     }
 
+    case kLicenseStatePending: {
+      if (current_time >= license_start_time_) {
+        license_state_ = kLicenseStateCanPlay;
+        can_decrypt_ = true;
+      }
+      break;
+    }
+
     case kLicenseStateInitial:
     case kLicenseStateExpired: {
       break;
@@ -115,13 +123,11 @@ void PolicyEngine::UpdateLicense(
   policy_.MergeFrom(license.policy());
 
   // some basic license validation
-  if (license_state_ == kLicenseStateInitial) {
-    // license start time needs to be present in the initial response
-    if (!license.has_license_start_time())
-      return;
-  }
-  else {
-    // if renewal, discard license if version has not been updated
+  // license start time needs to be specified in the initial response
+  if (!license.has_license_start_time()) return;
+
+  // if renewal, discard license if version has not been updated
+  if (license_state_ != kLicenseStateInitial) {
     if (license.id().version() > license_id_.version())
       license_id_.CopyFrom(license.id());
     else
@@ -129,12 +135,8 @@ void PolicyEngine::UpdateLicense(
   }
 
   // Update time information
-  int64_t current_time = clock_->GetCurrentTime();
-  if (license.has_license_start_time())
-    license_start_time_ = license.license_start_time();
-  license_received_time_ = current_time;
-  next_renewal_time_ = current_time +
-      policy_.renewal_delay_seconds();
+  license_start_time_ = license.license_start_time();
+  next_renewal_time_ = license_start_time_ + policy_.renewal_delay_seconds();
 
   // Calculate policy_max_duration_seconds_. policy_max_duration_seconds_
   // will be set to the minimum of the following policies :
@@ -157,12 +159,18 @@ void PolicyEngine::UpdateLicense(
     return;
   }
 
+  int64_t current_time = clock_->GetCurrentTime();
   if (IsLicenseDurationExpired(current_time)) return;
   if (IsPlaybackDurationExpired(current_time)) return;
 
   // Update state
-  license_state_ = kLicenseStateCanPlay;
-  can_decrypt_ = true;
+  if (current_time >= license_start_time_) {
+    license_state_ = kLicenseStateCanPlay;
+    can_decrypt_ = true;
+  } else {
+    license_state_ = kLicenseStatePending;
+    can_decrypt_ = false;
+  }
 }
 
 void PolicyEngine::BeginDecryption() {
@@ -172,12 +180,14 @@ void PolicyEngine::BeginDecryption() {
       case kLicenseStateNeedRenewal:
       case kLicenseStateWaitingLicenseUpdate:
         playback_start_time_ = clock_->GetCurrentTime();
+        last_playback_time_ = playback_start_time_;
 
         if (policy_.renew_with_usage()) {
           license_state_ = kLicenseStateNeedRenewal;
         }
         break;
       case kLicenseStateInitial:
+      case kLicenseStatePending:
       case kLicenseStateExpired:
       default:
         break;
@@ -185,6 +195,10 @@ void PolicyEngine::BeginDecryption() {
   }
 }
 
+void PolicyEngine::DecryptionEvent() {
+  last_playback_time_ = clock_->GetCurrentTime();
+}
+
 CdmResponseType PolicyEngine::Query(CdmQueryMap* key_info) {
   std::stringstream ss;
   int64_t current_time = clock_->GetCurrentTime();
@@ -211,6 +225,27 @@ CdmResponseType PolicyEngine::Query(CdmQueryMap* key_info) {
   return NO_ERROR;
 }
 
+bool PolicyEngine::GetSecondsSinceStarted(int64_t* seconds_since_started) {
+  if (playback_start_time_ == 0) return false;
+
+  *seconds_since_started = clock_->GetCurrentTime() - playback_start_time_;
+  return (*seconds_since_started >= 0) ? true : false;
+}
+
+bool PolicyEngine::GetSecondsSinceLastPlayed(
+    int64_t* seconds_since_last_played) {
+  if (last_playback_time_ == 0) return false;
+
+  *seconds_since_last_played = clock_->GetCurrentTime() - last_playback_time_;
+  return (*seconds_since_last_played >= 0) ? true : false;
+}
+
+void PolicyEngine::RestorePlaybackTimes(int64_t playback_start_time,
+                                        int64_t last_playback_time) {
+  playback_start_time_ = (playback_start_time > 0) ? playback_start_time : 0;
+  last_playback_time_ = (last_playback_time > 0) ? last_playback_time : 0;
+}
+
 void PolicyEngine::UpdateRenewalRequest(int64_t current_time) {
   license_state_ = kLicenseStateWaitingLicenseUpdate;
   next_renewal_time_ = current_time + policy_.renewal_retry_interval_seconds();
@@ -221,7 +256,7 @@ void PolicyEngine::UpdateRenewalRequest(int64_t current_time) {
 // will always return false if the value is 0.
 bool PolicyEngine::IsLicenseDurationExpired(int64_t current_time) {
   return policy_max_duration_seconds_ &&
-      license_received_time_ + policy_max_duration_seconds_ <=
+      license_start_time_ + policy_max_duration_seconds_ <=
       current_time;
 }
 
@@ -229,9 +264,12 @@ int64_t PolicyEngine::GetLicenseDurationRemaining(int64_t current_time) {
   if (0 == policy_max_duration_seconds_) return LLONG_MAX;
 
   int64_t remaining_time = policy_max_duration_seconds_
-      + license_received_time_ - current_time;
+      + license_start_time_ - current_time;
 
-  if (remaining_time < 0) remaining_time = 0;
+  if (remaining_time < 0)
+    remaining_time = 0;
+  else if (remaining_time > policy_max_duration_seconds_)
+    remaining_time = policy_max_duration_seconds_;
   return remaining_time;
 }
 
@@ -256,7 +294,7 @@ int64_t PolicyEngine::GetPlaybackDurationRemaining(int64_t current_time) {
 bool PolicyEngine::IsRenewalDelayExpired(int64_t current_time) {
   return policy_.can_renew() &&
       (policy_.renewal_delay_seconds() > 0) &&
-      license_received_time_ + policy_.renewal_delay_seconds() <=
+      license_start_time_ + policy_.renewal_delay_seconds() <=
       current_time;
 }
 
@@ -264,7 +302,7 @@ bool PolicyEngine::IsRenewalRecoveryDurationExpired(
     int64_t current_time) {
 // NOTE: Renewal Recovery Duration is currently not used.
   return (policy_.renewal_recovery_duration_seconds() > 0) &&
-      license_received_time_ + policy_.renewal_recovery_duration_seconds() <=
+      license_start_time_ + policy_.renewal_recovery_duration_seconds() <=
       current_time;
 }