Plumb texture target to VideoDecodeAccelerator::Client

content/common/gpu/media/video_decode_accelerator_unittest.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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11, EGL, and GLES2.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
 //   to be written sequentially and wait for the decode client to see certain
@@ skipping 198 matching lines @@
                         int frame_width,
                         int frame_height,
                         int profile);
   virtual ~EglRenderingVDAClient();
   void CreateDecoder();
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
   virtual void ProvidePictureBuffers(
       uint32 requested_num_of_buffers,
-      const gfx::Size& dimensions);
+      const gfx::Size& dimensions,
+      media::VideoDecodeAccelerator::TextureTarget texture_target);
   virtual void DismissPictureBuffer(int32 picture_buffer_id);
   virtual void PictureReady(const media::Picture& picture);
   // Simple state changes.
   virtual void NotifyInitializeDone();
   virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id);
   virtual void NotifyFlushDone();
   virtual void NotifyResetDone();
   virtual void NotifyError(VideoDecodeAccelerator::Error error);
 
   // Simple getters for inspecting the state of the Client.
@@ skipping 106 matching lines @@
   // Configure the decoder.
   media::VideoCodecProfile profile = media::H264PROFILE_BASELINE;
   if (profile_ != -1)
     profile = static_cast<media::VideoCodecProfile>(profile_);
   std::vector<uint8_t> avc_data(MP4_EXTRA_DATA,
                                 MP4_EXTRA_DATA + arraysize(MP4_EXTRA_DATA));
   CHECK(decoder_->Initialize(
       profile, gfx::Size(frame_width_, frame_height_), avc_data));
 }
 
+static int ToGLTextureTarget(

[Ami GONE FROM CHROMIUM, 2012/05/23 23:42:33]

Hopefully can drop.

[sail, 2012/05/29 18:58:09]

Done.

+    media::VideoDecodeAccelerator::TextureTarget texture_target) {
+  switch (texture_target) {
+    case media::VideoDecodeAccelerator::TEXTURE_TARGET_2D:
+      return GL_TEXTURE_2D;
+    case media::VideoDecodeAccelerator::TEXTURE_TARGET_ARB:
+      return GL_TEXTURE_RECTANGLE_ARB;
+  }
+  NOTREACHED();
+  return GL_TEXTURE_2D;
+}
+
 void EglRenderingVDAClient::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
-    const gfx::Size& dimensions) {
+    const gfx::Size& dimensions,
+    media::VideoDecodeAccelerator::TextureTarget texture_target) {
   if (decoder_deleted())
     return;
   std::vector<media::PictureBuffer> buffers;
 
   for (uint32 i = 0; i < requested_num_of_buffers; ++i) {
     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_, ToGLTextureTarget(texture_target), &texture_id,
+        &done);
     done.Wait();
     CHECK(outstanding_texture_ids_.insert(texture_id).second);
     media::PictureBuffer* buffer =
         new media::PictureBuffer(id, dimensions, texture_id);
     CHECK(picture_buffers_by_id_.insert(std::make_pair(id, buffer)).second);
     buffers.push_back(*buffer);
   }
   decoder_->AssignPictureBuffers(buffers);
 }
 
@@ skipping 462 matching lines @@
 
   base::ShadowingAtExitManager at_exit_manager;
   RenderingHelper::InitializePlatform();
 
 #if defined(OS_WIN)
   DXVAVideoDecodeAccelerator::PreSandboxInitialization();
 #endif
 
   return RUN_ALL_TESTS();
 }