Encrypted Media: Support natural size in video decrypt-and-decode path.

webkit/plugins/ppapi/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 "webkit/plugins/ppapi/content_decryptor_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop_proxy.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/channel_layout.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decryptor_client.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
+#include "ui/gfx/rect.h"
 #include "webkit/plugins/ppapi/ppb_buffer_impl.h"
 
 using ppapi::PpapiGlobals;
 using ppapi::ScopedPPResource;
 using ppapi::StringVar;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 
 namespace webkit {
 namespace ppapi {
@@ skipping 435 matching lines @@
                           decoder_config.extra_data_size(),
                           &extra_data_resource)) {
     return false;
   }
 
   DCHECK_EQ(pending_video_decoder_init_request_id_, 0u);
   DCHECK(pending_video_decoder_init_cb_.is_null());
   pending_video_decoder_init_request_id_ = pp_decoder_config.request_id;
   pending_video_decoder_init_cb_ = init_cb;
 
+  natural_size_ = decoder_config.natural_size();
+
   plugin_decryption_interface_->InitializeVideoDecoder(pp_instance_,
                                                        &pp_decoder_config,
                                                        extra_data_resource);
 
   return true;
 }
 
 bool ContentDecryptorDelegate::DeinitializeDecoder(
     media::Decryptor::StreamType stream_type) {
   CancelDecode(stream_type);
 
+  natural_size_ = gfx::Size();
+
   // TODO(tomfinegan): Add decoder deinitialize request tracking, and get
   // stream type from media stack.
   plugin_decryption_interface_->DeinitializeDecoder(
       pp_instance_, MediaDecryptorStreamTypeToPpStreamType(stream_type), 0);
   return true;
 }
 
 bool ContentDecryptorDelegate::ResetDecoder(
     media::Decryptor::StreamType stream_type) {
   CancelDecode(stream_type);
@@ skipping 196 matching lines @@
 
       DCHECK(!pending_audio_decoder_init_cb_.is_null());
       pending_audio_decoder_init_request_id_ = 0;
       base::ResetAndReturn(
           &pending_audio_decoder_init_cb_).Run(PP_ToBool(success));
   } else {
     if (request_id == 0 ||
         request_id != pending_video_decoder_init_request_id_)
       return;
 
+      if (!success)
+        natural_size_ = gfx::Size();
+
       DCHECK(!pending_video_decoder_init_cb_.is_null());
       pending_video_decoder_init_request_id_ = 0;
       base::ResetAndReturn(
           &pending_video_decoder_init_cb_).Run(PP_ToBool(success));
   }
 }
 
 void ContentDecryptorDelegate::DecoderDeinitializeDone(
     PP_DecryptorStreamType decoder_type,
     uint32_t request_id) {
@@ skipping 106 matching lines @@
 
   uint32_t mapped_size = 0;
   if (!ppb_buffer->Describe(&mapped_size) || !mapped_size) {
     video_decode_cb.Run(media::Decryptor::kError, NULL);
     return;
   }
 
   gfx::Size frame_size(frame_info->width, frame_info->height);
   DCHECK_EQ(frame_info->format, PP_DECRYPTEDFRAMEFORMAT_YV12);
 
-  // TODO(xhwang): Support visible_rect and natural_size in EME video decoding
-  // implementations.
   scoped_refptr<media::VideoFrame> decoded_frame =
       media::VideoFrame::WrapExternalYuvData(
           media::VideoFrame::YV12,
-          frame_size, gfx::Rect(frame_size), frame_size,
+          frame_size, gfx::Rect(frame_size), natural_size_,
           frame_info->strides[PP_DECRYPTEDFRAMEPLANES_Y],
           frame_info->strides[PP_DECRYPTEDFRAMEPLANES_U],
           frame_info->strides[PP_DECRYPTEDFRAMEPLANES_V],
           frame_data + frame_info->plane_offsets[PP_DECRYPTEDFRAMEPLANES_Y],
           frame_data + frame_info->plane_offsets[PP_DECRYPTEDFRAMEPLANES_U],
           frame_data + frame_info->plane_offsets[PP_DECRYPTEDFRAMEPLANES_V],
           base::TimeDelta::FromMicroseconds(
               frame_info->tracking_info.timestamp),
           media::BindToLoop(base::MessageLoopProxy::current(),
                             base::Bind(&PPB_Buffer_Impl::Unmap, ppb_buffer)));
@@ skipping 122 matching lines @@
     return false;
   }
   memcpy(mapper.data(), data, size);
 
   *resource = media_resource;
   return true;
 }
 
 }  // namespace ppapi
 }  // namespace webkit