Source release v3.2.0

core/include/cdm_engine.h

@@ -4,14 +4,18 @@
 #define WVCDM_CORE_CDM_ENGINE_H_
 
 #include <string>
+#include <vector>
 
 #include "certificate_provisioning.h"
+#include "clock.h"
 #include "crypto_session.h"
 #include "file_store.h"
 #include "initialization_data.h"
 #include "lock.h"
 #include "oemcrypto_adapter.h"
 #include "scoped_ptr.h"
+#include "service_certificate.h"
+#include "wv_cdm_constants.h"
 #include "wv_cdm_types.h"
 
 namespace wvcdm {
@@ -23,28 +27,41 @@ class UsagePropertySet;
 class WvCdmEventListener;
 
 typedef std::map<CdmSessionId, CdmSession*> CdmSessionMap;
-typedef std::map<CdmKeySetId, CdmSessionId> CdmReleaseKeySetMap;
+typedef std::map<
+    CdmKeySetId,
+    std::pair<CdmSessionId, int64_t /* expiration time in seconds */> >
+    CdmReleaseKeySetMap;
 
 class CdmEngine {
  public:
-  CdmEngine(FileSystem* file_system);
+  CdmEngine(FileSystem* file_system, const std::string& spoid = EMPTY_SPOID);
   virtual ~CdmEngine();
 
+  // Set service certificate for all sessions under this CDM/CdmEngine.
+  // Setting to the empty string is OK. If the License Service certificate is
+  // empty and privacy mode is true, the certificate will be fetched from
+  // the server before the first license request.
+  virtual CdmResponseType SetServiceCertificate(
+      const std::string& certificate);
+
   // Session related methods
-  virtual CdmResponseType OpenSession(const CdmKeySystem& key_system,
-                                      CdmClientPropertySet* property_set,
-                                      const CdmSessionId& forced_session_id,
-                                      WvCdmEventListener* event_listener);
-  virtual CdmResponseType OpenSession(const CdmKeySystem& key_system,
-                                      CdmClientPropertySet* property_set,
-                                      WvCdmEventListener* event_listener,
-                                      CdmSessionId* session_id);
+  virtual CdmResponseType OpenSession(
+      const CdmKeySystem& key_system, CdmClientPropertySet* property_set,
+      const CdmSessionId& forced_session_id,
+      WvCdmEventListener* event_listener);
+
+  virtual CdmResponseType OpenSession(
+      const CdmKeySystem& key_system, CdmClientPropertySet* property_set,
+      WvCdmEventListener* event_listener, CdmSessionId* session_id);
+
   virtual CdmResponseType CloseSession(const CdmSessionId& session_id);
+
   virtual bool IsOpenSession(const CdmSessionId& session_id);
 
-  virtual CdmResponseType OpenKeySetSession(const CdmKeySetId& key_set_id,
-                                            CdmClientPropertySet* property_set,
-                                            WvCdmEventListener* event_listener);
+  virtual CdmResponseType OpenKeySetSession(
+      const CdmKeySetId& key_set_id, CdmClientPropertySet* property_set,
+      WvCdmEventListener* event_listener);
+
   virtual CdmResponseType CloseKeySetSession(const CdmKeySetId& key_set_id);
 
   // License related methods
@@ -122,19 +139,32 @@ class CdmEngine {
   virtual CdmResponseType QueryOemCryptoSessionId(
       const CdmSessionId& session_id, CdmQueryMap* query_response);
 
-  // Provisioning related methods
+  // Generate and return a valid provisioning request.
   virtual CdmResponseType GetProvisioningRequest(
       CdmCertificateType cert_type, const std::string& cert_authority,
       CdmProvisioningRequest* request, std::string* default_url);
 
+  // Verify and process a provisioning response.
   virtual CdmResponseType HandleProvisioningResponse(
       const CdmProvisioningResponse& response, std::string* cert,
       std::string* wrapped_key);
 
+  // Return true if there is a device certificate on the current
+  // (origin-specific) file system.
   virtual bool IsProvisioned(CdmSecurityLevel security_level);
 
+  // Remove provisioning-related from the current (origin-specific) file system.
+  // This will force the device to reprovision itself.
   virtual CdmResponseType Unprovision(CdmSecurityLevel security_level);
 
+  // Delete OEMCrypto usage tables. Used by Unprovision().
+  CdmResponseType DeleteUsageTable(CdmSecurityLevel security_level);
+
+  // Return the list of key_set_ids stored on the current (origin-specific)
+  // file system.
+  virtual CdmResponseType ListStoredLicenses(
+      CdmSecurityLevel security_level, std::vector<std::string>* key_set_ids);
+
   // Usage related methods for streaming licenses
   // Retrieve a random usage info from the list of all usage infos for this app
   // id.
@@ -191,8 +221,9 @@ class CdmEngine {
   virtual bool IsKeyLoaded(const KeyId& key_id);
   virtual bool FindSessionForKey(const KeyId& key_id, CdmSessionId* sessionId);
 
-  // Used for notifying the Max-Res Engine of resolution changes
-  virtual void NotifyResolution(const CdmSessionId& session_id, uint32_t width,
+  // Used for notifying the Max-Res Engine of resolution changes.
+  // Return false if no match is found for session_id.
+  virtual bool NotifyResolution(const CdmSessionId& session_id, uint32_t width,
                                 uint32_t height);
 
   // Timer expiration method. This method is not re-entrant -- there can be
@@ -206,11 +237,10 @@ class CdmEngine {
 
  private:
   // private methods
-  CdmResponseType OpenSession(const CdmKeySystem& key_system,
-                              CdmClientPropertySet* property_set,
-                              WvCdmEventListener* event_listener,
-                              const CdmSessionId* forced_session_id,
-                              CdmSessionId* session_id);
+  CdmResponseType OpenSession(
+      const CdmKeySystem& key_system, CdmClientPropertySet* property_set,
+      WvCdmEventListener* event_listener, const CdmSessionId* forced_session_id,
+      CdmSessionId* session_id);
 
   void DeleteAllUsageReportsUponFactoryReset();
   bool ValidateKeySystem(const CdmKeySystem& key_system);
@@ -222,15 +252,25 @@ class CdmEngine {
 
   std::string MapHdcpVersion(CryptoSession::HdcpCapability version);
 
+  void CloseExpiredReleaseSessions();
+
   // instance variables
   CdmSessionMap sessions_;
   CdmReleaseKeySetMap release_key_sets_;
   scoped_ptr<CertificateProvisioning> cert_provisioning_;
   SecurityLevel cert_provisioning_requested_security_level_;
   FileSystem* file_system_;
+  Clock clock_;
+  std::string spoid_;
 
   static bool seeded_;
 
+  // Service certificate for license server and provisioning server.
+  // It is initially empty.  If left empty, the operations that
+  // require them (getting provider_id, encrypting ClientIdentification)
+  // are not performed.
+  ServiceCertificate service_certificate_;
+
   // usage related variables
   scoped_ptr<CdmSession> usage_session_;
   scoped_ptr<UsagePropertySet> usage_property_set_;
@@ -244,6 +284,8 @@ class CdmEngine {
   // occur simultaneously with OpenSession or CloseSession.
   Lock session_list_lock_;
 
+  Lock release_key_sets_lock_;
+
   CORE_DISALLOW_COPY_AND_ASSIGN(CdmEngine);
 };