Modify the PPAPI CDM interface to pass more info.

webkit/plugins/ppapi/ppapi_plugin_instance.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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_offset_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "ppapi/c/dev/ppb_find_dev.h"
 #include "ppapi/c/dev/ppb_zoom_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_text_input_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_gamepad.h"
 #include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_messaging.h"
 #include "ppapi/c/ppp_mouse_lock.h"
+#include "ppapi/c/private/pp_content_decryptor.h"
 #include "ppapi/c/private/ppp_instance_private.h"
 #include "ppapi/shared_impl/ppb_input_event_shared.h"
 #include "ppapi/shared_impl/ppb_url_util_shared.h"
 #include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/shared_impl/ppp_instance_combined.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
@@ skipping 1287 matching lines @@
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           init_data.size(), init_data.data());
 
   return PP_ToBool(plugin_decryption_interface_->GenerateKeyRequest(
       pp_instance(),
       StringVar::StringToPPVar(key_system),
       init_data_array));
 }
 
 bool PluginInstance::AddKey(const std::string& session_id,
-                            const std::string& key) {
+                            const std::string& key,
+                            const std::string& init_data) {
   if (!LoadContentDecryptorInterface())
     return false;
   PP_Var key_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(key.size(),
                                                                  key.data());
+  PP_Var init_data_array =
+      PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
+          init_data.size(),
+          init_data.data());
 
   return PP_ToBool(plugin_decryption_interface_->AddKey(
       pp_instance(),
       StringVar::StringToPPVar(session_id),
-      key_array));
+      key_array,
+      init_data_array));
 }
 
 bool PluginInstance::CancelKeyRequest(const std::string& session_id) {
   if (!LoadContentDecryptorInterface())
     return false;
 
   return PP_ToBool(plugin_decryption_interface_->CancelKeyRequest(
       pp_instance(),
       StringVar::StringToPPVar(session_id)));
 }
 
 bool PluginInstance::Decrypt(const base::StringPiece& encrypted_block,
                              const DecryptedDataCB& callback) {
   if (!LoadContentDecryptorInterface())
     return false;
   ScopedPPResource encrypted_resource(MakeBufferResource(pp_instance(),
                                                          encrypted_block));
   if (!encrypted_resource.get())
     return false;
 
+  PP_EncryptedBlockInfo block_info;
+
   // TODO(tomfinegan): Store callback and ID in a map, and pass ID to decryptor.
   return PP_ToBool(plugin_decryption_interface_->Decrypt(pp_instance(),
                                                          encrypted_resource,
-                                                         0));
+                                                         &block_info));
 }
 
 bool PluginInstance::DecryptAndDecode(const base::StringPiece& encrypted_block,
                                       const DecryptedDataCB& callback) {
   if (!LoadContentDecryptorInterface())
     return false;
   ScopedPPResource encrypted_resource(MakeBufferResource(pp_instance(),
                                                          encrypted_block));
   if (!encrypted_resource.get())
     return false;
+
+  PP_EncryptedBlockInfo block_info;
+
   // TODO(tomfinegan): Store callback and ID in a map, and pass ID to decryptor.
   return PP_ToBool(plugin_decryption_interface_->DecryptAndDecode(
       pp_instance(),
       encrypted_resource,
-      0));
+      &block_info));
 }
 
 bool PluginInstance::FlashIsFullscreenOrPending() {
   return fullscreen_container_ != NULL;
 }
 
 bool PluginInstance::IsFullscreenOrPending() {
   return desired_fullscreen_state_;
 }
 
@@ skipping 621 matching lines @@
 void PluginInstance::KeyError(PP_Instance instance,
                               PP_Var key_system_var,
                               PP_Var session_id_var,
                               int32_t media_error,
                               int32_t system_code) {
   // TODO(tomfinegan): send the data to media stack.
 }
 
 void PluginInstance::DeliverBlock(PP_Instance instance,
                                   PP_Resource decrypted_block,
-                                  int32_t request_id) {
+                                  const PP_DecryptedBlockInfo* block_info) {
   // TODO(xhwang): Pass the decrypted block back to media stack.
 }
 
 void PluginInstance::DeliverFrame(PP_Instance instance,
                                   PP_Resource decrypted_frame,
-                                  int32_t request_id) {
+                                  const PP_DecryptedBlockInfo* block_info) {
   // TODO(tomfinegan): To be implemented after completion of v0.1 of the
   // EME/CDM work.
 }
 
 void PluginInstance::DeliverSamples(PP_Instance instance,
                                     PP_Resource decrypted_samples,
-                                    int32_t request_id) {
+                                    const PP_DecryptedBlockInfo* block_info) {
   // TODO(tomfinegan): To be implemented after completion of v0.1 of the
   // EME/CDM work.
 }
 
 
 void PluginInstance::NumberOfFindResultsChanged(PP_Instance instance,
                                                 int32_t total,
                                                 PP_Bool final_result) {
   DCHECK_NE(find_identifier_, -1);
   delegate_->NumberOfFindResultsChanged(find_identifier_, total,
@@ skipping 360 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit