Implement StreamTexture::BindTexImage.

content/browser/gpu/browser_gpu_channel_host_factory.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/browser/gpu/browser_gpu_channel_host_factory.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 24 matching lines @@
         gpu_host_id(0),
         route_id(route_id),
         result(CREATE_COMMAND_BUFFER_FAILED) {}
   ~CreateRequest() {}
   base::WaitableEvent event;
   int gpu_host_id;
   int32 route_id;
   CreateCommandBufferResult result;
 };
 
+struct BrowserGpuChannelHostFactory::CreateStreamTextureRequest {
+  CreateStreamTextureRequest(int32 image_id, int32 stream_id, int32 route_id)
+      : event(true, false),
+        image_id(image_id),
+        stream_id(stream_id),
+        route_id(route_id) {}
+  ~CreateStreamTextureRequest() {}
+  base::WaitableEvent event;
+  int32 image_id;
+  int32 stream_id;
+  int32 route_id;
+  bool result;
+};
+
 class BrowserGpuChannelHostFactory::EstablishRequest
     : public base::RefCountedThreadSafe<EstablishRequest> {
  public:
   static scoped_refptr<EstablishRequest> Create(CauseForGpuLaunch cause,
                                                 int gpu_client_id,
                                                 int gpu_host_id);
   void Wait();
   void Cancel();
 
   int gpu_host_id() { return gpu_host_id_; }
@@ skipping 222 matching lines @@
   host->CreateViewCommandBuffer(
       surface,
       surface_id,
       gpu_client_id_,
       init_params,
       request->route_id,
       base::Bind(&BrowserGpuChannelHostFactory::CommandBufferCreatedOnIO,
                  request));
 }
 
+void BrowserGpuChannelHostFactory::CreateStreamTextureOnIO(
+    CreateStreamTextureRequest* request) {
+  GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
+  if (!host) {
+    request->event.Signal();
+    return;
+  }
+  host->CreateStreamTexture(
+      request->image_id, gpu_client_id_, request->route_id, request->stream_id,
+      base::Bind(&BrowserGpuChannelHostFactory::StreamTextureCreatedOnIO,
+                 request));
+}
+
 IPC::AttachmentBroker* BrowserGpuChannelHostFactory::GetAttachmentBroker() {
   return content::ChildProcessHost::GetAttachmentBroker();
 }
 
 // static
 void BrowserGpuChannelHostFactory::CommandBufferCreatedOnIO(
     CreateRequest* request, CreateCommandBufferResult result) {
   request->result = result;
   request->event.Signal();
 }
 
+// static
+void BrowserGpuChannelHostFactory::StreamTextureCreatedOnIO(
+    CreateStreamTextureRequest* request,
+    bool result) {
+  request->result = result;
+  request->event.Signal();
+}
+
 CreateCommandBufferResult BrowserGpuChannelHostFactory::CreateViewCommandBuffer(
       int32 surface_id,
       const GPUCreateCommandBufferConfig& init_params,
       int32 route_id) {
   CreateRequest request(route_id);
   GetIOThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&BrowserGpuChannelHostFactory::CreateViewCommandBufferOnIO,
                  base::Unretained(this), &request, surface_id, init_params));
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/125248 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "125248 BrowserGpuChannelHostFactory::CreateViewCommandBuffer"));
 
   // We're blocking the UI thread, which is generally undesirable.
   // In this case we need to wait for this before we can show any UI /anyway/,
   // so it won't cause additional jank.
   // TODO(piman): Make this asynchronous (http://crbug.com/125248).
   TRACE_EVENT0("browser",
                "BrowserGpuChannelHostFactory::CreateViewCommandBuffer");
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   request.event.Wait();
   return request.result;
 }
 
+bool BrowserGpuChannelHostFactory::CreateStreamTexture(int32 image_id,
+                                                       int32 route_id,
+                                                       int32 stream_id) {
+  CreateStreamTextureRequest request(image_id, stream_id, route_id);
+
+  GetIOThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&BrowserGpuChannelHostFactory::CreateStreamTextureOnIO,
+                 base::Unretained(this), &request));
+  TRACE_EVENT0("browser",
+               "BrowserGpuChannelHostFactory::CreateStreamTextureOnIO");
+
+  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  request.event.Wait();
+  return request.result;
+}
+
 // Blocking the UI thread to open a GPU channel is not supported on Android.
 // (Opening the initial channel to a child process involves handling a reply
 // task on the UI thread first, so we cannot block here.)
 #if !defined(OS_ANDROID)
 GpuChannelHost* BrowserGpuChannelHostFactory::EstablishGpuChannelSync(
     CauseForGpuLaunch cause_for_gpu_launch) {
   EstablishGpuChannel(cause_for_gpu_launch, base::Closure());
 
   if (pending_request_.get())
     pending_request_->Wait();
@@ skipping 69 matching lines @@
     int host_id,
     scoped_refptr<IPC::MessageFilter> filter) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   GpuProcessHost* host = GpuProcessHost::FromID(host_id);
   if (host)
     host->AddFilter(filter.get());
 }
 
 }  // namespace content