Pepper: Expose visible_rect to PPB_VideoDecoder.GetPicture.

ppapi/proxy/video_decoder_resource.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/proxy/video_decoder_resource.h"
 
 #include "base/bind.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/mailbox.h"
@@ skipping 31 matching lines @@
 }
 
 VideoDecoderResource::Texture::Texture(uint32_t texture_target,
                                        const PP_Size& size)
     : texture_target(texture_target), size(size) {
 }
 
 VideoDecoderResource::Texture::~Texture() {
 }
 
-VideoDecoderResource::Picture::Picture(int32_t decode_id, uint32_t texture_id)
-    : decode_id(decode_id), texture_id(texture_id) {
+VideoDecoderResource::Picture::Picture(int32_t decode_id,
+                                       uint32_t texture_id,
+                                       const PP_Rect& visible_rect)
+    : decode_id(decode_id), texture_id(texture_id), visible_rect(visible_rect) {
 }
 
 VideoDecoderResource::Picture::~Picture() {
 }
 
 VideoDecoderResource::VideoDecoderResource(Connection connection,
                                            PP_Instance instance)
     : PluginResource(connection, instance),
       num_decodes_(0),
       get_picture_(NULL),
+      get_visible_rect_(NULL),
       gles2_impl_(NULL),
       initialized_(false),
       testing_(false),
       // Set |decoder_last_error_| to PP_OK after successful initialization.
       // This makes error checking a little more concise, since we can check
       // that the decoder has been initialized and hasn't returned an error by
       // just testing |decoder_last_error_|.
       decoder_last_error_(PP_ERROR_FAILED) {
   // Clear the decode_ids_ array.
   memset(decode_ids_, 0, arraysize(decode_ids_));
@@ skipping 168 matching lines @@
   if (!available_shm_buffers_.empty() ||
       shm_buffers_.size() < kMaximumPendingDecodes)
     return PP_OK;
 
   // All buffers are busy and we can't create more. Delay completion until a
   // buffer is available.
   decode_callback_ = callback;
   return PP_OK_COMPLETIONPENDING;
 }
 
+int32_t VideoDecoderResource::GetPicture0_1(
+    PP_VideoPicture* picture,
+    scoped_refptr<TrackedCallback> callback) {
+  return GetPicture(picture, NULL, callback);
+}
+
 int32_t VideoDecoderResource::GetPicture(
     PP_VideoPicture* picture,
+    PP_Rect* visible_rect,
     scoped_refptr<TrackedCallback> callback) {
   if (decoder_last_error_)
     return decoder_last_error_;
   if (reset_callback_.get())
     return PP_ERROR_FAILED;
   if (get_picture_callback_.get())
     return PP_ERROR_INPROGRESS;
 
+  get_picture_ = picture;
+  get_visible_rect_ = visible_rect;
+
   // If the next picture is ready, return it synchronously.
   if (!received_pictures_.empty()) {
-    WriteNextPicture(picture);
+    WriteNextPicture();
     return PP_OK;
   }
 
   get_picture_callback_ = callback;
-  get_picture_ = picture;
+
   return PP_OK_COMPLETIONPENDING;
 }
 
 void VideoDecoderResource::RecyclePicture(const PP_VideoPicture* picture) {
   if (decoder_last_error_)
     return;
 
   Post(RENDERER, PpapiHostMsg_VideoDecoder_RecyclePicture(picture->texture_id));
 }
 
@@ skipping 112 matching lines @@
           std::make_pair(texture_ids[i], Texture(texture_target, size)));
     }
   }
 
   Post(RENDERER, PpapiHostMsg_VideoDecoder_AssignTextures(size, texture_ids));
 }
 
 void VideoDecoderResource::OnPluginMsgPictureReady(
     const ResourceMessageReplyParams& params,
     int32_t decode_id,
-    uint32_t texture_id) {
-  received_pictures_.push(Picture(decode_id, texture_id));
+    uint32_t texture_id,
+    const PP_Rect& visible_rect) {
+  received_pictures_.push(Picture(decode_id, texture_id, visible_rect));
 
   if (TrackedCallback::IsPending(get_picture_callback_)) {
     // The plugin may call GetPicture in its callback.
     scoped_refptr<TrackedCallback> callback;
     callback.swap(get_picture_callback_);
-    PP_VideoPicture* picture = get_picture_;
-    get_picture_ = NULL;
-    WriteNextPicture(picture);
+    WriteNextPicture();
     callback->Run(PP_OK);
   }
 }
 
 void VideoDecoderResource::OnPluginMsgDismissPicture(
     const ResourceMessageReplyParams& params,
     uint32_t texture_id) {
   DeleteGLTexture(texture_id);
   textures_.erase(texture_id);
 }
@@ skipping 81 matching lines @@
   }
 }
 
 void VideoDecoderResource::DeleteGLTexture(uint32_t id) {
   if (gles2_impl_) {
     gles2_impl_->DeleteTextures(1, &id);
     gles2_impl_->Flush();
   }
 }
 
-void VideoDecoderResource::WriteNextPicture(PP_VideoPicture* pp_picture) {
+void VideoDecoderResource::WriteNextPicture() {
   DCHECK(!received_pictures_.empty());
   Picture& picture = received_pictures_.front();
+
   // Internally, we identify decodes by a unique id, which the host returns
   // to us in the picture. Use this to get the plugin's decode_id.
-  pp_picture->decode_id = decode_ids_[picture.decode_id % kMaximumPictureDelay];
-  pp_picture->texture_id = picture.texture_id;
+  get_picture_->decode_id =
+      decode_ids_[picture.decode_id % kMaximumPictureDelay];
+  get_picture_->texture_id = picture.texture_id;
   TextureMap::iterator it = textures_.find(picture.texture_id);
   if (it != textures_.end()) {
-    pp_picture->texture_target = it->second.texture_target;
-    pp_picture->texture_size = it->second.size;
+    get_picture_->texture_target = it->second.texture_target;
+    get_picture_->texture_size = it->second.size;
   } else {
     NOTREACHED();
   }
+
+  if (get_visible_rect_)
+    *get_visible_rect_ = picture.visible_rect;
+
+  get_picture_ = NULL;
+  get_visible_rect_ = NULL;
+
   received_pictures_.pop();
 }
 
 }  // namespace proxy
 }  // namespace ppapi