Add |texture_target_| and |pixel_format_| to media::PictureBuffer

media/gpu/ipc/service/gpu_video_decode_accelerator.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 "media/gpu/ipc/service/gpu_video_decode_accelerator.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 143 matching lines @@
   IPC::Sender* sender_;
 };
 
 GpuVideoDecodeAccelerator::GpuVideoDecodeAccelerator(
     int32_t host_route_id,
     gpu::GpuCommandBufferStub* stub,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const AndroidOverlayMojoFactoryCB& overlay_factory_cb)
     : host_route_id_(host_route_id),
       stub_(stub),
-      texture_target_(0),
       textures_per_buffer_(0),
       filter_removed_(base::WaitableEvent::ResetPolicy::MANUAL,
                       base::WaitableEvent::InitialState::NOT_SIGNALED),
       child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(io_task_runner),
       overlay_factory_cb_(overlay_factory_cb),
       weak_factory_for_io_(this) {
   DCHECK(stub_);
   stub_->AddDestructionObserver(this);
   get_gl_context_cb_ = base::Bind(&GetGLContext, stub_->AsWeakPtr());
@@ skipping 59 matching lines @@
       dimensions.GetArea() > limits::kMaxCanvas) {
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   if (!Send(new AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers(
           host_route_id_, requested_num_of_buffers, format, textures_per_buffer,
           dimensions, texture_target))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers) "
                 << "failed";
   }
-  texture_dimensions_ = dimensions;
   textures_per_buffer_ = textures_per_buffer;
-  texture_target_ = texture_target;
 }
 
 void GpuVideoDecodeAccelerator::DismissPictureBuffer(
     int32_t picture_buffer_id) {
   // Notify client that picture buffer is now unused.
   if (!Send(new AcceleratedVideoDecoderHostMsg_DismissPictureBuffer(
           host_route_id_, picture_buffer_id))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_DismissPictureBuffer) "
                 << "failed";
   }
@@ skipping 138 matching lines @@
 // Runs on IO thread if VDA::TryToSetupDecodeOnSeparateThread() succeeded,
 // otherwise on the main thread.
 void GpuVideoDecodeAccelerator::OnDecode(
     const BitstreamBuffer& bitstream_buffer) {
   DCHECK(video_decode_accelerator_);
   video_decode_accelerator_->Decode(bitstream_buffer);
 }
 
 void GpuVideoDecodeAccelerator::OnAssignPictureBuffers(
     const std::vector<int32_t>& buffer_ids,
-    const std::vector<PictureBuffer::TextureIds>& texture_ids) {
+    const std::vector<PictureBuffer::TextureIds>& texture_ids,
+    uint32_t texture_target,
+    VideoPixelFormat format,
+    const gfx::Size& dimensions) {
   if (buffer_ids.size() != texture_ids.size()) {
     NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT);
     return;
   }
 
   gpu::gles2::GLES2Decoder* command_decoder = stub_->decoder();
   gpu::gles2::TextureManager* texture_manager =
       command_decoder->GetContextGroup()->texture_manager();
 
   std::vector<PictureBuffer> buffers;
@@ skipping 16 matching lines @@
     }
     for (size_t j = 0; j < textures_per_buffer_; j++) {
       gpu::gles2::TextureRef* texture_ref =
           texture_manager->GetTexture(buffer_texture_ids[j]);
       if (!texture_ref) {
         DLOG(ERROR) << "Failed to find texture id " << buffer_texture_ids[j];
         NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT);
         return;
       }
       gpu::gles2::Texture* info = texture_ref->texture();
-      if (info->target() != texture_target_) {
+      if (info->target() != texture_target) {
         DLOG(ERROR) << "Texture target mismatch for texture id "
                     << buffer_texture_ids[j];
         NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT);
         return;
       }
-      if (texture_target_ == GL_TEXTURE_EXTERNAL_OES ||
-          texture_target_ == GL_TEXTURE_RECTANGLE_ARB) {
+      if (texture_target == GL_TEXTURE_EXTERNAL_OES ||
+          texture_target == GL_TEXTURE_RECTANGLE_ARB) {
         // These textures have their dimensions defined by the underlying
         // storage.
-        // Use |texture_dimensions_| for this size.
-        texture_manager->SetLevelInfo(texture_ref, texture_target_, 0, GL_RGBA,
-                                      texture_dimensions_.width(),
-                                      texture_dimensions_.height(), 1, 0,
-                                      GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
+        // Use |dimensions| for this size.
+        texture_manager->SetLevelInfo(
+            texture_ref, texture_target, 0, GL_RGBA, dimensions.width(),
+            dimensions.height(), 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
       } else {
         // For other targets, texture dimensions should already be defined.
         GLsizei width = 0, height = 0;
-        info->GetLevelSize(texture_target_, 0, &width, &height, nullptr);
-        if (width != texture_dimensions_.width() ||
-            height != texture_dimensions_.height()) {
+        info->GetLevelSize(texture_target, 0, &width, &height, nullptr);
+        if (width != dimensions.width() || height != dimensions.height()) {
           DLOG(ERROR) << "Size mismatch for texture id "
                       << buffer_texture_ids[j];
           NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT);
           return;
         }
 
         // TODO(dshwang): after moving to D3D11, remove this. crbug.com/438691
         GLenum format =
             video_decode_accelerator_.get()->GetSurfaceInternalFormat();
         if (format != GL_RGBA) {
           DCHECK(format == GL_BGRA_EXT);
-          texture_manager->SetLevelInfo(texture_ref, texture_target_, 0, format,
+          texture_manager->SetLevelInfo(texture_ref, texture_target, 0, format,
                                         width, height, 1, 0, format,
                                         GL_UNSIGNED_BYTE, gfx::Rect());
         }
       }
       service_ids.push_back(texture_ref->service_id());
       current_textures.push_back(texture_ref);
     }
     textures.push_back(current_textures);
-    buffers.push_back(PictureBuffer(buffer_ids[i], texture_dimensions_,
+    buffers.push_back(PictureBuffer(buffer_ids[i], dimensions,

[liberato (no reviews please), 2017/05/16 17:25:24]

i think that this should pass in |texture_target| and |format|.  i think that
only this call and the associated unit test use that constructor, so it looks
like a small change.

[Chandan, 2017/05/17 12:07:06]

Done.

                                     buffer_texture_ids, service_ids));
   }
   {
     DebugAutoLock auto_lock(debug_uncleared_textures_lock_);
     for (uint32_t i = 0; i < buffer_ids.size(); ++i)
       uncleared_textures_[buffer_ids[i]] = textures[i];
   }
   video_decode_accelerator_->AssignPictureBuffers(buffers);
 }
 
@@ skipping 39 matching lines @@
   for (auto texture_ref : it->second) {
     GLenum target = texture_ref->texture()->target();
     gpu::gles2::TextureManager* texture_manager =
         stub_->decoder()->GetContextGroup()->texture_manager();
     texture_manager->SetLevelCleared(texture_ref.get(), target, 0, true);
   }
   uncleared_textures_.erase(it);
 }
 
 }  // namespace media