Introduce a client minimum picture pool size

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 44 matching lines @@
     : 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),
+      min_picture_count_(0),
       get_picture_(NULL),
       get_picture_0_1_(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) {
@@ skipping 16 matching lines @@
 int32_t VideoDecoderResource::Initialize0_1(
     PP_Resource graphics_context,
     PP_VideoProfile profile,
     PP_Bool allow_software_fallback,
     scoped_refptr<TrackedCallback> callback) {
   return Initialize(graphics_context,
                     profile,
                     allow_software_fallback
                         ? PP_HARDWAREACCELERATION_WITHFALLBACK
                         : PP_HARDWAREACCELERATION_ONLY,
+                    0,
                     callback);
 }
 
+int32_t VideoDecoderResource::Initialize0_2(
+    PP_Resource graphics_context,
+    PP_VideoProfile profile,
+    PP_HardwareAcceleration acceleration,
+    scoped_refptr<TrackedCallback> callback) {
+  return Initialize(graphics_context,
+                    profile,
+                    acceleration,
+                    0,
+                    callback);
+}
+
 int32_t VideoDecoderResource::Initialize(
     PP_Resource graphics_context,
     PP_VideoProfile profile,
     PP_HardwareAcceleration acceleration,
+    uint32_t min_picture_count,
     scoped_refptr<TrackedCallback> callback) {
   if (initialized_)
     return PP_ERROR_FAILED;
   if (profile < 0 || profile > PP_VIDEOPROFILE_MAX)
     return PP_ERROR_BADARGUMENT;
+  if (min_picture_count > kMaximumPictureCount)
+    return PP_ERROR_BADARGUMENT;
   if (initialize_callback_.get())
     return PP_ERROR_INPROGRESS;
   if (!graphics_context)
     return PP_ERROR_BADRESOURCE;
 
+  min_picture_count_ = min_picture_count;
+
   HostResource host_resource;
   if (!testing_) {
     // Create a new Graphics3D resource that can create texture resources to
     // share with the plugin. We can't use the plugin's Graphics3D, since we
     // create textures on a proxy thread, and would interfere with the plugin.
     thunk::EnterResourceCreationNoLock enter_create(pp_instance());
     if (enter_create.failed())
       return PP_ERROR_FAILED;
     int32_t attrib_list[] = {PP_GRAPHICS3DATTRIB_NONE};
     graphics3d_ =
         ScopedPPResource(ScopedPPResource::PassRef(),
                          enter_create.functions()->CreateGraphics3D(
                              pp_instance(), graphics_context, attrib_list));
     EnterResourceNoLock<PPB_Graphics3D_API> enter_graphics(graphics3d_.get(),
                                                            false);
     if (enter_graphics.failed())
       return PP_ERROR_BADRESOURCE;
 
     PPB_Graphics3D_Shared* ppb_graphics3d_shared =
         static_cast<PPB_Graphics3D_Shared*>(enter_graphics.object());
     gles2_impl_ = ppb_graphics3d_shared->gles2_impl();
     host_resource = ppb_graphics3d_shared->host_resource();
   }
 
   initialize_callback_ = callback;
 
   Call<PpapiPluginMsg_VideoDecoder_InitializeReply>(
       RENDERER,
       PpapiHostMsg_VideoDecoder_Initialize(
-          host_resource, profile, acceleration),
+          host_resource, profile, acceleration, min_picture_count),
       base::Bind(&VideoDecoderResource::OnPluginMsgInitializeComplete, this));
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t VideoDecoderResource::Decode(uint32_t decode_id,
                                      uint32_t size,
                                      const void* buffer,
                                      scoped_refptr<TrackedCallback> callback) {
   if (decoder_last_error_)
@@ skipping 194 matching lines @@
   testing_ = true;
 }
 
 void VideoDecoderResource::OnPluginMsgRequestTextures(
     const ResourceMessageReplyParams& params,
     uint32_t num_textures,
     const PP_Size& size,
     uint32_t texture_target,
     const std::vector<gpu::Mailbox>& mailboxes) {
   DCHECK(num_textures);
+  DCHECK(num_textures >= min_picture_count_);
   DCHECK(mailboxes.empty() || mailboxes.size() == num_textures);
   std::vector<uint32_t> texture_ids(num_textures);
   if (gles2_impl_) {
     gles2_impl_->GenTextures(num_textures, &texture_ids.front());
     for (uint32_t i = 0; i < num_textures; ++i) {
       gles2_impl_->ActiveTexture(GL_TEXTURE0);
       gles2_impl_->BindTexture(texture_target, texture_ids[i]);
       gles2_impl_->TexParameteri(
           texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
       gles2_impl_->TexParameteri(
@@ skipping 182 matching lines @@
     get_picture_0_1_->texture_target = texture_target;
     get_picture_0_1_->texture_size = texture_size;
     get_picture_0_1_ = NULL;
   }
 
   received_pictures_.pop();
 }
 
 }  // namespace proxy
 }  // namespace ppapi