Separate CDM initialization from GenerateKeyRequest & remove key_system parameters.

webkit/renderer/media/crypto/ppapi/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 "webkit/renderer/media/crypto/ppapi/clear_key_cdm.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
@@ skipping 142 matching lines @@
 
 ClearKeyCdm::Client::~Client() {}
 
 void ClearKeyCdm::Client::Reset() {
   status_ = kKeyError;
   session_id_.clear();
   key_message_.clear();
   default_url_.clear();
 }
 
-void ClearKeyCdm::Client::KeyAdded(const std::string& key_system,
-                                   const std::string& session_id) {
+void ClearKeyCdm::Client::KeyAdded(const std::string& session_id) {
   status_ = kKeyAdded;
   session_id_ = session_id;
 }
 
-void ClearKeyCdm::Client::KeyError(const std::string& key_system,
-                                   const std::string& session_id,
+void ClearKeyCdm::Client::KeyError(const std::string& session_id,
                                    media::MediaKeys::KeyError error_code,
                                    int system_code) {
   status_ = kKeyError;
   session_id_ = session_id;
 }
 
-void ClearKeyCdm::Client::KeyMessage(const std::string& key_system,
-                                     const std::string& session_id,
+void ClearKeyCdm::Client::KeyMessage(const std::string& session_id,
                                      const std::string& message,
                                      const std::string& default_url) {
   status_ = kKeyMessage;
   session_id_ = session_id;
   key_message_ = message;
   default_url_ = default_url;
 }
 
-void ClearKeyCdm::Client::NeedKey(const std::string& key_system,
-                                  const std::string& session_id,
+void ClearKeyCdm::Client::NeedKey(const std::string& session_id,
                                   const std::string& type,
                                   scoped_ptr<uint8[]> init_data,
                                   int init_data_length) {
   // In the current implementation of AesDecryptor, NeedKey is not used.
   // If no key is available to decrypt an input buffer, it returns kNoKey to
   // the caller instead of firing NeedKey.
   NOTREACHED();
 }
 
 ClearKeyCdm::ClearKeyCdm(cdm::Host* host)
@@ skipping 14 matching lines @@
 }
 
 ClearKeyCdm::~ClearKeyCdm() {}
 
 cdm::Status ClearKeyCdm::GenerateKeyRequest(const char* type, int type_size,
                                             const uint8_t* init_data,
                                             int init_data_size) {
   DVLOG(1) << "GenerateKeyRequest()";
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
-  decryptor_.GenerateKeyRequest(kExternalClearKey,
-                                std::string(type, type_size),
+  decryptor_.GenerateKeyRequest(std::string(type, type_size),
                                 init_data, init_data_size);
 
   if (client_.status() != Client::kKeyMessage) {
     host_->SendKeyError(NULL, 0, cdm::kUnknownError, 0);
     return cdm::kSessionError;
   }
 
   host_->SendKeyMessage(
       client_.session_id().data(), client_.session_id().size(),
       client_.key_message().data(), client_.key_message().size(),
       client_.default_url().data(), client_.default_url().size());
 
   // Only save the latest session ID for heartbeat messages.
   heartbeat_session_id_ = client_.session_id();
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::AddKey(const char* session_id,
                                 int session_id_size,
                                 const uint8_t* key,
                                 int key_size,
                                 const uint8_t* key_id,
                                 int key_id_size) {
   DVLOG(1) << "AddKey()";
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
-  decryptor_.AddKey(std::string(),
-                    key,
-                    key_size,
-                    key_id,
-                    key_id_size,
+  decryptor_.AddKey(key, key_size, key_id, key_id_size,
                     std::string(session_id, session_id_size));
 
   if (client_.status() != Client::kKeyAdded)
     return cdm::kSessionError;
 
   if (!timer_set_) {
     ScheduleNextHeartBeat();
     timer_set_ = true;
   }
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::CancelKeyRequest(const char* session_id,
                                           int session_id_size) {
   DVLOG(1) << "CancelKeyRequest()";
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
-  decryptor_.CancelKeyRequest(std::string(),
-                              std::string(session_id, session_id_size));
+  decryptor_.CancelKeyRequest(std::string(session_id, session_id_size));
   return cdm::kSuccess;
 }
 
 void ClearKeyCdm::TimerExpired(void* context) {
   std::string heartbeat_message;
   if (!next_heartbeat_message_.empty() &&
       context == &next_heartbeat_message_[0]) {
     heartbeat_message = next_heartbeat_message_;
   } else {
     heartbeat_message = "ERROR: Invalid timer context found!";
@@ skipping 282 matching lines @@
   int samples_generated = GenerateFakeAudioFramesFromDuration(
       timestamp_in_microseconds - CurrentTimeStampInMicroseconds(),
       audio_frames);
   total_samples_generated_ += samples_generated;
 
   return samples_generated == 0 ? cdm::kNeedMoreData : cdm::kSuccess;
 }
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 
 }  // namespace webkit_media