Update External Clear Key to support CDM_8

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>
 #include <string>
@@ skipping 134 matching lines @@
       return cdm::kInvalidAccessError;
     case media::MediaKeys::QUOTA_EXCEEDED_ERROR:
       return cdm::kQuotaExceededError;
     case media::MediaKeys::UNKNOWN_ERROR:
       return cdm::kUnknownError;
     case media::MediaKeys::CLIENT_ERROR:
       return cdm::kClientError;
     case media::MediaKeys::OUTPUT_ERROR:
       return cdm::kOutputError;
   }
-  NOTIMPLEMENTED();
+  NOTREACHED();
   return cdm::kUnknownError;
 }
 
 static media::MediaKeys::SessionType ConvertSessionType(
     cdm::SessionType session_type) {
   switch (session_type) {
     case cdm::kTemporary:
       return media::MediaKeys::TEMPORARY_SESSION;
     case cdm::kPersistentLicense:
       return media::MediaKeys::PERSISTENT_LICENSE_SESSION;
     case cdm::kPersistentKeyRelease:
       return media::MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION;
   }
-  NOTIMPLEMENTED();
+  NOTREACHED();
   return media::MediaKeys::TEMPORARY_SESSION;
 }
 
+// TODO(jrummell): |init_data_type| should be an enum all the way through
+// Chromium. http://crbug.com/469228
+static std::string ConvertInitDataType(cdm::InitDataType init_data_type) {
+  switch (init_data_type) {
+    case cdm::kCenc:
+      return "cenc";
+    case cdm::kKeyIds:
+      return "keyids";
+    case cdm::kWebM:
+      return "webm";
+  }
+  NOTREACHED();
+  return "keyids";
+}
+
 cdm::KeyStatus ConvertKeyStatus(media::CdmKeyInformation::KeyStatus status) {
   switch (status) {
     case media::CdmKeyInformation::KeyStatus::USABLE:
       return cdm::kUsable;
     case media::CdmKeyInformation::KeyStatus::INTERNAL_ERROR:
       return cdm::kInternalError;
     case media::CdmKeyInformation::KeyStatus::EXPIRED:
       return cdm::kExpired;
     case media::CdmKeyInformation::KeyStatus::OUTPUT_NOT_ALLOWED:
       return cdm::kOutputNotAllowed;
     case media::CdmKeyInformation::KeyStatus::OUTPUT_DOWNSCALED:
       return cdm::kOutputDownscaled;
     case media::CdmKeyInformation::KeyStatus::KEY_STATUS_PENDING:
       return cdm::kStatusPending;
   }
-  NOTIMPLEMENTED();
+  NOTREACHED();
   return cdm::kInternalError;
 }
 
 // Shallow copy all the key information from |keys_info| into |keys_vector|.
 // |keys_vector| is only valid for the lifetime of |keys_info| because it
 // contains pointers into the latter.
 void ConvertCdmKeysInfo(const std::vector<media::CdmKeyInformation*>& keys_info,
                         std::vector<cdm::KeyInformation>* keys_vector) {
   keys_vector->reserve(keys_info.size());
   for (const auto& key_info : keys_info) {
@@ skipping 73 matching lines @@
   channel_count_ = 0;
   bits_per_channel_ = 0;
   samples_per_second_ = 0;
   output_timestamp_base_in_microseconds_ = kNoTimestamp;
   total_samples_generated_ = 0;
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 }
 
 ClearKeyCdm::~ClearKeyCdm() {}
 
-void ClearKeyCdm::CreateSessionAndGenerateRequest(uint32 promise_id,
-                                                  cdm::SessionType session_type,
-                                                  const char* init_data_type,
-                                                  uint32 init_data_type_size,
-                                                  const uint8* init_data,
-                                                  uint32 init_data_size) {
+void ClearKeyCdm::Initialize(bool /* allow_distinctive_identifier */,
+                             bool /* allow_persistent_state */) {
+  // Implementation doesn't use distinctive identifier nor save persistent data,
+  // so nothing to do with these values.
+}
+
+void ClearKeyCdm::CreateSessionAndGenerateRequest(
+    uint32 promise_id,
+    cdm::SessionType session_type,
+    cdm::InitDataType init_data_type,
+    const uint8* init_data,
+    uint32 init_data_size) {
   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(
-      ConvertSessionType(session_type),
-      std::string(init_data_type, init_data_type_size), init_data,
-      init_data_size, promise.Pass());
+      ConvertSessionType(session_type), ConvertInitDataType(init_data_type),
+      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
 // supported.
 void ClearKeyCdm::LoadSession(uint32 promise_id,
                               cdm::SessionType session_type,
@@ skipping 588 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