Changes to the EME Pepper API

ppapi/cpp/private/content_decryptor_private.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 "ppapi/cpp/private/content_decryptor_private.h"
 
 #include <cstring>  // memcpy
 
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/private/ppb_content_decryptor_private.h"
 #include "ppapi/c/private/ppp_content_decryptor_private.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/instance_handle.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/module_impl.h"
 #include "ppapi/cpp/var.h"
 
 namespace pp {
 
 namespace {
 
 static const char kPPPContentDecryptorInterface[] =
     PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE;
 
-void GenerateKeyRequest(PP_Instance instance,
-                        PP_Var key_system_arg,
-                        PP_Var type_arg,
-                        PP_Var init_data_arg) {
+void Initialize(PP_Instance instance,
+                PP_Var key_system_arg,
+                PP_Bool can_challenge_platform) {
   void* object =
       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
   if (!object)
     return;
 
   pp::Var key_system_var(pp::PASS_REF, key_system_arg);
   if (!key_system_var.is_string())
     return;
 
+  static_cast<ContentDecryptor_Private*>(object)->Initialize(
+      key_system_var.AsString(),
+      can_challenge_platform);

[dmichael (off chromium), 2013/09/19 16:04:20]

PP_ToBool(can_challenge_platform)?

I think the Windows compiler might complain if you don't.

[jrummell, 2013/09/19 18:15:15]

Done.

+}
+
+void GenerateKeyRequest(PP_Instance instance,
+                        PP_Var type_arg,
+                        PP_Var init_data_arg) {
+  void* object =
+      Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
+  if (!object)
+    return;
+
   pp::Var type_var(pp::PASS_REF, type_arg);
   if (!type_var.is_string())
     return;
 
   pp::Var init_data_var(pp::PASS_REF, init_data_arg);
   if (!init_data_var.is_array_buffer())
     return;
   pp::VarArrayBuffer init_data_array_buffer(init_data_var);
 
   static_cast<ContentDecryptor_Private*>(object)->GenerateKeyRequest(
-      key_system_var.AsString(),
       type_var.AsString(),
       init_data_array_buffer);
 }
 
 void AddKey(PP_Instance instance,
             PP_Var session_id_arg,
             PP_Var key_arg,
             PP_Var init_data_arg) {
   void* object =
       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
@@ skipping 117 matching lines @@
   if (!object)
     return;
 
   static_cast<ContentDecryptor_Private*>(object)->DecryptAndDecode(
       decoder_type,
       encrypted_buffer,
       *encrypted_block_info);
 }
 
 const PPP_ContentDecryptor_Private ppp_content_decryptor = {
+  &Initialize,
   &GenerateKeyRequest,
   &AddKey,
   &CancelKeyRequest,
   &Decrypt,
   &InitializeAudioDecoder,
   &InitializeVideoDecoder,
   &DeinitializeDecoder,
   &ResetDecoder,
   &DecryptAndDecode
 };
@@ skipping 10 matching lines @@
                                     &ppp_content_decryptor);
   instance->AddPerInstanceObject(kPPPContentDecryptorInterface, this);
 }
 
 ContentDecryptor_Private::~ContentDecryptor_Private() {
   Instance::RemovePerInstanceObject(associated_instance_,
                                     kPPPContentDecryptorInterface,
                                     this);
 }
 
-void ContentDecryptor_Private::NeedKey(const std::string& key_system,
-                                       const std::string& session_id,
-                                       pp::VarArrayBuffer init_data) {
-  // session_id can be empty here.
-  if (has_interface<PPB_ContentDecryptor_Private>()) {
-    pp::Var key_system_var(key_system);
-    pp::Var session_id_var(session_id);
-
-    get_interface<PPB_ContentDecryptor_Private>()->NeedKey(
-        associated_instance_.pp_instance(),
-        key_system_var.pp_var(),
-        session_id_var.pp_var(),
-        init_data.pp_var());
-  }
-}
-
 void ContentDecryptor_Private::KeyAdded(const std::string& key_system,
                                         const std::string& session_id) {
   if (has_interface<PPB_ContentDecryptor_Private>()) {
     pp::Var key_system_var(key_system);
     pp::Var session_id_var(session_id);
     get_interface<PPB_ContentDecryptor_Private>()->KeyAdded(
         associated_instance_.pp_instance(),
         key_system_var.pp_var(),
         session_id_var.pp_var());
   }
@@ skipping 94 matching lines @@
     const PP_DecryptedBlockInfo& decrypted_block_info) {
   if (has_interface<PPB_ContentDecryptor_Private>()) {
     get_interface<PPB_ContentDecryptor_Private>()->DeliverSamples(
         associated_instance_.pp_instance(),
         audio_frames.pp_resource(),
         &decrypted_block_info);
   }
 }
 
 }  // namespace pp