Implement StreamTexture::BindTexImage.

content/common/gpu/client/gpu_channel_host.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 "content/common/gpu/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 43 matching lines @@
   host->Connect(channel_handle, shutdown_event);
   return host;
 }
 
 GpuChannelHost::GpuChannelHost(
     GpuChannelHostFactory* factory,
     const gpu::GPUInfo& gpu_info,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager)
     : factory_(factory),
       gpu_info_(gpu_info),
-      gpu_memory_buffer_manager_(gpu_memory_buffer_manager) {
+      gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
+      command_buffer_routing_id_(0) {
   next_transfer_buffer_id_.GetNext();
   next_image_id_.GetNext();
   next_route_id_.GetNext();
 }
 
 void GpuChannelHost::Connect(const IPC::ChannelHandle& channel_handle,
                              base::WaitableEvent* shutdown_event) {
   DCHECK(factory_->IsMainThread());
   // Open a channel to the GPU process. We pass NULL as the main listener here
   // since we need to filter everything to route it to the right thread.
@@ skipping 153 matching lines @@
 
   if (!succeeded) {
     LOG(ERROR)
         << "GpuChannelMsg_CreateOffscreenCommandBuffer returned failure.";
     return NULL;
   }
 
   CommandBufferProxyImpl* command_buffer =
       new CommandBufferProxyImpl(this, route_id);
   AddRoute(route_id, command_buffer->AsWeakPtr());
+  command_buffer_routing_id_ = route_id;

[piman, 2015/06/30 23:04:20]

NAK. A channel has multiple command buffers, and they can be created from
multiple threads. This field doesn't make sense and is racy.

You definitely want to go via GpuControl, which is the CommandBufferProxyImpl,
that has the command buffer route id.

[sivag, 2015/07/16 14:24:58]

Done.

 
   AutoLock lock(context_lock_);
   proxies_[route_id] = command_buffer;
   return command_buffer;
 }
 
 scoped_ptr<media::VideoDecodeAccelerator> GpuChannelHost::CreateVideoDecoder(
     int command_buffer_route_id) {
   TRACE_EVENT0("gpu", "GpuChannelHost::CreateVideoDecoder");
   AutoLock lock(context_lock_);
@@ skipping 36 matching lines @@
 void GpuChannelHost::DestroyCommandBuffer(
     CommandBufferProxyImpl* command_buffer) {
   TRACE_EVENT0("gpu", "GpuChannelHost::DestroyCommandBuffer");
 
   int route_id = command_buffer->GetRouteID();
   Send(new GpuChannelMsg_DestroyCommandBuffer(route_id));
   RemoveRoute(route_id);
 
   AutoLock lock(context_lock_);
   proxies_.erase(route_id);
+  command_buffer_routing_id_ = 0;
   if (flush_info_.flush_pending && flush_info_.route_id == route_id)
     flush_info_.flush_pending = false;
 
   delete command_buffer;
 }
 
 void GpuChannelHost::DestroyChannel() {
   DCHECK(factory_->IsMainThread());
   AutoLock lock(context_lock_);
   channel_.reset();
@@ skipping 85 matching lines @@
 }
 
 GpuChannelHost::~GpuChannelHost() {
 #if DCHECK_IS_ON()
   AutoLock lock(context_lock_);
   DCHECK(!channel_)
       << "GpuChannelHost::DestroyChannel must be called before destruction.";
 #endif
 }
 
+unsigned GpuChannelHost::CreateStreamTexture(int32 image_id) {
+  DCHECK(command_buffer_routing_id_);
+  int32 stream_id = GenerateRouteID();
+  bool succeeded = factory_->CreateStreamTexture(
+      image_id, command_buffer_routing_id_, stream_id);
+  if (!succeeded) {
+    DLOG(ERROR) << "GpuCommandBufferMsg_CreateStreamTexture returned failure";
+    return 0;
+  }
+  return stream_id;
+}
+
 GpuChannelHost::MessageFilter::MessageFilter()
     : lost_(false) {
 }
 
 GpuChannelHost::MessageFilter::~MessageFilter() {}
 
 void GpuChannelHost::MessageFilter::AddRoute(
     int route_id,
     base::WeakPtr<IPC::Listener> listener,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
@@ skipping 50 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content