Changes to support CDM_7

content/renderer/pepper/content_decryptor_delegate.cc

 // Copyright (c) 2012 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 "content/renderer/pepper/content_decryptor_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 238 matching lines @@
     case PP_DECRYPTEDSAMPLEFORMAT_PLANAR_F32:
       return media::kSampleFormatPlanarF32;
     default:
       NOTREACHED();
       return media::kUnknownSampleFormat;
   }
 }
 
 PP_SessionType MediaSessionTypeToPpSessionType(
     MediaKeys::SessionType session_type) {
+  // TODO(jrummell): Add support for PP_SESSIONTYPE_RELEASE_LICENSE.
   switch (session_type) {
     case MediaKeys::TEMPORARY_SESSION:
       return PP_SESSIONTYPE_TEMPORARY;
     case MediaKeys::PERSISTENT_SESSION:
-      return PP_SESSIONTYPE_PERSISTENT;
+      return PP_SESSIONTYPE_PERSISTENT_LICENSE;
     default:
       NOTREACHED();
       return PP_SESSIONTYPE_TEMPORARY;
   }
 }
 
 MediaKeys::Exception PpExceptionTypeToMediaException(
     PP_CdmExceptionCode exception_code) {
   switch (exception_code) {
     case PP_CDMEXCEPTIONCODE_NOTSUPPORTEDERROR:
@@ skipping 39 matching lines @@
       audio_channel_layout_(media::CHANNEL_LAYOUT_NONE),
       next_promise_id_(1),
       weak_ptr_factory_(this) {
   weak_this_ = weak_ptr_factory_.GetWeakPtr();
 }
 
 ContentDecryptorDelegate::~ContentDecryptorDelegate() {
   SatisfyAllPendingCallbacksOnError();
 }
 
+// TODO(jrummell): Remove |session_ready_cb| and |session_keys_change_cb|.
 void ContentDecryptorDelegate::Initialize(
     const std::string& key_system,
     const media::SessionMessageCB& session_message_cb,
     const media::SessionClosedCB& session_closed_cb,
     const media::SessionErrorCB& session_error_cb,
     const media::SessionKeysChangeCB& session_keys_change_cb,
     const media::SessionExpirationUpdateCB& session_expiration_update_cb,
     const base::Closure& fatal_plugin_error_cb) {
   DCHECK(!key_system.empty());
   DCHECK(key_system_.empty());
@@ skipping 28 matching lines @@
   }
 
   uint32_t promise_id = SavePromise(promise.Pass());
   PP_Var certificate_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           certificate_length, certificate);
   plugin_decryption_interface_->SetServerCertificate(
       pp_instance_, promise_id, certificate_array);
 }
 
+// TODO(jrummell): Rename method to CreateSessionAndGenerateRequest()
+// and reorder parameter list.
 void ContentDecryptorDelegate::CreateSession(
     const std::string& init_data_type,
     const uint8* init_data,
     int init_data_length,
     MediaKeys::SessionType session_type,
     scoped_ptr<NewSessionCdmPromise> promise) {
   uint32_t promise_id = SavePromise(promise.Pass());
   PP_Var init_data_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           init_data_length, init_data);
-  plugin_decryption_interface_->CreateSession(
-      pp_instance_,
-      promise_id,
-      StringVar::StringToPPVar(init_data_type),
-      init_data_array,
-      MediaSessionTypeToPpSessionType(session_type));
+  plugin_decryption_interface_->CreateSessionAndGenerateRequest(
+      pp_instance_, promise_id, MediaSessionTypeToPpSessionType(session_type),
+      StringVar::StringToPPVar(init_data_type), init_data_array);
 }
 
+// TODO(jrummell): Pass |session_type| to this method.
 void ContentDecryptorDelegate::LoadSession(
     const std::string& web_session_id,
     scoped_ptr<NewSessionCdmPromise> promise) {
   uint32_t promise_id = SavePromise(promise.Pass());
   plugin_decryption_interface_->LoadSession(
-      pp_instance_, promise_id, StringVar::StringToPPVar(web_session_id));
+      pp_instance_, promise_id, PP_SESSIONTYPE_PERSISTENT_LICENSE,
+      StringVar::StringToPPVar(web_session_id));
 }
 
 void ContentDecryptorDelegate::UpdateSession(
     const std::string& web_session_id,
     const uint8* response,
     int response_length,
     scoped_ptr<SimpleCdmPromise> promise) {
   uint32_t promise_id = SavePromise(promise.Pass());
   PP_Var response_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
@@ skipping 300 matching lines @@
   }
 
   StringVar* web_session_id_string = StringVar::FromPPVar(web_session_id);
   DCHECK(web_session_id_string);
 
   NewSessionCdmPromise* session_promise =
       static_cast<NewSessionCdmPromise*>(promise.get());
   session_promise->resolve(web_session_id_string->value());
 }
 
-void ContentDecryptorDelegate::OnPromiseResolvedWithKeyIds(
-    uint32 promise_id,
-    PP_Var key_ids_array) {
-  // Since there are no calls to GetUsableKeyIds(), this should never be called.
-  // FIXME(jrummell): remove once CDM interface updated.
-  NOTREACHED();
-}
-
 void ContentDecryptorDelegate::OnPromiseRejected(
     uint32 promise_id,
     PP_CdmExceptionCode exception_code,
     uint32 system_code,
     PP_Var error_description) {
   ReportSystemCodeUMA(key_system_, system_code);
 
   StringVar* error_description_string = StringVar::FromPPVar(error_description);
   DCHECK(error_description_string);
 
   scoped_ptr<CdmPromise> promise = TakePromise(promise_id);
   DCHECK(promise);
   if (promise) {
     promise->reject(PpExceptionTypeToMediaException(exception_code),
                     system_code,
                     error_description_string->value());
   }
 }
 
+// TODO(jrummell): Pass |message_type| to the callback.
 void ContentDecryptorDelegate::OnSessionMessage(PP_Var web_session_id,
-                                                PP_Var message,
-                                                PP_Var destination_url) {
+                                                PP_CdmMessageType message_type,
+                                                PP_Var message) {
   if (session_message_cb_.is_null())
     return;
 
   StringVar* web_session_id_string = StringVar::FromPPVar(web_session_id);
   DCHECK(web_session_id_string);
 
   ArrayBufferVar* message_array_buffer = ArrayBufferVar::FromPPVar(message);
   std::vector<uint8> message_vector;
   if (message_array_buffer) {
     const uint8* data = static_cast<const uint8*>(message_array_buffer->Map());
     message_vector.assign(data, data + message_array_buffer->ByteLength());
   }
 
-  StringVar* destination_url_string = StringVar::FromPPVar(destination_url);
-  DCHECK(destination_url_string);
-
-  GURL verified_gurl = GURL(destination_url_string->value());
-  if (!verified_gurl.is_valid() && !verified_gurl.is_empty()) {
-    DLOG(WARNING) << "SessionMessage default_url is invalid : "
-                  << verified_gurl.possibly_invalid_spec();
-    verified_gurl = GURL::EmptyGURL();  // Replace invalid destination_url.
-  }
-
-  session_message_cb_.Run(
-      web_session_id_string->value(), message_vector, verified_gurl);
+  session_message_cb_.Run(web_session_id_string->value(), message_vector,
+                          GURL::EmptyGURL());
 }
 
+// TODO(jrummell): Decode |key_information| and pass it to the callback.
 void ContentDecryptorDelegate::OnSessionKeysChange(
     PP_Var web_session_id,
-    PP_Bool has_additional_usable_key) {
+    PP_Bool has_additional_usable_key,
+    uint32_t key_count,
+    const struct PP_KeyInformation key_information[]) {
   if (session_keys_change_cb_.is_null())
     return;
 
   StringVar* web_session_id_string = StringVar::FromPPVar(web_session_id);
   DCHECK(web_session_id_string);
 
   session_keys_change_cb_.Run(web_session_id_string->value(),
                               PP_ToBool(has_additional_usable_key));
 }
 
 void ContentDecryptorDelegate::OnSessionExpirationChange(
     PP_Var web_session_id,
     PP_Time new_expiry_time) {
   if (session_expiration_update_cb_.is_null())
     return;
 
   StringVar* web_session_id_string = StringVar::FromPPVar(web_session_id);
   DCHECK(web_session_id_string);
 
   session_expiration_update_cb_.Run(web_session_id_string->value(),
                                     ppapi::PPTimeToTime(new_expiry_time));
 }
 
-void ContentDecryptorDelegate::OnSessionReady(PP_Var web_session_id) {
-  // Ready events no longer generated.
-  // TODO(jrummell): Remove event from Pepper.
-  NOTREACHED();
-}
-
 void ContentDecryptorDelegate::OnSessionClosed(PP_Var web_session_id) {
   if (session_closed_cb_.is_null())
     return;
 
   StringVar* web_session_id_string = StringVar::FromPPVar(web_session_id);
   DCHECK(web_session_id_string);
 
   session_closed_cb_.Run(web_session_id_string->value());
 }
 
@@ skipping 460 matching lines @@
 
 scoped_ptr<CdmPromise> ContentDecryptorDelegate::TakePromise(
     uint32_t promise_id) {
   PromiseMap::iterator it = promises_.find(promise_id);
   if (it == promises_.end())
     return scoped_ptr<CdmPromise>();
   return promises_.take_and_erase(it);
 }
 
 }  // namespace content