media: Make MediaKeys ref-counted.

media/cdm/ppapi/external_clear_key/clear_key_cdm.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cdm/ppapi/external_clear_key/clear_key_cdm.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 
@@ skipping 249 matching lines @@
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
 namespace media {
 
 ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host,
                          const std::string& key_system,
                          const GURL& origin)
-    : decryptor_(
+    : decryptor_(new AesDecryptor(
           origin,
           base::Bind(&ClearKeyCdm::OnSessionMessage, base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnSessionClosed, base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnSessionKeysChange,
-                     base::Unretained(this))),
+                     base::Unretained(this)))),
       host_(host),
       key_system_(key_system),
       has_received_keys_change_event_for_emulated_loadsession_(false),
       timer_delay_ms_(kInitialTimerDelayMs),
       renewal_timer_set_(false) {
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   channel_count_ = 0;
   bits_per_channel_ = 0;
   samples_per_second_ = 0;
   output_timestamp_base_in_microseconds_ = kNoTimestamp;
@@ skipping 18 matching lines @@
   DVLOG(1) << __FUNCTION__;
 
   scoped_ptr<media::NewSessionCdmPromise> promise(
       new media::CdmCallbackPromise<std::string>(
           base::Bind(&ClearKeyCdm::OnSessionCreated,
                      base::Unretained(this),
                      promise_id),
           base::Bind(&ClearKeyCdm::OnPromiseFailed,
                      base::Unretained(this),
                      promise_id)));
-  decryptor_.CreateSessionAndGenerateRequest(
+  decryptor_->CreateSessionAndGenerateRequest(
       ConvertSessionType(session_type), ConvertInitDataType(init_data_type),
       std::vector<uint8_t>(init_data, init_data + init_data_size),
       promise.Pass());
 
   if (key_system_ == kExternalClearKeyFileIOTestKeySystem)
     StartFileIOTest();
 }
 
 // Loads a emulated stored session. Currently only |kLoadableSessionId|
 // (containing a |kLoadableSessionKey| for |kLoadableSessionKeyId|) is
@@ skipping 15 matching lines @@
   DCHECK(session_id_for_emulated_loadsession_.empty());
 
   scoped_ptr<media::NewSessionCdmPromise> promise(
       new media::CdmCallbackPromise<std::string>(
           base::Bind(&ClearKeyCdm::OnSessionLoaded,
                      base::Unretained(this),
                      promise_id),
           base::Bind(&ClearKeyCdm::OnPromiseFailed,
                      base::Unretained(this),
                      promise_id)));
-  decryptor_.CreateSessionAndGenerateRequest(
+  decryptor_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
       std::vector<uint8_t>(), promise.Pass());
 }
 
 void ClearKeyCdm::UpdateSession(uint32 promise_id,
                                 const char* session_id,
                                 uint32_t session_id_length,
                                 const uint8* response,
                                 uint32 response_size) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
 
   // If updating the loadable session, use the actual session id generated.
   if (web_session_str == std::string(kLoadableSessionId))
     web_session_str = session_id_for_emulated_loadsession_;
 
   scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
       base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
                  promise_id),
       base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                  promise_id)));
-  decryptor_.UpdateSession(
+  decryptor_->UpdateSession(
       web_session_str, std::vector<uint8_t>(response, response + response_size),
       promise.Pass());
 
   if (!renewal_timer_set_) {
     ScheduleNextRenewal();
     renewal_timer_set_ = true;
   }
 }
 
 void ClearKeyCdm::CloseSession(uint32 promise_id,
                                const char* session_id,
                                uint32_t session_id_length) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
 
   // If closing the loadable session, use the actual session id generated.
   if (web_session_str == std::string(kLoadableSessionId))
     web_session_str = session_id_for_emulated_loadsession_;
 
   scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
       base::Bind(
           &ClearKeyCdm::OnPromiseResolved, base::Unretained(this), promise_id),
       base::Bind(
           &ClearKeyCdm::OnPromiseFailed, base::Unretained(this), promise_id)));
