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 144 matching lines @@
 };
 
 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),
+      pixel_format_(PIXEL_FORMAT_UNKNOWN),
       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 62 matching lines @@
   }
   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;
+  pixel_format_ = format;
 }
 
 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 217 matching lines @@
           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_,
-                                    buffer_texture_ids, service_ids));
+                                    buffer_texture_ids, service_ids,
+                                    texture_target_, pixel_format_));
   }
   {
     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);
 }
 
 void GpuVideoDecodeAccelerator::OnReusePictureBuffer(
@@ skipping 40 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