Source release v2.1.3-2-789 + third_party libs

Change-Id: I8648756dab3fe1f53d6da18b83cd1294581d1abe

core/src/cdm_session.cpp

@@ -33,6 +33,7 @@ CdmSession::CdmSession(const CdmClientPropertySet* cdm_client_property_set)
       is_offline_(false),
       is_release_(false),
       is_usage_update_needed_(false),
+      is_initial_decryption_(true),
       is_certificate_loaded_(false) {
   if (cdm_client_property_set) {
     Properties::AddSessionPropertySet(session_id_, cdm_client_property_set);
@@ -64,6 +65,7 @@ CdmResponseType CdmSession::Init() {
   crypto_session_.reset(session.release());
   license_received_ = false;
   reinitialize_session_ = false;
+  is_initial_decryption_ = true;
   return NO_ERROR;
 }
 
@@ -313,6 +315,10 @@ CdmResponseType CdmSession::Decrypt(const CdmDecryptionParameters& params) {
   CdmResponseType status = crypto_session_->Decrypt(params);
 
   if (NO_ERROR == status) {
+    if (is_initial_decryption_) {
+      policy_engine_.BeginDecryption();
+      is_initial_decryption_ = false;
+    }
     if (!is_usage_update_needed_) {
       is_usage_update_needed_ =
         !license_parser_.provider_session_token().empty();
@@ -515,8 +521,9 @@ void CdmSession::OnKeyReleaseEvent(const CdmKeySetId& key_set_id) {
 }
 
 SecurityLevel CdmSession::GetRequestedSecurityLevel() {
-  if (Properties::GetSecurityLevel(session_id_)
-          .compare(QUERY_VALUE_SECURITY_LEVEL_L3) == 0) {
+  std::string security_level;
+  if (Properties::GetSecurityLevel(session_id_, &security_level) &&
+      security_level == QUERY_VALUE_SECURITY_LEVEL_L3) {
     return kLevel3;
   }
 

core/src/license.cpp

@@ -193,10 +193,10 @@ bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
   }
 
   bool privacy_mode_enabled = Properties::UsePrivacyMode(session_id);
-  std::vector<uint8_t> cert = Properties::GetServiceCertificate(session_id);
-  std::string serialized_service_certificate(cert.begin(), cert.end());
-
-  if (serialized_service_certificate.empty())
+  std::string serialized_service_certificate;
+  if (!Properties::GetServiceCertificate(session_id,
+                                         &serialized_service_certificate) ||
+      serialized_service_certificate.empty())
     serialized_service_certificate = service_certificate_;
 
   if (privacy_mode_enabled && serialized_service_certificate.empty()) {

core/src/policy_engine.cpp

@@ -2,16 +2,16 @@
 
 #include "policy_engine.h"
 
-#include <algorithm>
-#include <map>
+#include <limits.h>
+
 #include <sstream>
 #include <string>
 #include <vector>
 
+#include "clock.h"
 #include "log.h"
 #include "properties.h"
 #include "string_conversions.h"
-#include "clock.h"
 #include "wv_cdm_constants.h"
 
 namespace wvcdm {
@@ -59,7 +59,6 @@ void PolicyEngine::OnTimerEvent(bool* event_occurred, CdmEventType* event) {
 
   // Test to determine if renewal should be attempted.
   switch (license_state_) {
-    case kLicenseStateInitialPendingUsage:
     case kLicenseStateCanPlay: {
       if (IsRenewalDelayExpired(current_time))
         renewal_needed = true;
@@ -115,11 +114,6 @@ void PolicyEngine::UpdateLicense(
 
   policy_.MergeFrom(license.policy());
 
-  if (!policy_.can_play()) {
-    license_state_ = kLicenseStateExpired;
-    return;
-  }
-
   // some basic license validation
   if (license_state_ == kLicenseStateInitial) {
     // license start time needs to be present in the initial response
@@ -158,20 +152,23 @@ void PolicyEngine::UpdateLicense(
     policy_max_duration_seconds_ = policy_.license_duration_seconds();
   }
 
+  if (!policy_.can_play()) {
+    license_state_ = kLicenseStateExpired;
+    return;
+  }
+
+  if (IsLicenseDurationExpired(current_time)) return;
+  if (IsPlaybackDurationExpired(current_time)) return;
+
   // Update state
-  if (license_state_ == kLicenseStateInitial) {
-    license_state_ = kLicenseStateInitialPendingUsage;
-  }
-  else {
-    license_state_ = kLicenseStateCanPlay;
-    can_decrypt_ = true;
-  }
+  license_state_ = kLicenseStateCanPlay;
+  can_decrypt_ = true;
 }
 
 void PolicyEngine::BeginDecryption() {
   if (playback_start_time_ == 0) {
     switch (license_state_) {
-      case kLicenseStateInitialPendingUsage:
+      case kLicenseStateCanPlay:
       case kLicenseStateNeedRenewal:
       case kLicenseStateWaitingLicenseUpdate:
         playback_start_time_ = clock_->GetCurrentTime();
@@ -179,12 +176,7 @@ void PolicyEngine::BeginDecryption() {
         if (policy_.renew_with_usage()) {
           license_state_ = kLicenseStateNeedRenewal;
         }
-        else {
-          license_state_ = kLicenseStateCanPlay;
-          can_decrypt_ = true;
-        }
         break;
-      case kLicenseStateCanPlay:
       case kLicenseStateInitial:
       case kLicenseStateExpired:
       default:
@@ -209,17 +201,10 @@ CdmResponseType PolicyEngine::Query(CdmQueryMap* key_info) {
     QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
   (*key_info)[QUERY_KEY_RENEW_ALLOWED] = policy_.can_renew() ?
     QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
-  int64_t remaining_time = policy_max_duration_seconds_ +
-      license_received_time_ - current_time;
-  if (remaining_time < 0)
-    remaining_time = 0;
-  ss << remaining_time;
+  ss << GetLicenseDurationRemaining(current_time);
   (*key_info)[QUERY_KEY_LICENSE_DURATION_REMAINING] = ss.str();
-  remaining_time = policy_.playback_duration_seconds() + playback_start_time_ -
-      current_time;
-  if (remaining_time < 0)
-    remaining_time = 0;
-  ss << remaining_time;
+  ss.str("");
+  ss << GetPlaybackDurationRemaining(current_time);
   (*key_info)[QUERY_KEY_PLAYBACK_DURATION_REMAINING] = ss.str();
   (*key_info)[QUERY_KEY_RENEWAL_SERVER_URL] = policy_.renewal_server_url();
 
@@ -240,6 +225,16 @@ bool PolicyEngine::IsLicenseDurationExpired(int64_t current_time) {
       current_time;
 }
 
+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;
+
+  if (remaining_time < 0) remaining_time = 0;
+  return remaining_time;
+}
+
 bool PolicyEngine::IsPlaybackDurationExpired(int64_t current_time) {
   return (policy_.playback_duration_seconds() > 0) &&
       playback_start_time_ &&
@@ -247,6 +242,17 @@ bool PolicyEngine::IsPlaybackDurationExpired(int64_t current_time) {
       current_time;
 }
 
+int64_t PolicyEngine::GetPlaybackDurationRemaining(int64_t current_time) {
+  if (0 == policy_.playback_duration_seconds()) return LLONG_MAX;
+  if (0 == playback_start_time_) return policy_.playback_duration_seconds();
+
+  int64_t remaining_time = policy_.playback_duration_seconds()
+      + playback_start_time_ - current_time;
+
+  if (remaining_time < 0) remaining_time = 0;
+  return remaining_time;
+}
+
 bool PolicyEngine::IsRenewalDelayExpired(int64_t current_time) {
   return policy_.can_renew() &&
       (policy_.renewal_delay_seconds() > 0) &&

core/src/properties.cpp

@@ -60,27 +60,30 @@ const CdmClientPropertySet* Properties::GetCdmClientPropertySet(
   return NULL;
 }
 
-const std::string Properties::GetSecurityLevel(const CdmSessionId& session_id) {
+bool Properties::GetSecurityLevel(const CdmSessionId& session_id,
+                                  std::string* security_level) {
   const CdmClientPropertySet* property_set =
       GetCdmClientPropertySet(session_id);
   if (NULL == property_set) {
     LOGE("Properties::GetSecurityLevel: cannot find property set for %s",
          session_id.c_str());
-    return "";
+    return false;
   }
-  return property_set->security_level();
+  *security_level = property_set->security_level();
+  return true;
 }
 
-const std::vector<uint8_t> Properties::GetServiceCertificate(
-    const CdmSessionId& session_id) {
+bool Properties::GetServiceCertificate(const CdmSessionId& session_id,
+                                       std::string* service_certificate) {
   const CdmClientPropertySet* property_set =
       GetCdmClientPropertySet(session_id);
   if (NULL == property_set) {
     LOGE("Properties::GetServiceCertificate: cannot find property set for %s",
          session_id.c_str());
-    return std::vector<uint8_t>();
+    return false;
   }
-  return property_set->service_certificate();
+  *service_certificate = property_set->service_certificate();
+  return true;
 }
 
 bool Properties::UsePrivacyMode(const CdmSessionId& session_id) {