Source release v2.1.4-0-804 + third_party libs

Change-Id: I1db8582efba613fa8a2b91a9c2697c5dfb2a8abf

core/include/cdm_engine.h

@@ -3,15 +3,16 @@
 #ifndef WVCDM_CORE_CDM_ENGINE_H_
 #define WVCDM_CORE_CDM_ENGINE_H_
 
+#include "cdm_session.h"
 #include "certificate_provisioning.h"
 #include "initialization_data.h"
 #include "oemcrypto_adapter.h"
+#include "scoped_ptr.h"
 #include "wv_cdm_types.h"
 
 namespace wvcdm {
 
 class CdmClientPropertySet;
-class CdmSession;
 class CryptoEngine;
 class WvCdmEventListener;
 
@@ -121,8 +122,11 @@ class CdmEngine {
   CdmReleaseKeySetMap release_key_sets_;
   CertificateProvisioning cert_provisioning_;
   SecurityLevel cert_provisioning_requested_security_level_;
-  CdmSession* usage_session_;
 
+  static bool seeded_;
+
+  // usage related variables
+  scoped_ptr<CdmSession> usage_session_;
   int64_t last_usage_information_update_time;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(CdmEngine);

core/include/cdm_session.h

@@ -31,11 +31,6 @@ class CdmSession {
   virtual CdmResponseType RestoreUsageSession(
       const CdmKeyMessage& key_request, const CdmKeyResponse& key_response);
 
-  virtual void set_key_system(const CdmKeySystem& ksystem) {
-    key_system_ = ksystem;
-  }
-  virtual const CdmKeySystem& key_system() { return key_system_; }
-
   virtual const CdmSessionId& session_id() { return session_id_; }
 
   virtual CdmResponseType GenerateKeyRequest(
@@ -99,6 +94,11 @@ class CdmSession {
   }
 
  private:
+  // Internal constructor
+  void Create(CdmLicense* license_parser, CryptoSession* crypto_session,
+              PolicyEngine* policy_engine, DeviceFiles* file_handle,
+              const CdmClientPropertySet* cdm_client_property_set);
+
   // Generate unique ID for each new session.
   CdmSessionId GenerateSessionId();
   bool GenerateKeySetId(CdmKeySetId* key_set_id);
@@ -108,17 +108,18 @@ class CdmSession {
   bool DeleteLicense();
 
   // instance variables
-  const CdmSessionId session_id_;
-  CdmKeySystem key_system_;
-  CdmLicense license_parser_;
+  bool initialized_;
+  CdmSessionId session_id_;
+  scoped_ptr<CdmLicense> license_parser_;
   scoped_ptr<CryptoSession> crypto_session_;
-  PolicyEngine policy_engine_;
+  scoped_ptr<PolicyEngine> policy_engine_;
+  scoped_ptr<DeviceFiles> file_handle_;
   bool license_received_;
-  bool reinitialize_session_;
   bool is_offline_;
   bool is_release_;
   bool is_usage_update_needed_;
   bool is_initial_decryption_;
+  CdmSecurityLevel security_level_;
 
   // information useful for offline and usage scenarios
   CdmKeyMessage key_request_;
@@ -133,12 +134,18 @@ class CdmSession {
   // license type release and offline related information
   CdmKeySetId key_set_id_;
 
-  // Used for certificate based licensing
-  std::string wrapped_key_;
-  bool is_certificate_loaded_;
-
   std::set<WvCdmEventListener*> listeners_;
 
+  // For testing only
+  // Takes ownership of license_parser, crypto_session, policy_engine
+  // and device_files
+  CdmSession(CdmLicense* license_parser, CryptoSession* crypto_session,
+             PolicyEngine* policy_engine, DeviceFiles* file_handle,
+             const CdmClientPropertySet* cdm_client_property_set);
+#if defined(UNIT_TEST)
+  friend class CdmSessionTest;
+#endif
+
   CORE_DISALLOW_COPY_AND_ASSIGN(CdmSession);
 };
 

core/include/crypto_session.h

@@ -25,6 +25,7 @@ class CryptoSession {
   virtual bool GetToken(std::string* token);
   virtual CdmSecurityLevel GetSecurityLevel();
   virtual bool GetDeviceUniqueId(std::string* device_id);
+  virtual bool GetApiVersion(uint32_t* version);
   virtual bool GetSystemId(uint32_t* system_id);
   virtual bool GetProvisioningId(std::string* provisioning_id);
 

core/include/device_files.h

@@ -3,6 +3,7 @@
 #ifndef WVCDM_CORE_DEVICE_FILES_H_
 #define WVCDM_CORE_DEVICE_FILES_H_
 
+#include "scoped_ptr.h"
 #include "wv_cdm_types.h"
 
 #if defined(UNIT_TEST)
@@ -21,11 +22,13 @@ class DeviceFiles {
     kLicenseStateUnknown,
   } LicenseState;
 
-  DeviceFiles(): file_(NULL), security_level_(kSecurityLevelUninitialized),
-                 initialized_(false), test_file_(false) {}
+  DeviceFiles();
   virtual ~DeviceFiles();
 
   virtual bool Init(CdmSecurityLevel security_level);
+  virtual bool Reset(CdmSecurityLevel security_level) {
+      return Init(security_level);
+  }
 
   virtual bool StoreCertificate(const std::string& certificate,
                                 const std::string& wrapped_private_key);
@@ -93,7 +96,7 @@ class DeviceFiles {
   FRIEND_TEST(WvCdmUsageInfoTest, DISABLED_UsageInfo);
 #endif
 
-  File* file_;
+  scoped_ptr<File> file_;
   CdmSecurityLevel security_level_;
   bool initialized_;
 

core/include/policy_engine.h

@@ -60,6 +60,7 @@ class PolicyEngine {
  private:
   typedef enum {
     kLicenseStateInitial,
+    kLicenseStatePending,  // if license is issued for sometime in the future
     kLicenseStateCanPlay,
     kLicenseStateNeedRenewal,
     kLicenseStateWaitingLicenseUpdate,
@@ -91,18 +92,14 @@ class PolicyEngine {
   // from the license server we will get an updated id field.
   video_widevine_server::sdk::LicenseIdentification license_id_;
 
-  // This is the license start time that gets sent from the server in each
-  // license request or renewal.
+  // The server returns the license start time in the license/license renewal
+  // response based off the request time sent by the client in the
+  // license request/renewal
   int64_t license_start_time_;
-
-  // This is the time at which the license was received and playback was
-  // started. These times are based off the local clock in case there is a
-  // discrepency between local and server time.
-  int64_t license_received_time_;
   int64_t playback_start_time_;
 
   // This is used as a reference point for policy management. This value
-  // represents an offset from license_received_time_. This is used to
+  // represents an offset from license_start_time_. This is used to
   // calculate the time where renewal retries should occur.
   int64_t next_renewal_time_;
   int64_t policy_max_duration_seconds_;

core/include/properties.h

@@ -87,6 +87,14 @@ class Properties {
     security_level_path_backward_compatibility_support_ = flag;
   }
 
+#if defined(UNIT_TEST)
+  FRIEND_TEST(CdmSessionTest, InitWithCertificate);
+  FRIEND_TEST(CdmSessionTest, InitWithKeybox);
+  FRIEND_TEST(CdmSessionTest, ReInitFail);
+  FRIEND_TEST(CdmSessionTest, InitFailCryptoError);
+  FRIEND_TEST(CdmSessionTest, InitNeedsProvisioning);
+#endif
+
  private:
   static bool oem_crypto_use_secure_buffers_;
   static bool oem_crypto_use_fifo_;