Source release v2.1.2-0-773 + third_party libs

Change-Id: Ia07608577b65b301c22a8ff4bf7f743c2d3f9274

core/include/cdm_engine.h

@@ -88,10 +88,11 @@ class CdmEngine {
       std::string* cert,
       std::string* wrapped_key);
 
-  // Secure stop related methods
-  CdmResponseType GetSecureStops(CdmSecureStops* secure_stops);
-  CdmResponseType ReleaseSecureStops(
-      const CdmSecureStopReleaseMessage& message);
+  CdmResponseType Unprovision(CdmSecurityLevel security_level);
+
+  // Usage related methods for streaming licenses
+  CdmResponseType GetUsageInfo(CdmUsageInfo* usage_info);
+  CdmResponseType ReleaseUsageInfo(const CdmUsageInfoReleaseMessage& message);
 
   // Decryption and key related methods
   // Accept encrypted buffer and return decrypted data.
@@ -124,6 +125,9 @@ class CdmEngine {
   CdmReleaseKeySetMap release_key_sets_;
   CertificateProvisioning cert_provisioning_;
   SecurityLevel cert_provisioning_requested_security_level_;
+  CdmSession* usage_session_;
+
+  int64_t last_usage_information_update_time;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(CdmEngine);
 };

core/include/cdm_session.h

