Implement StreamTexture::BindTexImage.

content/common/gpu/client/gpu_channel_host.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_
 #define CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 72 matching lines @@
   virtual ~GpuChannelHostFactory() {}
 
   virtual bool IsMainThread() = 0;
   virtual scoped_refptr<base::SingleThreadTaskRunner>
   GetIOThreadTaskRunner() = 0;
   virtual scoped_ptr<base::SharedMemory> AllocateSharedMemory(size_t size) = 0;
   virtual CreateCommandBufferResult CreateViewCommandBuffer(
       int32 surface_id,
       const GPUCreateCommandBufferConfig& init_params,
       int32 route_id) = 0;
+  virtual bool CreateStreamTexture(int32 image_id,
+                                   int32 route_id,
+                                   int32 stream_id) = 0;

[reveman, 2015/06/29 16:02:01]

hm, could this be part of the GpuControl interface instead?

We already have CreateImage and adding a CreateStreamTextureImage function seems
reasonable. 

[sivag, 2015/06/30 11:17:17]

As of now we have the CreateStreamTextureImage(int textureid) interface in
gpu_control.h(https://code.google.com/p/chromium/codesearch#chromium/src/gpu/command_buffer/client/gpu_control.h&l=80).
But this interacts with the gpu command buffer directly sends a message to the
gpu to create stream texture(
https://code.google.com/p/chromium/codesearch#chromium/src/content/common/gpu...)

But in this patch  we first send a host message to browser then forward it to
gpu and still we use the renderer context to do this.

What i mean is though we add it in gpu_control.h, there will be no caller as we
call this from renderer client context via browser?

Please advice on how to proceed here?

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

Done.

 };
 
 // Encapsulates an IPC channel between the client and one GPU process.
 // On the GPU process side there's a corresponding GpuChannel.
 // Every method can be called on any thread with a message loop, except for the
 // IO thread.
 class GpuChannelHost : public IPC::Sender,
                        public base::RefCountedThreadSafe<GpuChannelHost> {
  public:
   // Must be called on the main thread (as defined by the factory).
@@ skipping 84 matching lines @@
   gfx::GpuMemoryBufferHandle ShareGpuMemoryBufferToGpuProcess(
       const gfx::GpuMemoryBufferHandle& source_handle,
       bool* requires_sync_point);
 
   // Reserve one unused image ID.
   int32 ReserveImageId();
 
   // Generate a route ID guaranteed to be unique for this channel.
   int32 GenerateRouteID();
 
+  unsigned CreateStreamTexture(int32 image_id);
+
  private:
   friend class base::RefCountedThreadSafe<GpuChannelHost>;
   GpuChannelHost(GpuChannelHostFactory* factory,
                  const gpu::GPUInfo& gpu_info,
                  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager);
   ~GpuChannelHost() override;
   void Connect(const IPC::ChannelHandle& channel_handle,
                base::WaitableEvent* shutdown_event);
   bool InternalSend(IPC::Message* msg);
   void InternalFlush();
@@ skipping 64 matching lines @@
   base::AtomicSequenceNumber next_route_id_;
 
   // Protects channel_ and proxies_.
   mutable base::Lock context_lock_;
   scoped_ptr<IPC::SyncChannel> channel_;
   // Used to look up a proxy from its routing id.
   typedef base::hash_map<int, CommandBufferProxyImpl*> ProxyMap;
   ProxyMap proxies_;
   ProxyFlushInfo flush_info_;
 
+  int command_buffer_routing_id_;
+
   DISALLOW_COPY_AND_ASSIGN(GpuChannelHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_