Update PluginInstance for decrypt-and-decode video.

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/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_offset_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decryptor_client.h"
+#include "media/base/video_util.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"
@@ skipping 418 matching lines @@
       filtered_input_event_mask_(0),
       text_input_type_(kPluginDefaultTextInputType),
       text_input_caret_(0, 0, 0, 0),
       text_input_caret_bounds_(0, 0, 0, 0),
       text_input_caret_set_(false),
       selection_caret_(0),
       selection_anchor_(0),
       pending_user_gesture_(0.0),
       flash_impl_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       decryptor_client_(NULL),
-      next_decryption_request_id_(1) {
+      next_decryption_request_id_(1),
+      pending_video_decode_request_id_(0) {
   pp_instance_ = HostGlobals::Get()->AddInstance(this);
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   DCHECK(delegate);
   module_->InstanceCreated(this);
   delegate_->InstanceCreated(this);
   message_channel_.reset(new MessageChannel(this));
 
   view_data_.is_page_visible = delegate->IsPageVisible();
 
@@ skipping 1052 matching lines @@
 
   ScopedPPResource encrypted_resource(
       ScopedPPResource::PassRef(),
       MakeBufferResource(pp_instance(),
                          encrypted_buffer->GetData(),
                          encrypted_buffer->GetDataSize()));
   if (!encrypted_resource.get())
     return false;
 
   uint32_t request_id = next_decryption_request_id_++;
+  if (next_decryption_request_id_ == 0)
+    next_decryption_request_id_++;

[xhwang, 2012/10/09 22:29:32]

Okay, it took a user to watch a 60fps movie for 2 years non-stop to hit this :P
Removed.

 
   PP_EncryptedBlockInfo block_info;
   DCHECK(encrypted_buffer->GetDecryptConfig());
   if (!MakeEncryptedBlockInfo(*encrypted_buffer->GetDecryptConfig(),
                               encrypted_buffer->GetTimestamp().InMicroseconds(),
                               request_id,
                               &block_info)) {
     return false;
   }
 
   DCHECK(!ContainsKey(pending_decryption_cbs_, request_id));
   pending_decryption_cbs_.insert(std::make_pair(request_id, decrypt_cb));
 
   plugin_decryption_interface_->Decrypt(pp_instance(),
                                         encrypted_resource,
                                         &block_info);
   return true;
 }
 
 // Note: this method can be used with an unencrypted frame.
 bool PluginInstance::DecryptAndDecodeFrame(
     const scoped_refptr<media::DecoderBuffer>& encrypted_frame,
-    const media::Decryptor::DecryptCB& decrypt_cb) {
+    const media::Decryptor::VideoDecodeCB& video_decode_cb) {
   if (!LoadContentDecryptorInterface())
     return false;
 
   ScopedPPResource encrypted_resource(MakeBufferResource(
       pp_instance(),
       encrypted_frame->GetData(),
       encrypted_frame->GetDataSize()));
   if (!encrypted_resource.get())
     return false;
 
-  const uint32_t request_id = next_decryption_request_id_++;
+  uint32_t request_id = next_decryption_request_id_++;
+  if (next_decryption_request_id_ == 0)
+    next_decryption_request_id_++;
 
   // TODO(tomfinegan): Need to get the video format information here somehow.
   PP_EncryptedVideoFrameInfo frame_info;
   frame_info.width = 0;
   frame_info.height = 0;
   frame_info.format = PP_DECRYPTEDFRAMEFORMAT_UNKNOWN;
   frame_info.codec = PP_VIDEOCODEC_UNKNOWN;
 
   DCHECK(encrypted_frame->GetDecryptConfig());
   if (!MakeEncryptedBlockInfo(*encrypted_frame->GetDecryptConfig(),
                               encrypted_frame->GetTimestamp().InMicroseconds(),
                               request_id,
                               &frame_info.encryption_info)) {
     return false;
   }
 
-  DCHECK(!ContainsKey(pending_decryption_cbs_, request_id));
-  pending_decryption_cbs_.insert(std::make_pair(request_id, decrypt_cb));
+  // Only one pending video decode request at any time. This is enforced by the
+  // media pipeline.
+  DCHECK_EQ(pending_video_decode_request_id_, 0u);
+  DCHECK(pending_video_decode_cb_.is_null());
+  pending_video_decode_request_id_ = request_id;
+  pending_video_decode_cb_ = video_decode_cb;
 
   plugin_decryption_interface_->DecryptAndDecodeFrame(pp_instance(),
                                                       encrypted_resource,
                                                       &frame_info);
   return true;
 }
 
 bool PluginInstance::FlashIsFullscreenOrPending() {
   return fullscreen_container_ != NULL;
 }
@@ skipping 695 matching lines @@
       block_info->tracking_info.request_id);
   if (found == pending_decryption_cbs_.end())
     return;
   media::Decryptor::DecryptCB decrypt_cb = found->second;
   pending_decryption_cbs_.erase(found);
 
   if (block_info->result == PP_DECRYPTRESULT_DECRYPT_NOKEY) {
     decrypt_cb.Run(media::Decryptor::kNoKey, NULL);
     return;
   }
