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 239 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::SessionReadyCB& session_ready_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());
@@ skipping 30 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 26 matching lines @@
     promise->reject(
         media::MediaKeys::INVALID_ACCESS_ERROR, 0, "Incorrect session.");
     return;
   }
 
   uint32_t promise_id = SavePromise(promise.Pass());
   plugin_decryption_interface_->RemoveSession(
       pp_instance_, promise_id, StringVar::StringToPPVar(web_session_id));
 }
 
+// TODO(jrummell): Remove this method.
 void ContentDecryptorDelegate::GetUsableKeyIds(
     const std::string& web_session_id,
     scoped_ptr<media::KeyIdsPromise> promise) {
-  if (web_session_id.length() > media::limits::kMaxWebSessionIdLength) {
-    promise->reject(
-        media::MediaKeys::INVALID_ACCESS_ERROR, 0, "Incorrect session.");
-    return;
-  }
-
-  uint32_t promise_id = SavePromise(promise.Pass());
-  plugin_decryption_interface_->GetUsableKeyIds(
-      pp_instance_, promise_id, StringVar::StringToPPVar(web_session_id));
+  NOTREACHED();
 }
 
 // TODO(xhwang): Remove duplication of code in Decrypt(),
 // DecryptAndDecodeAudio() and DecryptAndDecodeVideo().
 bool ContentDecryptorDelegate::Decrypt(
     Decryptor::StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const Decryptor::DecryptCB& decrypt_cb) {
   DVLOG(3) << "Decrypt() - stream_type: " << stream_type;
 
@@ skipping 256 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) {
-  scoped_ptr<CdmPromise> promise = TakePromise(promise_id);
-
-  ArrayVar* key_ids = ArrayVar::FromPPVar(key_ids_array);
-  DCHECK(key_ids && key_ids->GetLength() <= media::limits::kMaxKeyIds);
-  media::KeyIdsVector key_ids_vector;
-  if (key_ids && key_ids->GetLength() <= media::limits::kMaxKeyIds) {
-    for (size_t i = 0; i < key_ids->GetLength(); ++i) {
-      ArrayBufferVar* array_buffer = ArrayBufferVar::FromPPVar(key_ids->Get(i));
-
-      if (!array_buffer ||
-          array_buffer->ByteLength() < media::limits::kMinKeyIdLength ||
-          array_buffer->ByteLength() > media::limits::kMaxKeyIdLength) {
-        NOTREACHED();
-        continue;
-      }
-
-      std::vector<uint8> key_id;
-      const uint8* data = static_cast<const uint8*>(array_buffer->Map());
-      key_id.assign(data, data + array_buffer->ByteLength());
-      key_ids_vector.push_back(key_id);
-    }
-  }
-
-  if (!promise ||
-      promise->GetResolveParameterType() !=
-          media::CdmPromise::KEY_IDS_VECTOR_TYPE) {
-    NOTREACHED();
-    return;
-  }
-
-  KeyIdsPromise* key_ids_promise(static_cast<KeyIdsPromise*>(promise.get()));
-  key_ids_promise->resolve(key_ids_vector);
-}
-
 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_MessageType 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,
+    PP_Var 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) {
-  if (session_ready_cb_.is_null())
-    return;
-
-  StringVar* web_session_id_string = StringVar::FromPPVar(web_session_id);
-  DCHECK(web_session_id_string);
-
-  session_ready_cb_.Run(web_session_id_string->value());
-}
-
 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