Plumb texture target to VideoDecodeAccelerator::Client

Currently all VideoDecodeAccelerator::Clients use GL_TEXTURE_2D as their texture target.

Unfortunately the Mac decoder only supports GL_TEXTURE_RECTANGLE_ARB texture targets.

This CL allows decoders to choose which texture target they want.

BUG=127414
TEST=


Review URL: https://chromiumcodereview.appspot.com/10392141

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@141258 0039d316-1c4b-4281-b951-d872f2087c98

29 files changed, 170 insertions, 74 deletions

diff --git a/content/common/gpu/client/gpu_video_decode_accelerator_host.cc b/content/common/gpu/client/gpu_video_decode_accelerator_host.cc
index 0ac5167a..a903ed0 100644
--- a/content/common/gpu/client/gpu_video_decode_accelerator_host.cc
+++ b/content/common/gpu/client/gpu_video_decode_accelerator_host.cc
@@ -145,10 +145,13 @@ void GpuVideoDecodeAcceleratorHost::OnBitstreamBufferProcessed(
 
 void GpuVideoDecodeAcceleratorHost::OnProvidePictureBuffer(
     uint32 num_requested_buffers,
-    const gfx::Size& buffer_size) {
+    const gfx::Size& buffer_size,
+    uint32 texture_target) {
   DCHECK(CalledOnValidThread());
-  if (client_)
-    client_->ProvidePictureBuffers(num_requested_buffers, buffer_size);
+  if (client_) {
+    client_->ProvidePictureBuffers(
+        num_requested_buffers, buffer_size, texture_target);
+  }
 }
 
 void GpuVideoDecodeAcceleratorHost::OnDismissPictureBuffer(
diff --git a/content/common/gpu/client/gpu_video_decode_accelerator_host.h b/content/common/gpu/client/gpu_video_decode_accelerator_host.h
index a2a6a24..5a0bd78 100644
--- a/content/common/gpu/client/gpu_video_decode_accelerator_host.h
+++ b/content/common/gpu/client/gpu_video_decode_accelerator_host.h
@@ -48,8 +48,9 @@ class GpuVideoDecodeAcceleratorHost
   void Send(IPC::Message* message);
 
   void OnBitstreamBufferProcessed(int32 bitstream_buffer_id);
-  void OnProvidePictureBuffer(
-    uint32 num_requested_buffers, const gfx::Size& buffer_size);
+  void OnProvidePictureBuffer(uint32 num_requested_buffers,
+                              const gfx::Size& buffer_size,
+                              uint32 texture_target);
   void OnDismissPictureBuffer(int32 picture_buffer_id);
   void OnPictureReady(int32 picture_buffer_id, int32 bitstream_buffer_id);
   void OnFlushDone();
diff --git a/content/common/gpu/gpu_messages.h b/content/common/gpu/gpu_messages.h
index cd8a7b5..1b5746c 100644
--- a/content/common/gpu/gpu_messages.h
+++ b/content/common/gpu/gpu_messages.h
@@ -517,9 +517,11 @@ IPC_MESSAGE_ROUTED1(AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed,
                     int32) /* Processed buffer ID */
 
 // Allocate video frames for output of the hardware video decoder.
-IPC_MESSAGE_ROUTED2(AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers,
-                    int32, /* Number of video frames to generate */
-                    gfx::Size) /* Requested size of buffer */
+IPC_MESSAGE_ROUTED3(
+    AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers,
+    int32, /* Number of video frames to generate */
+    gfx::Size, /* Requested size of buffer */
+    uint32 ) /* Texture target */
 
 // Decoder reports that a picture is ready and buffer does not need to be passed
 // back to the decoder.
diff --git a/content/common/gpu/media/dxva_video_decode_accelerator.cc b/content/common/gpu/media/dxva_video_decode_accelerator.cc
index 28f5f66..207702b 100644
--- a/content/common/gpu/media/dxva_video_decode_accelerator.cc
+++ b/content/common/gpu/media/dxva_video_decode_accelerator.cc
@@ -1014,8 +1014,10 @@ void DXVAVideoDecodeAccelerator::RequestPictureBuffers(int width, int height) {
   // TODO(ananta)
   // We need to support mid stream resize.
   if (state_ != kUninitialized && client_) {
-    client_->ProvidePictureBuffers(kNumPictureBuffers,
-                                   gfx::Size(width, height));
+    client_->ProvidePictureBuffers(
+        kNumPictureBuffers,
+        gfx::Size(width, height),
+        GL_TEXTURE_2D);
   }
 }
 
diff --git a/content/common/gpu/media/gpu_video_decode_accelerator.cc b/content/common/gpu/media/gpu_video_decode_accelerator.cc
index 6ad1329..9c67bbf 100644
--- a/content/common/gpu/media/gpu_video_decode_accelerator.cc
+++ b/content/common/gpu/media/gpu_video_decode_accelerator.cc
@@ -69,9 +69,12 @@ bool GpuVideoDecodeAccelerator::OnMessageReceived(const IPC::Message& msg) {
 }
 
 void GpuVideoDecodeAccelerator::ProvidePictureBuffers(
-    uint32 requested_num_of_buffers, const gfx::Size& dimensions) {
+    uint32 requested_num_of_buffers,
+    const gfx::Size& dimensions,
+    uint32 texture_target) {
   if (!Send(new AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers(
-          host_route_id_, requested_num_of_buffers, dimensions))) {
+          host_route_id_, requested_num_of_buffers, dimensions,
+          texture_target))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers) "
                 << "failed";
   }