@@ -28,6 +28,8 @@ class CdmSession {
 
   CdmResponseType RestoreOfflineSession(const CdmKeySetId& key_set_id,
                                         const CdmLicenseType license_type);
+  CdmResponseType RestoreUsageSession(const CdmKeyMessage& key_request,
+                                      const CdmKeyResponse& key_response);
 
   void set_key_system(const CdmKeySystem& ksystem) { key_system_ = ksystem; }
   const CdmKeySystem& key_system() { return key_system_; }
@@ -86,6 +88,12 @@ class CdmSession {
   void OnKeyReleaseEvent(const CdmKeySetId& key_set_id);
 
   SecurityLevel GetRequestedSecurityLevel();
+  CdmSecurityLevel GetSecurityLevel();
+
+  CdmResponseType UpdateUsageInformation();
+
+  bool is_usage_update_needed() { return is_usage_update_needed_; }
+  void reset_is_usage_update_needed() { is_usage_update_needed_ = false; }
 
  private:
 
@@ -93,7 +101,9 @@ class CdmSession {
   CdmSessionId GenerateSessionId();
   bool GenerateKeySetId(CdmKeySetId* key_set_id);
 
+  CdmResponseType StoreLicense();
   bool StoreLicense(DeviceFiles::LicenseState state);
+  bool DeleteLicense();
 
   // instance variables
   const CdmSessionId session_id_;
@@ -103,13 +113,16 @@ class CdmSession {
   PolicyEngine policy_engine_;
   bool license_received_;
   bool reinitialize_session_;
+  bool is_offline_;
+  bool is_release_;
+  bool is_usage_update_needed_;
 
-  CdmLicenseType license_type_;
+  // information useful for offline and usage scenarios
+  CdmKeyMessage key_request_;
+  CdmKeyResponse key_response_;
 
   // license type offline related information
   CdmInitData offline_init_data_;
-  CdmKeyMessage offline_key_request_;
-  CdmKeyResponse offline_key_response_;
   CdmKeyMessage offline_key_renewal_request_;
   CdmKeyResponse offline_key_renewal_response_;
   std::string offline_release_server_url_;

core/include/crypto_session.h

@@ -45,7 +45,8 @@ class CryptoSession {
                            const std::string& signature,
                            const std::string& mac_key_iv,
                            const std::string& mac_key,
-                           int num_keys, const CryptoKey* key_array);
+                           const std::vector<CryptoKey>& key_array,
+                           const std::string& provider_session_token);
   bool LoadCertificatePrivateKey(std::string& wrapped_key);
   bool RefreshKeys(const std::string& message, const std::string& signature,
                    int num_keys, const CryptoKey* key_array);
@@ -63,6 +64,15 @@ class CryptoSession {
   // Media data path
   CdmResponseType Decrypt(const CdmDecryptionParameters& parameters);
 
+  CdmResponseType UpdateUsageInformation();
+  CdmResponseType GenerateUsageReport(
+      const std::string& provider_session_token,
+      std::string* usage_report);
+  CdmResponseType ReleaseUsageInformation(
+      const std::string& message,
+      const std::string& signature,
+      const std::string& provider_session_token);
+
   bool GetRandom(size_t data_length, uint8_t* random_data);
 
  private:

core/include/device_files.h

@@ -5,6 +5,10 @@
 
 #include "wv_cdm_types.h"
 
+#if defined(UNIT_TEST)
+#include <gtest/gtest_prod.h>
+#endif
+
 namespace wvcdm {
 
 class File;
@@ -18,10 +22,10 @@ class DeviceFiles {
   } LicenseState;
 
   DeviceFiles(): file_(NULL), security_level_(kSecurityLevelUninitialized),
-                 initialized_(false) {}
-  virtual ~DeviceFiles() {}
+                 initialized_(false), test_file_(false) {}
+  virtual ~DeviceFiles();
 
-  virtual bool Init(const File* handle, CdmSecurityLevel security_level);
+  virtual bool Init(CdmSecurityLevel security_level);
 
   virtual bool StoreCertificate(const std::string& certificate,
                                 const std::string& wrapped_private_key);
@@ -49,25 +53,52 @@ class DeviceFiles {
   virtual bool DeleteAllLicenses();
   virtual bool LicenseExists(const std::string& key_set_id);
 
-  // For testing only
-  static std::string GetCertificateFileName();
-  static std::string GetLicenseFileNameExtension();
-
- protected:
-  bool Hash(const std::string& data, std::string* hash);
-  bool StoreFile(const char* name, const std::string& data);
-  bool RetrieveFile(const char* name, std::string* data);
+  virtual bool StoreUsageInfo(const std::string& provider_session_token,
+                              const CdmKeyMessage& key_request,
+                              const CdmKeyResponse& key_response);
+  virtual bool DeleteUsageInfo(const std::string& provider_session_token);
+  virtual bool DeleteUsageInfo();
+  virtual bool RetrieveUsageInfo(
+      std::vector<std::pair<CdmKeyMessage, CdmKeyResponse> >* usage_info);
 
  private:
+  bool StoreFile(const char* name, const std::string& serialized_file);
+  bool RetrieveFile(const char* name, std::string* serialized_file);
+
   // Certificate and offline licenses are now stored in security
   // level specific directories. In an earlier version they were
   // stored in a common directory and need to be copied over.
   virtual void SecurityLevelPathBackwardCompatibility();
 
+  // For testing only:
+  static std::string GetCertificateFileName();
+  static std::string GetLicenseFileNameExtension();
+  static std::string GetUsageInfoFileName();
+  void SetTestFile(File* file);
+#if defined(UNIT_TEST)
+  FRIEND_TEST(DeviceFilesSecurityLevelTest, SecurityLevel);
+  FRIEND_TEST(DeviceFilesStoreTest, StoreCertificate);
+  FRIEND_TEST(DeviceFilesStoreTest, StoreLicense);
+  FRIEND_TEST(DeviceFilesTest, DeleteLicense);
+  FRIEND_TEST(DeviceFilesTest, ReadCertificate);
+  FRIEND_TEST(DeviceFilesTest, RetrieveLicenses);
+  FRIEND_TEST(DeviceFilesTest, SecurityLevelPathBackwardCompatibility);
+  FRIEND_TEST(DeviceFilesTest, StoreLicenses);
+  FRIEND_TEST(DeviceFilesTest, UpdateLicenseState);
+  FRIEND_TEST(DeviceFilesUsageInfoTest, Delete);
+  FRIEND_TEST(DeviceFilesUsageInfoTest, Read);
+  FRIEND_TEST(DeviceFilesUsageInfoTest, Store);
+  FRIEND_TEST(WvCdmRequestLicenseTest, UnprovisionTest);
+  FRIEND_TEST(WvCdmRequestLicenseTest, ForceL3Test);
+  FRIEND_TEST(WvCdmUsageInfoTest, DISABLED_UsageInfo);
+#endif
+
   File* file_;
   CdmSecurityLevel security_level_;
   bool initialized_;
 
+  bool test_file_;
+
   CORE_DISALLOW_COPY_AND_ASSIGN(DeviceFiles);
 };
 

core/include/file_store.h

@@ -7,6 +7,9 @@
 
 #include "wv_cdm_types.h"
 
+#include <stddef.h>
+#include <stdlib.h>
+
 namespace wvcdm {
 
 // File class. The implementation is platform dependent.

core/include/license.h

@@ -40,12 +40,16 @@ class CdmLicense {
   CdmResponseType HandleKeyUpdateResponse(
       bool is_renewal, const CdmKeyResponse& license_response);
 
-  bool RestoreOfflineLicense(CdmKeyMessage& license_request,
-                             CdmKeyResponse& license_response,
-                             CdmKeyResponse& license_renewal_response);
+  bool RestoreOfflineLicense(const CdmKeyMessage& license_request,
+                             const CdmKeyResponse& license_response,
+                             const CdmKeyResponse& license_renewal_response);
+  bool RestoreUsageLicense(const CdmKeyMessage& license_request,
+                           const CdmKeyResponse& license_response);
   bool HasInitData() { return !stored_init_data_.empty(); }
   bool IsKeyLoaded(const KeyId& key_id);
 
+  std::string provider_session_token() { return provider_session_token_; }
+
  private:
   bool PrepareServiceCertificateRequest(CdmKeyMessage* signed_request,
                                         std::string* server_url);
@@ -67,6 +71,7 @@ class CdmLicense {
   std::string stored_init_data_;
   bool initialized_;
   std::set<KeyId> loaded_keys_;
+  std::string provider_session_token_;
 
   // Used for certificate based licensing
   CdmKeyMessage key_request_;

core/include/log.h

@@ -17,6 +17,8 @@ typedef enum {
   LOG_VERBOSE
 } LogPriority;
 
+extern LogPriority g_cutoff;
+
 // Enable/disable verbose logging (LOGV).
 // This function is supplied for cases where the system layer does not
 // initialize logging.  This is also needed to initialize logging in

core/include/privacy_crypto.h

@@ -24,30 +24,27 @@
 
 #include <string>
 
-#include "openssl/evp.h"
-#include "openssl/rsa.h"
 #include "wv_cdm_types.h"
 
 namespace wvcdm {
 
 class AesCbcKey {
  public:
-  AesCbcKey() : initialized_(false) {};
-  ~AesCbcKey() {};
+  AesCbcKey();
+  ~AesCbcKey();
 
   bool Init(const std::string& key);
   bool Encrypt(const std::string& in, std::string* out, std::string* iv);
 
  private:
-  EVP_CIPHER_CTX ctx_;
-  bool initialized_;
+  std::string key_;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(AesCbcKey);
 };
 
 class RsaPublicKey {
  public:
-  RsaPublicKey() : key_(NULL) {}
+  RsaPublicKey();
   ~RsaPublicKey();
 
   // Initializes an RsaPublicKey object using a DER encoded PKCS#1 RSAPublicKey
@@ -64,7 +61,7 @@ class RsaPublicKey {
                        const std::string& signature);
 
  private:
-  RSA* key_;
+  std::string serialized_key_;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(RsaPublicKey);
 };

core/include/wv_cdm_types.h

@@ -23,15 +23,15 @@ typedef uint32_t CryptoSessionId;
 typedef std::string CryptoKeyId;
 typedef std::map<std::string, std::string> CdmAppParameterMap;
 typedef std::map<std::string, std::string> CdmQueryMap;
-typedef std::vector<std::string> CdmSecureStops;
-typedef std::vector<uint8_t> CdmSecureStopReleaseMessage;
+typedef std::vector<std::string> CdmUsageInfo;
+typedef std::string CdmUsageInfoReleaseMessage;
 typedef std::string CdmProvisioningRequest;
 typedef std::string CdmProvisioningResponse;
 
 // Types for shared host/cdm interface pairs used to shared vendor data.
-typedef std::pair<std::string, std::string> kStringPairs;
-typedef std::vector<uint8_t> kVectorBytes;
-typedef std::pair<std::string, kVectorBytes> kVectorPairs;
+typedef std::pair<std::string, std::string> StringPairs;
+typedef std::vector<uint8_t> VectorBytes;
+typedef std::pair<std::string, VectorBytes> VectorPairs;
 
 enum CdmResponseType {
   NO_ERROR,