+
   if (block_info->result != PP_DECRYPTRESULT_SUCCESS) {
     decrypt_cb.Run(media::Decryptor::kError, NULL);
     return;
   }
 
   EnterResourceNoLock<PPB_Buffer_API> enter(decrypted_block, true);
   if (!enter.succeeded()) {
     decrypt_cb.Run(media::Decryptor::kError, NULL);
     return;
   }
   BufferAutoMapper mapper(enter.object());
   if (!mapper.data() || !mapper.size()) {
     decrypt_cb.Run(media::Decryptor::kError, NULL);
     return;
   }
 
   // TODO(tomfinegan): Find a way to take ownership of the shared memory
   // managed by the PPB_Buffer_Dev, and avoid the extra copy.
   scoped_refptr<media::DecoderBuffer> decrypted_buffer(
       media::DecoderBuffer::CopyFrom(
           reinterpret_cast<const uint8*>(mapper.data()), mapper.size()));
   decrypted_buffer->SetTimestamp(base::TimeDelta::FromMicroseconds(
       block_info->tracking_info.timestamp));
   decrypt_cb.Run(media::Decryptor::kSuccess, decrypted_buffer);
 }
 
 void PluginInstance::DeliverFrame(PP_Instance instance,
                                   PP_Resource decrypted_frame,
                                   const PP_DecryptedFrameInfo* frame_info) {
-  // TODO(tomfinegan): To be implemented after completion of v0.1 of the
-  // EME/CDM work.
+  DCHECK(frame_info);
+  uint32_t request_id = frame_info->tracking_info.request_id;
+
+  // If the request ID is not valid or does not match what's saved, do nothing.
+  if (request_id == 0 || request_id != pending_video_decode_request_id_)
+    return;
+
+  DCHECK(!pending_video_decode_cb_.is_null());
+  pending_video_decode_request_id_ = 0;
+  media::Decryptor::VideoDecodeCB video_decode_cb =
+      base::ResetAndReturn(&pending_video_decode_cb_);
+
+  if (frame_info->result == PP_DECRYPTRESULT_DECRYPT_NOKEY) {
+    video_decode_cb.Run(media::Decryptor::kNoKey, NULL);
+    return;
+  }
+
+  if (frame_info->result != PP_DECRYPTRESULT_SUCCESS) {
+    video_decode_cb.Run(media::Decryptor::kError, NULL);
+    return;
+  }
+
+  EnterResourceNoLock<PPB_Buffer_API> enter(decrypted_frame, true);
+  if (!enter.succeeded()) {
+    video_decode_cb.Run(media::Decryptor::kError, NULL);
+    return;
+  }
+  BufferAutoMapper mapper(enter.object());
+  if (!mapper.data() || !mapper.size()) {
+    video_decode_cb.Run(media::Decryptor::kError, NULL);
+    return;
+  }
+
+  const uint8* frame_data = reinterpret_cast<uint8*>(mapper.data());
+
+  // TODO(tomfinegan): Find a way to take ownership of the shared memory
+  // managed by the PPB_Buffer_Dev, and avoid the extra copy.
+  DCHECK(frame_info->format == PP_DECRYPTEDFRAMEFORMAT_YV12);
+  gfx::Size frame_size(frame_info->width, frame_info->height);
+  scoped_refptr<media::VideoFrame> decoded_frame(
+      media::VideoFrame::CreateFrame(
+          media::VideoFrame::YV12, frame_size, frame_size,
+          base::TimeDelta::FromMicroseconds(
+              frame_info->tracking_info.timestamp)));
+
+  media::CopyYPlane(
+      frame_data + frame_info->plane_offsets[PP_DECRYPTEDFRAMEPLANES_Y],
+      frame_info->strides[PP_DECRYPTEDFRAMEPLANES_Y],
+      frame_info->height,
+      decoded_frame.get());
+
+  media::CopyUPlane(
+      frame_data + frame_info->plane_offsets[PP_DECRYPTEDFRAMEPLANES_U],
+      frame_info->strides[PP_DECRYPTEDFRAMEPLANES_U],
+      frame_info->height,
+      decoded_frame.get());
+
+  media::CopyVPlane(
+      frame_data + frame_info->plane_offsets[PP_DECRYPTEDFRAMEPLANES_V],
+      frame_info->strides[PP_DECRYPTEDFRAMEPLANES_V],
+      frame_info->height,
+      decoded_frame.get());
+
+  video_decode_cb.Run(media::Decryptor::kSuccess, decoded_frame);
 }
 
 void PluginInstance::DeliverSamples(PP_Instance instance,
                                     PP_Resource decrypted_samples,
                                     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,
@@ skipping 370 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