diff --git a/content/common/gpu/media/gpu_video_decode_accelerator.h b/content/common/gpu/media/gpu_video_decode_accelerator.h
index bf37e38..9abe74c 100644
--- a/content/common/gpu/media/gpu_video_decode_accelerator.h
+++ b/content/common/gpu/media/gpu_video_decode_accelerator.h
@@ -30,8 +30,9 @@ class GpuVideoDecodeAccelerator
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
   // media::VideoDecodeAccelerator::Client implementation.
-  virtual void ProvidePictureBuffers(
-      uint32 requested_num_of_buffers, const gfx::Size& dimensions) OVERRIDE;
+  virtual void ProvidePictureBuffers(uint32 requested_num_of_buffers,
+                                     const gfx::Size& dimensions,
+                                     uint32 texture_target) OVERRIDE;
   virtual void DismissPictureBuffer(int32 picture_buffer_id) OVERRIDE;
   virtual void PictureReady(const media::Picture& picture) OVERRIDE;
   virtual void NotifyInitializeDone() OVERRIDE;
diff --git a/content/common/gpu/media/mac_video_decode_accelerator.mm b/content/common/gpu/media/mac_video_decode_accelerator.mm
index c21a4f9..6008069 100644
--- a/content/common/gpu/media/mac_video_decode_accelerator.mm
+++ b/content/common/gpu/media/mac_video_decode_accelerator.mm
@@ -328,7 +328,8 @@ void MacVideoDecodeAccelerator::RequestPictures() {
     client_->ProvidePictureBuffers(
         kNumPictureBuffers,
         gfx::Size(config_record_builder_.coded_width(),
-                  config_record_builder_.coded_height()));
+                  config_record_builder_.coded_height()),
+        GL_TEXTURE_RECTANGLE_ARB);
   }
 }
 
diff --git a/content/common/gpu/media/omx_video_decode_accelerator.cc b/content/common/gpu/media/omx_video_decode_accelerator.cc
index 811997d..5e88010 100644
--- a/content/common/gpu/media/omx_video_decode_accelerator.cc
+++ b/content/common/gpu/media/omx_video_decode_accelerator.cc
@@ -748,7 +748,8 @@ void OmxVideoDecodeAccelerator::OnOutputPortDisabled() {
   if (client_) {
     client_->ProvidePictureBuffers(
         kNumPictureBuffers,
-        gfx::Size(vformat.nFrameWidth, vformat.nFrameHeight));
+        gfx::Size(vformat.nFrameWidth, vformat.nFrameHeight),
+        GL_TEXTURE_2D);
   }
 }
 
diff --git a/content/common/gpu/media/rendering_helper.h b/content/common/gpu/media/rendering_helper.h
index ff99f65..a62fb60 100644
--- a/content/common/gpu/media/rendering_helper.h
+++ b/content/common/gpu/media/rendering_helper.h
@@ -40,6 +40,7 @@ class RenderingHelper {
   // Return a newly-created GLES2 texture id rendering to a specific window, and
   // signal |*done|.
   virtual void CreateTexture(int window_id,
+                             uint32 texture_target,
                              uint32* texture_id,
                              base::WaitableEvent* done) = 0;
 
diff --git a/content/common/gpu/media/rendering_helper_egl.cc b/content/common/gpu/media/rendering_helper_egl.cc
index 17f2173..dc15309 100644
--- a/content/common/gpu/media/rendering_helper_egl.cc
+++ b/content/common/gpu/media/rendering_helper_egl.cc
@@ -57,6 +57,7 @@ class RenderingHelperEGL : public RenderingHelper {
                           base::WaitableEvent* done) OVERRIDE;
   virtual void UnInitialize(base::WaitableEvent* done) OVERRIDE;
   virtual void CreateTexture(int window_id,
+                             uint32 texture_target,
                              uint32* texture_id,
                              base::WaitableEvent* done) OVERRIDE;
   virtual void RenderTexture(uint32 texture_id) OVERRIDE;
@@ -245,15 +246,17 @@ void RenderingHelperEGL::UnInitialize(base::WaitableEvent* done) {
 }
 
 void RenderingHelperEGL::CreateTexture(int window_id,
+                                       uint32 texture_target,
                                        uint32* texture_id,
                                        base::WaitableEvent* done) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&RenderingHelper::CreateTexture, base::Unretained(this),
-                   window_id, texture_id, done));
+                   window_id, texture_target, texture_id, done));
     return;
   }
+  CHECK_EQ(static_cast<uint32>(GL_TEXTURE_2D), texture_target);
   CHECK(eglMakeCurrent(egl_display_, egl_surfaces_[window_id],
                        egl_surfaces_[window_id], egl_context_))
       << eglGetError();
