Update ClearKeyCdm to use CDM_3.

Chrome now supports CDM_3, so update the ClearKeyCdm implementation to use the new interface.

BUG=224786
TEST=encrypted-media layout tests and browser_tests for encrypted media pass

Review URL: https://codereview.chromium.org/102503002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@241759 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 78 insertions, 187 deletions

diff --git a/media/cdm/ppapi/clear_key_cdm.cc b/media/cdm/ppapi/clear_key_cdm.cc
index 6d3a68c..16a00a5 100644
--- a/media/cdm/ppapi/clear_key_cdm.cc
+++ b/media/cdm/ppapi/clear_key_cdm.cc
@@ -158,64 +158,16 @@ const char* GetCdmVersion() {
 
 namespace media {
 
-// Since all the calls to AesDecryptor are synchronous, pass a dummy value for
-// session_id that is never exposed outside this class.
-// TODO(jrummell): Remove usage of this when the CDM interface is updated
-// to use session_id.
-
-ClearKeyCdm::Client::Client()
-    : status_(kNone), error_code_(MediaKeys::kUnknownError), system_code_(0) {}
-
-ClearKeyCdm::Client::~Client() {}
-
-void ClearKeyCdm::Client::Reset() {
-  status_ = kNone;
-  web_session_id_.clear();
-  message_.clear();
-  destination_url_.clear();
-  error_code_ = MediaKeys::kUnknownError;
-  system_code_ = 0;
-}
-
-void ClearKeyCdm::Client::OnSessionCreated(uint32 session_id,
-                                           const std::string& web_session_id) {
-  status_ = static_cast<Status>(status_ | kCreated);
-  web_session_id_ = web_session_id;
-}
-
-void ClearKeyCdm::Client::OnSessionMessage(uint32 session_id,
-                                           const std::vector<uint8>& message,
-                                           const std::string& destination_url) {
-  status_ = static_cast<Status>(status_ | kMessage);
-  message_ = message;
-  destination_url_ = destination_url;
-}
-
-void ClearKeyCdm::Client::OnSessionReady(uint32 session_id) {
-  status_ = static_cast<Status>(status_ | kReady);
-}
-
-void ClearKeyCdm::Client::OnSessionClosed(uint32 session_id) {
-  status_ = static_cast<Status>(status_ | kClosed);
-}
-
-void ClearKeyCdm::Client::OnSessionError(uint32 session_id,
-                                         media::MediaKeys::KeyError error_code,
-                                         int system_code) {
-  status_ = static_cast<Status>(status_ | kError);
-  error_code_ = error_code;
-  system_code_ = system_code;
-}
-
 ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host, bool is_decrypt_only)
     : decryptor_(
-          base::Bind(&Client::OnSessionCreated, base::Unretained(&client_)),
-          base::Bind(&Client::OnSessionMessage, base::Unretained(&client_)),
-          base::Bind(&Client::OnSessionReady, base::Unretained(&client_)),
-          base::Bind(&Client::OnSessionClosed, base::Unretained(&client_)),
-          base::Bind(&Client::OnSessionError, base::Unretained(&client_))),
+          base::Bind(&ClearKeyCdm::OnSessionCreated, base::Unretained(this)),
+          base::Bind(&ClearKeyCdm::OnSessionMessage, base::Unretained(this)),
+          base::Bind(&ClearKeyCdm::OnSessionReady, base::Unretained(this)),
+          base::Bind(&ClearKeyCdm::OnSessionClosed, base::Unretained(this)),
+          base::Bind(&ClearKeyCdm::OnSessionError, base::Unretained(this))),
       host_(host),
       is_decrypt_only_(is_decrypt_only),
+      heartbeat_session_id_(0),
       timer_delay_ms_(kInitialTimerDelayMs),
       timer_set_(false) {
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
@@ -229,82 +181,34 @@ ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host, bool is_decrypt_only)
 
 ClearKeyCdm::~ClearKeyCdm() {}
 
-cdm::Status ClearKeyCdm::GenerateKeyRequest(const char* type,
-                                            uint32_t type_size,
-                                            const uint8_t* init_data,
-                                            uint32_t init_data_size) {
-  DVLOG(1) << "GenerateKeyRequest()";
-  base::AutoLock auto_lock(client_lock_);
-  ScopedResetter<Client> auto_resetter(&client_);
-  decryptor_.CreateSession(MediaKeys::kInvalidSessionId,
-                           std::string(type, type_size),
-                           init_data, init_data_size);
-
-  if (client_.status() != (Client::kMessage | Client::kCreated)) {
-    // Use values returned to client if possible.
-    host_->SendKeyError(client_.web_session_id().data(),
-                        client_.web_session_id().size(),
-                        static_cast<cdm::MediaKeyError>(client_.error_code()),
-                        client_.system_code());
-    return cdm::kSessionError;
-  }
-
-  host_->SendKeyMessage(
-      client_.web_session_id().data(), client_.web_session_id().size(),
-      reinterpret_cast<const char*>(&client_.message()[0]),
-      client_.message().size(),
-      client_.destination_url().data(), client_.destination_url().size());
+void ClearKeyCdm::CreateSession(uint32 session_id,
+                                const char* type,
+                                uint32 type_size,
+                                const uint8* init_data,
+                                uint32 init_data_size) {
+  DVLOG(1) << __FUNCTION__;
+  decryptor_.CreateSession(
+      session_id, std::string(type, type_size), init_data, init_data_size);
 
   // Only save the latest session ID for heartbeat messages.
-  heartbeat_session_id_ = client_.web_session_id();
-
-  return cdm::kSuccess;
+  heartbeat_session_id_ = session_id;
 }
 
-cdm::Status ClearKeyCdm::AddKey(const char* session_id,
-                                uint32_t session_id_size,
-                                const uint8_t* key,
-                                uint32_t key_size,
-                                const uint8_t* key_id,
-                                uint32_t key_id_size) {
-  DVLOG(1) << "AddKey()";
-  DCHECK(!key_id && !key_id_size);
-  base::AutoLock auto_lock(client_lock_);
-  ScopedResetter<Client> auto_resetter(&client_);
-  decryptor_.UpdateSession(MediaKeys::kInvalidSessionId, key, key_size);
-
-  if (client_.status() != Client::kReady) {
-    host_->SendKeyError(session_id, session_id_size,
-                        static_cast<cdm::MediaKeyError>(client_.error_code()),
-                        client_.system_code());
-    return cdm::kSessionError;
-  }
+void ClearKeyCdm::UpdateSession(uint32 session_id,
+                                const uint8* response,
+                                uint32 response_size) {
+  DVLOG(1) << __FUNCTION__;
+  decryptor_.UpdateSession(session_id, response, response_size);
 
   if (!timer_set_) {
     ScheduleNextHeartBeat();
     timer_set_ = true;
   }
-
-  return cdm::kSuccess;
 }
 
-cdm::Status ClearKeyCdm::CancelKeyRequest(const char* session_id,
-                                          uint32_t session_id_size) {
-  DVLOG(1) << "CancelKeyRequest()";
-  base::AutoLock auto_lock(client_lock_);
-  ScopedResetter<Client> auto_resetter(&client_);
-  decryptor_.ReleaseSession(MediaKeys::kInvalidSessionId);
-
-  // No message normally sent by Release(), but if an error occurred,
-  // report it as a failure.
-  if (client_.status() == Client::kError) {
-    host_->SendKeyError(session_id, session_id_size,
-                        static_cast<cdm::MediaKeyError>(client_.error_code()),
-                        client_.system_code());
-    return cdm::kSessionError;
-  }
-
-  return cdm::kSuccess;
+void ClearKeyCdm::ReleaseSession(uint32 session_id) {
+  DVLOG(1) << __FUNCTION__;
+  decryptor_.ReleaseSession(session_id);
 }
 
 void ClearKeyCdm::TimerExpired(void* context) {
@@ -320,10 +224,11 @@ void ClearKeyCdm::TimerExpired(void* context) {
   // There is no service at this URL, so applications should ignore it.
   const char url[] = "http://test.externalclearkey.chromium.org";
 
-  host_->SendKeyMessage(
-      heartbeat_session_id_.data(), heartbeat_session_id_.size(),
-      heartbeat_message.data(), heartbeat_message.size(),
-      url, arraysize(url) - 1);
+  host_->OnSessionMessage(heartbeat_session_id_,
+                          heartbeat_message.data(),
+                          heartbeat_message.size(),
+                          url,
+                          arraysize(url) - 1);
 
   ScheduleNextHeartBeat();
 }
@@ -562,6 +467,36 @@ void ClearKeyCdm::OnQueryOutputProtectionStatus(
   NOTIMPLEMENTED();
 };
 
+void ClearKeyCdm::OnSessionCreated(uint32 reference_id,
+                                   const std::string& session_id) {
+  host_->OnSessionCreated(reference_id, session_id.data(), session_id.size());
+}
+
+void ClearKeyCdm::OnSessionMessage(uint32 reference_id,
+                                   const std::vector<uint8>& message,
+                                   const std::string& destination_url) {
+  host_->OnSessionMessage(reference_id,
+                          reinterpret_cast<const char*>(message.data()),
+                          message.size(),
+                          destination_url.data(),
+                          destination_url.size());
+}
+
+void ClearKeyCdm::OnSessionReady(uint32 reference_id) {
+  host_->OnSessionReady(reference_id);
+}
+
+void ClearKeyCdm::OnSessionClosed(uint32 reference_id) {
+  host_->OnSessionClosed(reference_id);
+}
+
+void ClearKeyCdm::OnSessionError(uint32 reference_id,
+                                 media::MediaKeys::KeyError error_code,
+                                 int system_code) {
+  host_->OnSessionError(
+      reference_id, static_cast<cdm::MediaKeyError>(error_code), system_code);
+}
+
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
 int64 ClearKeyCdm::CurrentTimeStampInMicroseconds() const {
   return output_timestamp_base_in_microseconds_ +
diff --git a/media/cdm/ppapi/clear_key_cdm.h b/media/cdm/ppapi/clear_key_cdm.h
index 0ec18a1..87f45e1 100644
--- a/media/cdm/ppapi/clear_key_cdm.h
+++ b/media/cdm/ppapi/clear_key_cdm.h
@@ -34,17 +34,14 @@ class ClearKeyCdm : public ClearKeyCdmInterface {
   virtual ~ClearKeyCdm();
 
   // ContentDecryptionModule implementation.
-  virtual cdm::Status GenerateKeyRequest(
-      const char* type, uint32_t type_size,
-      const uint8_t* init_data, uint32_t init_data_size) OVERRIDE;
-  virtual cdm::Status AddKey(const char* session_id,
-                             uint32_t session_id_size,
-                             const uint8_t* key,
-                             uint32_t key_size,
-                             const uint8_t* key_id,
-                             uint32_t key_id_size) OVERRIDE;
-  virtual cdm::Status CancelKeyRequest(const char* session_id,
-                                       uint32_t session_id_size) OVERRIDE;
+  virtual void CreateSession(
+      uint32 session_id,
+      const char* type, uint32 type_size,
+      const uint8* init_data, uint32 init_data_size) OVERRIDE;
+  virtual void UpdateSession(
+      uint32 session_id,
+      const uint8* response, uint32 response_size) OVERRIDE;
+  virtual void ReleaseSession(uint32 session_id) OVERRIDE;
   virtual void TimerExpired(void* context) OVERRIDE;
   virtual cdm::Status Decrypt(const cdm::InputBuffer& encrypted_buffer,
                               cdm::DecryptedBlock* decrypted_block) OVERRIDE;
@@ -67,52 +64,16 @@ class ClearKeyCdm : public ClearKeyCdmInterface {
       uint32_t link_mask, uint32_t output_protection_mask) OVERRIDE;
 
  private:
-  // TODO(xhwang): After we removed DecryptorClient. We probably can also remove
-  // this Client class as well. Investigate this possibility.
-  class Client {
-   public:
-    // TODO(jrummell): Remove bitmask and rename kNone to kInvalid once CDM
-    // interface supports session_id passing completely.
-    enum Status {
-      kNone = 0,
-      kCreated = 1 << 0,
-      kMessage = 1 << 1,
-      kReady = 1 << 2,
-      kClosed = 1 << 3,
-      kError = 1 << 4
-    };
-
-    Client();
-    virtual ~Client();
-
-    Status status() { return status_; }
-    const std::string& web_session_id() { return web_session_id_; }
-    const std::vector<uint8>& message() { return message_; }
-    const std::string& destination_url() { return destination_url_; }
-    MediaKeys::KeyError error_code() { return error_code_; }
-    int system_code() { return system_code_; }
-
-    // Resets the Client to a clean state.
-    void Reset();
-
-    void OnSessionCreated(uint32 session_id, const std::string& web_session_id);
-    void OnSessionMessage(uint32 session_id,
-                          const std::vector<uint8>& message,
-                          const std::string& destination_url);
-    void OnSessionReady(uint32 session_id);
-    void OnSessionClosed(uint32 session_id);
-    void OnSessionError(uint32 session_id,
-                        MediaKeys::KeyError error_code,
-                        int system_code);
-
-   private:
-    Status status_;
-    std::string web_session_id_;
-    std::vector<uint8> message_;
-    std::string destination_url_;
-    MediaKeys::KeyError error_code_;
-    int system_code_;
-  };
+  // ContentDecryptionModule callbacks.
+  void OnSessionCreated(uint32 reference_id, const std::string& session_id);
+  void OnSessionMessage(uint32 reference_id,
+                        const std::vector<uint8>& message,
+                        const std::string& destination_url);
+  void OnSessionReady(uint32 reference_id);
+  void OnSessionClosed(uint32 reference_id);
+  void OnSessionError(uint32 reference_id,
+                      MediaKeys::KeyError error_code,
+                      int system_code);
 
   // Prepares next heartbeat message and sets a timer for it.
   void ScheduleNextHeartBeat();
@@ -143,18 +104,13 @@ class ClearKeyCdm : public ClearKeyCdmInterface {
                                       cdm::AudioFrames* audio_frames);
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 
-  Client client_;
   AesDecryptor decryptor_;
 
-  // Protects the |client_| from being accessed by the |decryptor_|
-  // simultaneously.
-  base::Lock client_lock_;
-
   ClearKeyCdmHost* host_;
 
   const bool is_decrypt_only_;
 
-  std::string heartbeat_session_id_;
+  uint32 heartbeat_session_id_;
   std::string next_heartbeat_message_;
 
   // Timer delay in milliseconds for the next host_->SetTimer() call.
diff --git a/media/cdm/ppapi/clear_key_cdm_common.h b/media/cdm/ppapi/clear_key_cdm_common.h
index 8f84397..39727b9 100644
--- a/media/cdm/ppapi/clear_key_cdm_common.h
+++ b/media/cdm/ppapi/clear_key_cdm_common.h
@@ -10,7 +10,7 @@
 namespace media {
 
 // Aliases for the version of the interfaces that this CDM implements.
-typedef cdm::ContentDecryptionModule_2 ClearKeyCdmInterface;
+typedef cdm::ContentDecryptionModule_3 ClearKeyCdmInterface;
 typedef ClearKeyCdmInterface::Host ClearKeyCdmHost;
 
 }  // namespace media