-  decryptor_.CloseSession(web_session_str, promise.Pass());
+  decryptor_->CloseSession(web_session_str, promise.Pass());
 }
 
 void ClearKeyCdm::RemoveSession(uint32 promise_id,
                                 const char* session_id,
                                 uint32_t session_id_length) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
 
   // RemoveSession only allowed for the loadable session.
   if (web_session_str == std::string(kLoadableSessionId)) {
     web_session_str = session_id_for_emulated_loadsession_;
   } else {
     // TODO(jrummell): This should be a DCHECK once blink does the proper
     // checks.
     std::string message("Not supported for non-persistent sessions.");
     host_->OnRejectPromise(promise_id,
                            cdm::kInvalidAccessError,
                            0,
                            message.data(),
                            message.length());
     return;
   }
 
   scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
       base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
                  promise_id),
       base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                  promise_id)));
-  decryptor_.RemoveSession(web_session_str, promise.Pass());
+  decryptor_->RemoveSession(web_session_str, promise.Pass());
 }
 
 void ClearKeyCdm::SetServerCertificate(uint32 promise_id,
                                        const uint8_t* server_certificate_data,
                                        uint32_t server_certificate_data_size) {
   // ClearKey doesn't use a server certificate.
   host_->OnResolvePromise(promise_id);
 }
 
 void ClearKeyCdm::TimerExpired(void* context) {
@@ skipping 227 matching lines @@
 
   if (buffer->end_of_stream()) {
     *decrypted_buffer = buffer;
     return cdm::kSuccess;
   }
 
   // Callback is called synchronously, so we can use variables on the stack.
   media::Decryptor::Status status = media::Decryptor::kError;
   // The AesDecryptor does not care what the stream type is. Pass kVideo
   // for both audio and video decryption.
-  decryptor_.Decrypt(
-      media::Decryptor::kVideo,
-      buffer,
+  decryptor_->Decrypt(
+      media::Decryptor::kVideo, buffer,
       base::Bind(&CopyDecryptResults, &status, decrypted_buffer));
 
   if (status == media::Decryptor::kError)
     return cdm::kDecryptError;
 
   if (status == media::Decryptor::kNoKey)
     return cdm::kNoKey;
 
   DCHECK_EQ(status, media::Decryptor::kSuccess);
   return cdm::kSuccess;
@@ skipping 13 matching lines @@
 
 void ClearKeyCdm::LoadLoadableSession() {
   std::string jwk_set = GenerateJWKSet(kLoadableSessionKey,
                                        sizeof(kLoadableSessionKey),
                                        kLoadableSessionKeyId,
                                        sizeof(kLoadableSessionKeyId) - 1);
   scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
       base::Bind(&ClearKeyCdm::OnLoadSessionUpdated, base::Unretained(this)),
       base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                  promise_id_for_emulated_loadsession_)));
-  decryptor_.UpdateSession(session_id_for_emulated_loadsession_,
-                           std::vector<uint8_t>(jwk_set.begin(), jwk_set.end()),
-                           promise.Pass());
+  decryptor_->UpdateSession(
+      session_id_for_emulated_loadsession_,
+      std::vector<uint8_t>(jwk_set.begin(), jwk_set.end()), promise.Pass());
 }
 
 void ClearKeyCdm::OnSessionMessage(const std::string& session_id,
                                    MediaKeys::MessageType message_type,
                                    const std::vector<uint8>& message,
                                    const GURL& legacy_destination_url) {
   DVLOG(1) << "OnSessionMessage: " << message.size();
 
   // Ignore the message when we are waiting to update the loadable session.
   if (session_id == session_id_for_emulated_loadsession_)
@@ skipping 187 matching lines @@
 void ClearKeyCdm::OnFileIOTestComplete(bool success) {
   DVLOG(1) << __FUNCTION__ << ": " << success;
   std::string message = GetFileIOTestResultMessage(success);
   host_->OnSessionMessage(last_session_id_.data(), last_session_id_.length(),
                           cdm::kLicenseRequest, message.data(),
                           message.length(), NULL, 0);
   file_io_test_runner_.reset();
 }
 
 }  // namespace media