Introduce a client minimum picture pool size

content/renderer/pepper/pepper_video_decoder_host.cc

 // Copyright (c) 2014 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 "content/renderer/pepper/pepper_video_decoder_host.h"
 
 #include "base/bind.h"
 #include "base/memory/shared_memory.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/pepper_file_util.h"
+#include "content/public/common/content_client.h"
+#include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/ppb_graphics_3d_impl.h"
 #include "content/renderer/pepper/video_decoder_shim.h"
+#include "media/base/limits.h"
 #include "media/video/video_decode_accelerator.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/video_decoder_constants.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_graphics_3d_api.h"
 
 using ppapi::proxy::SerializedHandle;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Graphics3D_API;
 
 namespace content {
 
 namespace {
 
+// The maximum number of pictures that the client can pass in for
+// min_picture_count, just as a sanity check on the argument.
+// This should match the constant of the same name in test_video_decoder.cc.
+const uint32_t kMaximumPictureCount = 100;

[bbudge, 2015/08/19 18:47:06]

I forgot that we had a place for constants like this. Could you move this to
ppapi/proxy/video_decoder_constants.h ? That would allow you to share the
definition with the proxy (resource) if you wanted to validate there too.

https://code.google.com/p/chromium/codesearch#chromium/src/ppapi/proxy/video_...

[lpique, 2015/08/19 19:42:17]

Sure. I saw it when looking for a location to share the constant with the test.
I've moved it there, and added back the validation in the resource proxy.

+
 media::VideoCodecProfile PepperToMediaVideoProfile(PP_VideoProfile profile) {
   switch (profile) {
     case PP_VIDEOPROFILE_H264BASELINE:
       return media::H264PROFILE_BASELINE;
     case PP_VIDEOPROFILE_H264MAIN:
       return media::H264PROFILE_MAIN;
     case PP_VIDEOPROFILE_H264EXTENDED:
       return media::H264PROFILE_EXTENDED;
     case PP_VIDEOPROFILE_H264HIGH:
       return media::H264PROFILE_HIGH;
@@ skipping 30 matching lines @@
 }
 
 PepperVideoDecoderHost::PendingDecode::~PendingDecode() {
 }
 
 PepperVideoDecoderHost::PepperVideoDecoderHost(RendererPpapiHost* host,
                                                PP_Instance instance,
                                                PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       renderer_ppapi_host_(host),
+      min_picture_count_(0),
       initialized_(false) {
 }
 
 PepperVideoDecoderHost::~PepperVideoDecoderHost() {
 }
 
 int32_t PepperVideoDecoderHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
   PPAPI_BEGIN_MESSAGE_MAP(PepperVideoDecoderHost, msg)
@@ skipping 12 matching lines @@
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_VideoDecoder_Reset,
                                         OnHostMsgReset)
   PPAPI_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
 int32_t PepperVideoDecoderHost::OnHostMsgInitialize(
     ppapi::host::HostMessageContext* context,
     const ppapi::HostResource& graphics_context,
     PP_VideoProfile profile,
-    PP_HardwareAcceleration acceleration) {
+    PP_HardwareAcceleration acceleration,
+    uint32_t min_picture_count) {
   if (initialized_)
     return PP_ERROR_FAILED;
+  if (min_picture_count > kMaximumPictureCount)
+    return PP_ERROR_BADARGUMENT;
 
   EnterResourceNoLock<PPB_Graphics3D_API> enter_graphics(
       graphics_context.host_resource(), true);
   if (enter_graphics.failed())
     return PP_ERROR_FAILED;
   PPB_Graphics3D_Impl* graphics3d =
       static_cast<PPB_Graphics3D_Impl*>(enter_graphics.object());
 
   CommandBufferProxyImpl* command_buffer = graphics3d->GetCommandBufferProxy();
   if (!command_buffer)
     return PP_ERROR_FAILED;
 
   media::VideoCodecProfile media_profile = PepperToMediaVideoProfile(profile);
 
+  // Check for Dev API use
+  // TODO(lpique): remove check when PPB_VideoDecoder_1_1 reaches beta/stable.
+  // https://crbug.com/520323
+  if (min_picture_count != 0) {
+    ContentRendererClient* client = GetContentClient()->renderer();
+    bool allowed = client->IsPluginAllowedToUseDevChannelAPIs();
+    if (!allowed)
+      return PP_ERROR_NOTSUPPORTED;
+  }
+  min_picture_count_ = min_picture_count;
+
   if (acceleration != PP_HARDWAREACCELERATION_NONE) {
     // This is not synchronous, but subsequent IPC messages will be buffered, so
     // it is okay to immediately send IPC messages.
     decoder_ = command_buffer->CreateVideoDecoder();
     if (decoder_ && decoder_->Initialize(media_profile, this)) {
       initialized_ = true;
       return PP_OK;
     }
     decoder_.reset();
     if (acceleration == PP_HARDWAREACCELERATION_ONLY)
       return PP_ERROR_NOTSUPPORTED;
   }
 
 #if defined(OS_ANDROID)
   return PP_ERROR_NOTSUPPORTED;
 #else
-  decoder_.reset(new VideoDecoderShim(this));
+  uint32_t shim_texture_pool_size = media::limits::kMaxVideoFrames + 1;
+  shim_texture_pool_size = std::max(shim_texture_pool_size,
+                                    min_picture_count_);
+  decoder_.reset(new VideoDecoderShim(this, shim_texture_pool_size));
   initialize_reply_context_ = context->MakeReplyMessageContext();
   decoder_->Initialize(media_profile, this);
 
   return PP_OK_COMPLETIONPENDING;
 #endif
 }
 
 int32_t PepperVideoDecoderHost::OnHostMsgGetShm(
     ppapi::host::HostMessageContext* context,
     uint32_t shm_id,
@@ skipping 150 matching lines @@
   reset_reply_context_ = context->MakeReplyMessageContext();
   decoder_->Reset();
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PepperVideoDecoderHost::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions,
     uint32 texture_target) {
-  RequestTextures(requested_num_of_buffers,
+  RequestTextures(std::max(min_picture_count_, requested_num_of_buffers),
                   dimensions,
                   texture_target,
                   std::vector<gpu::Mailbox>());
 }
 
 void PepperVideoDecoderHost::PictureReady(const media::Picture& picture) {
   // Don't bother validating the visible rect, since the plugin process is less
   // trusted than the gpu process.
   DCHECK(pictures_in_use_.find(picture.picture_buffer_id()) ==
          pictures_in_use_.end());
@@ skipping 92 matching lines @@
   host()->SendUnsolicitedReply(
       pp_resource(),
       PpapiPluginMsg_VideoDecoder_RequestTextures(
           requested_num_of_buffers,
           PP_MakeSize(dimensions.width(), dimensions.height()),
           texture_target,
           mailboxes));
 }
 
 }  // namespace content