Introduce a client minimum picture pool size

content/renderer/pepper/video_decoder_shim.cc

 // Copyright 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/video_decoder_shim.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
@@ skipping 712 matching lines @@
   // again.
   while (!pending_decodes_.empty())
     pending_decodes_.pop();
   decoder_.reset();
   // This instance is deleted once we exit this scope.
 }
 
 void VideoDecoderShim::DecoderImpl::OnInitDone(bool success) {
   int32_t result = success ? PP_OK : PP_ERROR_NOTSUPPORTED;
 
-  // Calculate how many textures the shim should create.
-  uint32_t shim_texture_pool_size = media::limits::kMaxVideoFrames + 1;
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoDecoderShim::OnInitializeComplete, shim_,
-                            result, shim_texture_pool_size));
+                            result));
 }
 
 void VideoDecoderShim::DecoderImpl::DoDecode() {
   if (pending_decodes_.empty() || awaiting_decoder_)
     return;
 
   awaiting_decoder_ = true;
   const PendingDecode& decode = pending_decodes_.front();
   decode_id_ = decode.decode_id;
   decoder_->Decode(decode.buffer,
@@ skipping 44 matching lines @@
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoDecoderShim::OnOutputComplete, shim_,
                             base::Passed(&pending_frame)));
 }
 
 void VideoDecoderShim::DecoderImpl::OnResetComplete() {
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoDecoderShim::OnResetComplete, shim_));
 }
 
-VideoDecoderShim::VideoDecoderShim(PepperVideoDecoderHost* host)
+VideoDecoderShim::VideoDecoderShim(
+    PepperVideoDecoderHost* host, uint32_t texture_pool_size)
     : state_(UNINITIALIZED),
       host_(host),
       media_task_runner_(
           RenderThreadImpl::current()->GetMediaThreadTaskRunner()),
       context_provider_(
           RenderThreadImpl::current()->SharedMainThreadContextProvider()),
-      texture_pool_size_(0),
+      texture_pool_size_(texture_pool_size),
       num_pending_decodes_(0),
       yuv_converter_(new YUVConverter(context_provider_)),
       weak_ptr_factory_(this) {
   DCHECK(host_);
   DCHECK(media_task_runner_.get());
   DCHECK(context_provider_.get());
   decoder_impl_.reset(new DecoderImpl(weak_ptr_factory_.GetWeakPtr()));
 }
 
 VideoDecoderShim::~VideoDecoderShim() {
@@ skipping 121 matching lines @@
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoDecoderShim::DecoderImpl::Reset,
                  base::Unretained(decoder_impl_.get())));
 }
 
 void VideoDecoderShim::Destroy() {
   delete this;
 }
 
-void VideoDecoderShim::OnInitializeComplete(int32_t result,
-                                            uint32_t texture_pool_size) {
+void VideoDecoderShim::OnInitializeComplete(int32_t result) {
   DCHECK(RenderThreadImpl::current());
   DCHECK(host_);
 
   if (result == PP_OK) {
     state_ = DECODING;
-    texture_pool_size_ = texture_pool_size;
   }
 
   host_->OnInitializeComplete(result);
 }
 
 void VideoDecoderShim::OnDecodeComplete(int32_t result, uint32_t decode_id) {
   DCHECK(RenderThreadImpl::current());
   DCHECK(host_);
 
   if (result == PP_ERROR_RESOURCE_FAILED) {
@@ skipping 117 matching lines @@
 void VideoDecoderShim::DeleteTexture(uint32_t texture_id) {
   gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
   gles2->DeleteTextures(1, &texture_id);
 }
 
 void VideoDecoderShim::FlushCommandBuffer() {
   context_provider_->ContextGL()->Flush();
 }
 
 }  // namespace content