diff --git a/content/common/gpu/media/rendering_helper_mac.mm b/content/common/gpu/media/rendering_helper_mac.mm
index 163fe53..0bd0076 100644
--- a/content/common/gpu/media/rendering_helper_mac.mm
+++ b/content/common/gpu/media/rendering_helper_mac.mm
@@ -90,6 +90,7 @@ class RenderingHelperMac : public RenderingHelper {
                           base::WaitableEvent* done) OVERRIDE;
   virtual void UnInitialize(base::WaitableEvent* done) OVERRIDE;
   virtual void CreateTexture(int window_id,
+                             uint32 texture_target,
                              GLuint* texture_id,
                              base::WaitableEvent* done) OVERRIDE;
   virtual void RenderTexture(GLuint texture_id) OVERRIDE;
@@ -185,9 +186,11 @@ void RenderingHelperMac::UnInitialize(base::WaitableEvent* done) {
 }
 
 void RenderingHelperMac::CreateTexture(int window_id,
+                                       uint32 texture_target,
                                        GLuint* texture_id,
                                        base::WaitableEvent* done) {
   CHECK_EQ(MessageLoop::current(), message_loop_);
+  CHECK_EQ(static_cast<uint32>(GL_TEXTURE_RECTANGLE_ARB), texture_target);
   CGLContextObj cgl_ctx = GetCGLContext(gl_view_);
   glGenTextures(1, texture_id);
   CHECK_EQ(GL_NO_ERROR, static_cast<int>(glGetError()));
diff --git a/content/common/gpu/media/video_decode_accelerator_unittest.cc b/content/common/gpu/media/video_decode_accelerator_unittest.cc
index 411c85e..2d8162a 100644
--- a/content/common/gpu/media/video_decode_accelerator_unittest.cc
+++ b/content/common/gpu/media/video_decode_accelerator_unittest.cc
@@ -204,9 +204,9 @@ class EglRenderingVDAClient : public VideoDecodeAccelerator::Client {
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
-  virtual void ProvidePictureBuffers(
-      uint32 requested_num_of_buffers,
-      const gfx::Size& dimensions);
+  virtual void ProvidePictureBuffers(uint32 requested_num_of_buffers,
+                                     const gfx::Size& dimensions,
+                                     uint32 texture_target);
   virtual void DismissPictureBuffer(int32 picture_buffer_id);
   virtual void PictureReady(const media::Picture& picture);
   // Simple state changes.
@@ -333,7 +333,8 @@ void EglRenderingVDAClient::CreateDecoder() {
 
 void EglRenderingVDAClient::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
-    const gfx::Size& dimensions) {
+    const gfx::Size& dimensions,
+    uint32 texture_target) {
   if (decoder_deleted())
     return;
   std::vector<media::PictureBuffer> buffers;
@@ -342,7 +343,8 @@ void EglRenderingVDAClient::ProvidePictureBuffers(
     uint32 id = picture_buffers_by_id_.size();
     uint32 texture_id;
     base::WaitableEvent done(false, false);
-    rendering_helper_->CreateTexture(rendering_window_id_, &texture_id, &done);
+    rendering_helper_->CreateTexture(
+        rendering_window_id_, texture_target, &texture_id, &done);
     done.Wait();
     CHECK(outstanding_texture_ids_.insert(texture_id).second);
     media::PictureBuffer* buffer =
diff --git a/content/renderer/media/pepper_platform_video_decoder_impl.cc b/content/renderer/media/pepper_platform_video_decoder_impl.cc
index 503cd43..62e5d23 100644
--- a/content/renderer/media/pepper_platform_video_decoder_impl.cc
+++ b/content/renderer/media/pepper_platform_video_decoder_impl.cc
@@ -90,9 +90,11 @@ void PlatformVideoDecoderImpl::NotifyError(
 
 void PlatformVideoDecoderImpl::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
-    const gfx::Size& dimensions) {
+    const gfx::Size& dimensions,
+    uint32 texture_target) {
   DCHECK(RenderThreadImpl::current());
-  client_->ProvidePictureBuffers(requested_num_of_buffers, dimensions);
+  client_->ProvidePictureBuffers(requested_num_of_buffers, dimensions,
+                                 texture_target);
 }
 
 void PlatformVideoDecoderImpl::DismissPictureBuffer(int32 picture_buffer_id) {
diff --git a/content/renderer/media/pepper_platform_video_decoder_impl.h b/content/renderer/media/pepper_platform_video_decoder_impl.h
index a3c4341..d79ce01 100644
--- a/content/renderer/media/pepper_platform_video_decoder_impl.h
+++ b/content/renderer/media/pepper_platform_video_decoder_impl.h
@@ -33,8 +33,9 @@ class PlatformVideoDecoderImpl
   virtual void Destroy() OVERRIDE;
 
   // VideoDecodeAccelerator::Client implementation.
-  virtual void ProvidePictureBuffers(
-      uint32 requested_num_of_buffers, const gfx::Size& dimensions) OVERRIDE;
+  virtual void ProvidePictureBuffers(uint32 requested_num_of_buffers,
+                                     const gfx::Size& dimensions,
+                                     uint32 texture_target) OVERRIDE;
   virtual void PictureReady(const media::Picture& picture) OVERRIDE;
   virtual void DismissPictureBuffer(int32 picture_buffer_id) OVERRIDE;
   virtual void NotifyInitializeDone() OVERRIDE;
diff --git a/content/renderer/media/renderer_gpu_video_decoder_factories.cc b/content/renderer/media/renderer_gpu_video_decoder_factories.cc
index 82d145b..305ef99 100644
--- a/content/renderer/media/renderer_gpu_video_decoder_factories.cc
+++ b/content/renderer/media/renderer_gpu_video_decoder_factories.cc
@@ -75,7 +75,7 @@ void RendererGpuVideoDecoderFactories::AsyncCreateVideoDecodeAccelerator(
 bool RendererGpuVideoDecoderFactories::CreateTextures(
     int32 count, const gfx::Size& size,
     std::vector<uint32>* texture_ids,
-    uint32* texture_target) {
+    uint32 texture_target) {
   DCHECK_NE(MessageLoop::current(), message_loop_);
   bool success = false;
   base::WaitableEvent waiter(false, false);
@@ -88,8 +88,9 @@ bool RendererGpuVideoDecoderFactories::CreateTextures(
 
 void RendererGpuVideoDecoderFactories::AsyncCreateTextures(
     int32 count, const gfx::Size& size, std::vector<uint32>* texture_ids,
-    uint32* texture_target, bool* success, base::WaitableEvent* waiter) {
+    uint32 texture_target, bool* success, base::WaitableEvent* waiter) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(texture_target);
   if (!context_) {
     *success = false;
     waiter->Signal();
@@ -98,16 +99,15 @@ void RendererGpuVideoDecoderFactories::AsyncCreateTextures(
   gpu::gles2::GLES2Implementation* gles2 = context_->GetImplementation();
   texture_ids->resize(count);
   gles2->GenTextures(count, &texture_ids->at(0));
-  *texture_target = GL_TEXTURE_2D;
   for (int i = 0; i < count; ++i) {
     gles2->ActiveTexture(GL_TEXTURE0);
     uint32 texture_id = texture_ids->at(i);
-    gles2->BindTexture(*texture_target, texture_id);
-    gles2->TexParameteri(*texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    gles2->TexParameteri(*texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    gles2->TexParameterf(*texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    gles2->TexParameterf(*texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    gles2->TexImage2D(*texture_target, 0, GL_RGBA, size.width(), size.height(),
+    gles2->BindTexture(texture_target, texture_id);
+    gles2->TexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    gles2->TexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    gles2->TexParameterf(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    gles2->TexParameterf(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    gles2->TexImage2D(texture_target, 0, GL_RGBA, size.width(), size.height(),
                       0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
   }
   // We need a glFlush here to guarantee the decoder (in the GPU process) can
diff --git a/content/renderer/media/renderer_gpu_video_decoder_factories.h b/content/renderer/media/renderer_gpu_video_decoder_factories.h
index a4150ea..c4386f2 100644
--- a/content/renderer/media/renderer_gpu_video_decoder_factories.h
+++ b/content/renderer/media/renderer_gpu_video_decoder_factories.h
@@ -46,7 +46,7 @@ class CONTENT_EXPORT RendererGpuVideoDecoderFactories
 
   virtual bool CreateTextures(int32 count, const gfx::Size& size,
                               std::vector<uint32>* texture_ids,
-                              uint32* texture_target) OVERRIDE;
+                              uint32 texture_target) OVERRIDE;
 
   virtual void DeleteTexture(uint32 texture_id) OVERRIDE;
 
@@ -74,7 +74,7 @@ class CONTENT_EXPORT RendererGpuVideoDecoderFactories
       base::WaitableEvent* waiter);
   void AsyncCreateTextures(
       int32 count, const gfx::Size& size, std::vector<uint32>* texture_ids,
-      uint32* texture_target, bool* success, base::WaitableEvent* waiter);
+      uint32 texture_target, bool* success, base::WaitableEvent* waiter);
   void AsyncDeleteTexture(uint32 texture_id);
   void AsyncCreateSharedMemory(
       size_t size, base::SharedMemory** shm, base::WaitableEvent* waiter);
diff --git a/media/filters/gpu_video_decoder.cc b/media/filters/gpu_video_decoder.cc
index 9352790..9899f8d 100644
--- a/media/filters/gpu_video_decoder.cc
+++ b/media/filters/gpu_video_decoder.cc
@@ -298,16 +298,19 @@ void GpuVideoDecoder::NotifyInitializeDone() {
 }
 
 void GpuVideoDecoder::ProvidePictureBuffers(uint32 count,
-                                            const gfx::Size& size) {
+                                            const gfx::Size& size,
+                                            uint32 texture_target) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::ProvidePictureBuffers, this, count, size));
+        &GpuVideoDecoder::ProvidePictureBuffers, this, count, size,
+        texture_target));
     return;
   }
 
   std::vector<uint32> texture_ids;
+  decoder_texture_target_ = texture_target;
   if (!factories_->CreateTextures(
-      count, size, &texture_ids, &decoder_texture_target_)) {
+      count, size, &texture_ids, decoder_texture_target_)) {
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
diff --git a/media/filters/gpu_video_decoder.h b/media/filters/gpu_video_decoder.h
index 4274d15..f4c3c63 100644
--- a/media/filters/gpu_video_decoder.h
+++ b/media/filters/gpu_video_decoder.h
@@ -42,7 +42,7 @@ class MEDIA_EXPORT GpuVideoDecoder
     // Allocate & delete native textures.
     virtual bool CreateTextures(int32 count, const gfx::Size& size,
                                 std::vector<uint32>* texture_ids,
-                                uint32* texture_target) = 0;
+                                uint32 texture_target) = 0;
     virtual void DeleteTexture(uint32 texture_id) = 0;
 
     // Allocate & return a shared memory segment.  Caller is responsible for
@@ -72,7 +72,8 @@ class MEDIA_EXPORT GpuVideoDecoder
   // VideoDecodeAccelerator::Client implementation.
   virtual void NotifyInitializeDone() OVERRIDE;
   virtual void ProvidePictureBuffers(uint32 count,
-                                     const gfx::Size& size) OVERRIDE;
+                                     const gfx::Size& size,
+                                     uint32 texture_target) OVERRIDE;
   virtual void DismissPictureBuffer(int32 id) OVERRIDE;
   virtual void PictureReady(const media::Picture& picture) OVERRIDE;
   virtual void NotifyEndOfBitstreamBuffer(int32 id) OVERRIDE;
diff --git a/media/video/video_decode_accelerator.h b/media/video/video_decode_accelerator.h
index 5fa0d21..c04d8dc 100644
--- a/media/video/video_decode_accelerator.h
+++ b/media/video/video_decode_accelerator.h
@@ -52,8 +52,9 @@ class MEDIA_EXPORT VideoDecodeAccelerator
     virtual void NotifyInitializeDone() = 0;
 
     // Callback to tell client how many and what size of buffers to provide.
-    virtual void ProvidePictureBuffers(
-        uint32 requested_num_of_buffers, const gfx::Size& dimensions) = 0;
+    virtual void ProvidePictureBuffers(uint32 requested_num_of_buffers,
+                                       const gfx::Size& dimensions,
+                                       uint32 texture_target) = 0;
 
     // Callback to dismiss picture buffer that was assigned earlier.
     virtual void DismissPictureBuffer(int32 picture_buffer_id) = 0;
diff --git a/ppapi/api/dev/ppp_video_decoder_dev.idl b/ppapi/api/dev/ppp_video_decoder_dev.idl
index 2a6e419..1f6d8c6 100644
--- a/ppapi/api/dev/ppp_video_decoder_dev.idl
+++ b/ppapi/api/dev/ppp_video_decoder_dev.idl
@@ -8,7 +8,8 @@
  */
 label Chrome {
   M14 = 0.9,
-  M18 = 0.10
+  M18 = 0.10,
+  M21 = 0.11
 };
 
 /**
@@ -33,6 +34,7 @@ interface PPP_VideoDecoder_Dev {
    *  |req_num_of_bufs| tells how many buffers are needed by the decoder.
    *  |dimensions| tells the dimensions of the buffer to allocate.
    */
+  [deprecate=0.11]
   void ProvidePictureBuffers(
       [in] PP_Instance instance,
       [in] PP_Resource decoder,
@@ -40,6 +42,29 @@ interface PPP_VideoDecoder_Dev {
       [in] PP_Size dimensions);
 
   /**
+   * Callback function to provide buffers for the decoded output pictures. If
+   * succeeds plugin must provide buffers through AssignPictureBuffers function
+   * to the API. If |req_num_of_bufs| matching exactly the specification
+   * given in the parameters cannot be allocated decoder should be destroyed.
+   *
+   * Decoding will not proceed until buffers have been provided.
+   *
+   * Parameters:
+   *  |instance| the plugin instance to which the callback is responding.
+   *  |decoder| the PPB_VideoDecoder_Dev resource.
+   *  |req_num_of_bufs| tells how many buffers are needed by the decoder.
+   *  |dimensions| tells the dimensions of the buffer to allocate.
+   *  |texture_target| the type of texture used.
+   */
+  [version=0.11]
+  void ProvidePictureBuffers(
+      [in] PP_Instance instance,
+      [in] PP_Resource decoder,
+      [in] uint32_t req_num_of_bufs,
+      [in] PP_Size dimensions,
+      [in] uint32_t texture_target);
+
+  /**
    * Callback function for decoder to deliver unneeded picture buffers back to
    * the plugin.
    *
diff --git a/ppapi/c/dev/ppp_video_decoder_dev.h b/ppapi/c/dev/ppp_video_decoder_dev.h
index a06b582..20c4e8c 100644
--- a/ppapi/c/dev/ppp_video_decoder_dev.h
+++ b/ppapi/c/dev/ppp_video_decoder_dev.h
@@ -3,7 +3,7 @@
  * found in the LICENSE file.
  */
 
-/* From dev/ppp_video_decoder_dev.idl modified Wed Jan 11 14:58:58 2012. */
+/* From dev/ppp_video_decoder_dev.idl modified Tue May 29 10:59:23 2012. */
 
 #ifndef PPAPI_C_DEV_PPP_VIDEO_DECODER_DEV_H_
 #define PPAPI_C_DEV_PPP_VIDEO_DECODER_DEV_H_
@@ -17,7 +17,8 @@
 
 #define PPP_VIDEODECODER_DEV_INTERFACE_0_9 "PPP_VideoDecoder(Dev);0.9"
 #define PPP_VIDEODECODER_DEV_INTERFACE_0_10 "PPP_VideoDecoder(Dev);0.10"
-#define PPP_VIDEODECODER_DEV_INTERFACE PPP_VIDEODECODER_DEV_INTERFACE_0_10
+#define PPP_VIDEODECODER_DEV_INTERFACE_0_11 "PPP_VideoDecoder(Dev);0.11"
+#define PPP_VIDEODECODER_DEV_INTERFACE PPP_VIDEODECODER_DEV_INTERFACE_0_11
 
 /**
  * @file
@@ -36,7 +37,7 @@
  *
  * See PPB_VideoDecoder_Dev for general usage tips.
  */
-struct PPP_VideoDecoder_Dev_0_10 {
+struct PPP_VideoDecoder_Dev_0_11 {
   /**
    * Callback function to provide buffers for the decoded output pictures. If
    * succeeds plugin must provide buffers through AssignPictureBuffers function
@@ -50,11 +51,13 @@ struct PPP_VideoDecoder_Dev_0_10 {
    *  |decoder| the PPB_VideoDecoder_Dev resource.
    *  |req_num_of_bufs| tells how many buffers are needed by the decoder.
    *  |dimensions| tells the dimensions of the buffer to allocate.
+   *  |texture_target| the type of texture used.
    */
   void (*ProvidePictureBuffers)(PP_Instance instance,
                                 PP_Resource decoder,
                                 uint32_t req_num_of_bufs,
-                                const struct PP_Size* dimensions);
+                                const struct PP_Size* dimensions,
+                                uint32_t texture_target);
   /**
    * Callback function for decoder to deliver unneeded picture buffers back to
    * the plugin.
@@ -94,7 +97,7 @@ struct PPP_VideoDecoder_Dev_0_10 {
                       PP_VideoDecodeError_Dev error);
 };
 
-typedef struct PPP_VideoDecoder_Dev_0_10 PPP_VideoDecoder_Dev;
+typedef struct PPP_VideoDecoder_Dev_0_11 PPP_VideoDecoder_Dev;
 
 struct PPP_VideoDecoder_Dev_0_9 {
   void (*ProvidePictureBuffers)(PP_Instance instance,
@@ -112,6 +115,22 @@ struct PPP_VideoDecoder_Dev_0_9 {
                       PP_Resource decoder,
                       PP_VideoDecodeError_Dev error);
 };
+
+struct PPP_VideoDecoder_Dev_0_10 {
+  void (*ProvidePictureBuffers)(PP_Instance instance,
+                                PP_Resource decoder,
+                                uint32_t req_num_of_bufs,
+                                const struct PP_Size* dimensions);
+  void (*DismissPictureBuffer)(PP_Instance instance,
+                               PP_Resource decoder,
+                               int32_t picture_buffer_id);
+  void (*PictureReady)(PP_Instance instance,
+                       PP_Resource decoder,
+                       const struct PP_Picture_Dev* picture);
+  void (*NotifyError)(PP_Instance instance,
+                      PP_Resource decoder,
+                      PP_VideoDecodeError_Dev error);
+};
 /**
  * @}
  */
diff --git a/ppapi/cpp/dev/video_decoder_client_dev.cc b/ppapi/cpp/dev/video_decoder_client_dev.cc
index eaab575..10c2619 100644
--- a/ppapi/cpp/dev/video_decoder_client_dev.cc
+++ b/ppapi/cpp/dev/video_decoder_client_dev.cc
@@ -21,13 +21,14 @@ const char kPPPVideoDecoderInterface[] = PPP_VIDEODECODER_DEV_INTERFACE;
 void ProvidePictureBuffers(PP_Instance instance,
                            PP_Resource decoder,
                            uint32_t req_num_of_bufs,
-                           const PP_Size* dimensions) {
+                           const PP_Size* dimensions,
+                           uint32_t texture_target) {
   void* object = Instance::GetPerInstanceObject(instance,
                                                 kPPPVideoDecoderInterface);
   if (!object)
     return;
   static_cast<VideoDecoderClient_Dev*>(object)->ProvidePictureBuffers(
-      decoder, req_num_of_bufs, *dimensions);
+      decoder, req_num_of_bufs, *dimensions, texture_target);
 }
 
 void DismissPictureBuffer(PP_Instance instance,
diff --git a/ppapi/cpp/dev/video_decoder_client_dev.h b/ppapi/cpp/dev/video_decoder_client_dev.h
index d598b40..a6e2bb5 100644
--- a/ppapi/cpp/dev/video_decoder_client_dev.h
+++ b/ppapi/cpp/dev/video_decoder_client_dev.h
@@ -26,7 +26,8 @@ class VideoDecoderClient_Dev {
   // Callback to provide buffers for the decoded output pictures.
   virtual void ProvidePictureBuffers(PP_Resource decoder,
                                      uint32_t req_num_of_bufs,
-                                     const PP_Size& dimensions) = 0;
+                                     const PP_Size& dimensions,
+                                     uint32_t texture_target) = 0;
 
   // Callback for decoder to deliver unneeded picture buffers back to the
   // plugin.
diff --git a/ppapi/examples/video_decode/video_decode.cc b/ppapi/examples/video_decode/video_decode.cc
index dd0c08f..6e4f4e1 100644
--- a/ppapi/examples/video_decode/video_decode.cc
+++ b/ppapi/examples/video_decode/video_decode.cc
@@ -60,9 +60,11 @@ class VideoDecodeDemoInstance : public pp::Instance,
   }
 
   // pp::VideoDecoderClient_Dev implementation.
-  virtual void ProvidePictureBuffers(PP_Resource decoder,
-                                     uint32_t req_num_of_bufs,
-                                     const PP_Size& dimensions);
+  virtual void ProvidePictureBuffers(
+      PP_Resource decoder,
+      uint32_t req_num_of_bufs,
+      const PP_Size& dimensions,
+      uint32_t texture_target);
   virtual void DismissPictureBuffer(PP_Resource decoder,
                                     int32_t picture_buffer_id);
   virtual void PictureReady(PP_Resource decoder, const PP_Picture_Dev& picture);
@@ -82,8 +84,10 @@ class VideoDecodeDemoInstance : public pp::Instance,
     void DecodeNextNALUs();
 
     // Per-decoder implementation of part of pp::VideoDecoderClient_Dev.
-    void ProvidePictureBuffers(uint32_t req_num_of_bufs,
-                               PP_Size dimensions);
+    void ProvidePictureBuffers(
+        uint32_t req_num_of_bufs,
+        PP_Size dimensions,
+        uint32_t texture_target);
     void DismissPictureBuffer(int32_t picture_buffer_id);
 
     const PP_PictureBuffer_Dev& GetPictureBufferById(int id);
@@ -320,15 +324,21 @@ void VideoDecodeDemoInstance::DecoderClient::DecodeNextNALU() {
   decoder_->Decode(bitstream_buffer, cb);
 }
 
-void VideoDecodeDemoInstance::ProvidePictureBuffers(
-    PP_Resource decoder, uint32_t req_num_of_bufs, const PP_Size& dimensions) {
+void VideoDecodeDemoInstance::ProvidePictureBuffers(PP_Resource decoder,
+                                                    uint32_t req_num_of_bufs,
+                                                    const PP_Size& dimensions,
+                                                    uint32_t texture_target) {
   DecoderClient* client = video_decoders_[decoder];
   assert(client);
-  client->ProvidePictureBuffers(req_num_of_bufs, dimensions);
+  client->ProvidePictureBuffers(req_num_of_bufs, dimensions, texture_target);
 }
 
 void VideoDecodeDemoInstance::DecoderClient::ProvidePictureBuffers(
-    uint32_t req_num_of_bufs, PP_Size dimensions) {
+    uint32_t req_num_of_bufs,
+    PP_Size dimensions,
+    uint32_t texture_target) {
+  // TODO(sail): Add support for GL_TEXTURE_RECTANGLE_ARB.
+  assert(texture_target == GL_TEXTURE_2D);
   std::vector<PP_PictureBuffer_Dev> buffers;
   for (uint32_t i = 0; i < req_num_of_bufs; ++i) {
     PP_PictureBuffer_Dev buffer;
diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h
index b2787a9..16c57c1 100644
--- a/ppapi/proxy/ppapi_messages.h
+++ b/ppapi/proxy/ppapi_messages.h
@@ -626,10 +626,11 @@ IPC_MESSAGE_ROUTED2(PpapiMsg_PPBVideoDecoder_ResetACK,
                     int32_t /* PP_CompletionCallback result */)
 
 // PPP_VideoDecoder_Dev.
-IPC_MESSAGE_ROUTED3(PpapiMsg_PPPVideoDecoder_ProvidePictureBuffers,
+IPC_MESSAGE_ROUTED4(PpapiMsg_PPPVideoDecoder_ProvidePictureBuffers,
                     ppapi::HostResource /* video_decoder */,
                     uint32_t /* requested number of buffers */,
-                    PP_Size /* dimensions of buffers */)
+                    PP_Size /* dimensions of buffers */,
+                    uint32_t /* texture_target */)
 IPC_MESSAGE_ROUTED2(PpapiMsg_PPPVideoDecoder_DismissPictureBuffer,
                     ppapi::HostResource /* video_decoder */,
                     int32_t /* picture buffer id */)
diff --git a/ppapi/proxy/ppp_video_decoder_proxy.cc b/ppapi/proxy/ppp_video_decoder_proxy.cc
index 1ebf20a..7648b7f 100644
--- a/ppapi/proxy/ppp_video_decoder_proxy.cc
+++ b/ppapi/proxy/ppp_video_decoder_proxy.cc
@@ -22,14 +22,15 @@ namespace {
 
 void ProvidePictureBuffers(PP_Instance instance, PP_Resource decoder,
                            uint32_t req_num_of_bufs,
-                           const PP_Size* dimensions) {
+                           const PP_Size* dimensions,
+                           uint32_t texture_target) {
   HostResource decoder_resource;
   decoder_resource.SetHostResource(instance, decoder);
 
   HostDispatcher::GetForInstance(instance)->Send(
       new PpapiMsg_PPPVideoDecoder_ProvidePictureBuffers(
           API_ID_PPP_VIDEO_DECODER_DEV,
-          decoder_resource, req_num_of_bufs, *dimensions));
+          decoder_resource, req_num_of_bufs, *dimensions, texture_target));
 }
 
 void DismissPictureBuffer(PP_Instance instance, PP_Resource decoder,
@@ -118,15 +119,18 @@ bool PPP_VideoDecoder_Proxy::OnMessageReceived(const IPC::Message& msg) {
 }
 
 void PPP_VideoDecoder_Proxy::OnMsgProvidePictureBuffers(
-    const HostResource& decoder, uint32_t req_num_of_bufs,
-    const PP_Size& dimensions) {
+    const HostResource& decoder,
+    uint32_t req_num_of_bufs,
+    const PP_Size& dimensions,
+    uint32_t texture_target) {
   PP_Resource plugin_decoder = PluginGlobals::Get()->plugin_resource_tracker()->
       PluginResourceForHostResource(decoder);
   CallWhileUnlocked(ppp_video_decoder_impl_->ProvidePictureBuffers,
                     decoder.instance(),
                     plugin_decoder,
                     req_num_of_bufs,
-                    &dimensions);
+                    &dimensions,
+                    texture_target);
 }
 
 void PPP_VideoDecoder_Proxy::OnMsgDismissPictureBuffer(
diff --git a/ppapi/proxy/ppp_video_decoder_proxy.h b/ppapi/proxy/ppp_video_decoder_proxy.h
index c4ff4c3..84d83a5 100644
--- a/ppapi/proxy/ppp_video_decoder_proxy.h
+++ b/ppapi/proxy/ppp_video_decoder_proxy.h
@@ -30,7 +30,8 @@ class PPP_VideoDecoder_Proxy : public InterfaceProxy {
   // Message handlers.
   void OnMsgProvidePictureBuffers(const ppapi::HostResource& decoder,
                                   uint32_t req_num_of_buffers,
-                                  const PP_Size& dimensions);
+                                  const PP_Size& dimensions,
+                                  uint32_t texture_target);
   void OnMsgDismissPictureBuffer(const ppapi::HostResource& decoder,
                                  int32_t picture_id);
   void OnMsgPictureReady(const ppapi::HostResource& decoder,
diff --git a/webkit/plugins/ppapi/ppb_video_decoder_impl.cc b/webkit/plugins/ppapi/ppb_video_decoder_impl.cc
index db8a8f6..ab0773c 100644
--- a/webkit/plugins/ppapi/ppb_video_decoder_impl.cc
+++ b/webkit/plugins/ppapi/ppb_video_decoder_impl.cc
@@ -220,13 +220,15 @@ void PPB_VideoDecoder_Impl::Destroy() {
 }
 
 void PPB_VideoDecoder_Impl::ProvidePictureBuffers(
-    uint32 requested_num_of_buffers, const gfx::Size& dimensions) {
+    uint32 requested_num_of_buffers,
+    const gfx::Size& dimensions,
+    uint32 texture_target) {
   if (!ppp_videodecoder_)
     return;
 
   PP_Size out_dim = PP_MakeSize(dimensions.width(), dimensions.height());
   ppp_videodecoder_->ProvidePictureBuffers(pp_instance(), pp_resource(),
-                                           requested_num_of_buffers, &out_dim);
+      requested_num_of_buffers, &out_dim, texture_target);
 }
 
 void PPB_VideoDecoder_Impl::PictureReady(const media::Picture& picture) {
diff --git a/webkit/plugins/ppapi/ppb_video_decoder_impl.h b/webkit/plugins/ppapi/ppb_video_decoder_impl.h
index 7bb8cc0..895874b3 100644
--- a/webkit/plugins/ppapi/ppb_video_decoder_impl.h
+++ b/webkit/plugins/ppapi/ppb_video_decoder_impl.h
@@ -49,8 +49,9 @@ class PPB_VideoDecoder_Impl : public ::ppapi::PPB_VideoDecoder_Shared,
   virtual void Destroy() OVERRIDE;
 
   // media::VideoDecodeAccelerator::Client implementation.
-  virtual void ProvidePictureBuffers(
-      uint32 requested_num_of_buffers, const gfx::Size& dimensions) OVERRIDE;
+  virtual void ProvidePictureBuffers(uint32 requested_num_of_buffers,
+                                     const gfx::Size& dimensions,
+                                     uint32 texture_target) OVERRIDE;
   virtual void DismissPictureBuffer(int32 picture_buffer_id) OVERRIDE;
   virtual void PictureReady(const media::Picture& picture) OVERRIDE;
   virtual void NotifyInitializeDone() OVERRIDE;