Enable sync allocation of GpuMemoryBuffers from the browser process.

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/debug/trace_event.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 170 matching lines @@
     event_.Wait();
   }
   FinishOnMain();
 }
 
 void BrowserGpuChannelHostFactory::EstablishRequest::Cancel() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   finished_ = true;
 }
 
+class BrowserGpuChannelHostFactory::CreateGpuMemoryBufferRequest
+    : public base::RefCountedThreadSafe<CreateGpuMemoryBufferRequest> {
+ public:
+  enum RequestType {
+    SYNC,
+    CALLBACK,
+  };
+  static scoped_refptr<CreateGpuMemoryBufferRequest> CreateSync();
+  static scoped_refptr<CreateGpuMemoryBufferRequest> CreateForCallback(
+      uint32 request_id);
+
+  void Wait();
+  void Signal();
+
+  void set_result(const gfx::GpuMemoryBufferHandle& handle) {
+    handle_ = handle;
+  }
+  gfx::GpuMemoryBufferHandle result() { return handle_; }
+  uint32 request_id() { return request_id_; }
+  RequestType request_type() { return request_type_; }
+
+ private:
+  friend class base::RefCountedThreadSafe<CreateGpuMemoryBufferRequest>;
+  CreateGpuMemoryBufferRequest(scoped_ptr<base::WaitableEvent> event,
+                               uint32 request_id,
+                               RequestType request_type);
+  ~CreateGpuMemoryBufferRequest() {}
+
+  scoped_ptr<base::WaitableEvent> event_;
+  gfx::GpuMemoryBufferHandle handle_;
+  uint32 request_id_;
+  RequestType request_type_;
+};
+
+scoped_refptr<BrowserGpuChannelHostFactory::CreateGpuMemoryBufferRequest>
+BrowserGpuChannelHostFactory::CreateGpuMemoryBufferRequest::CreateSync() {
+  scoped_ptr<base::WaitableEvent> event(new base::WaitableEvent(true, false));
+  scoped_refptr<CreateGpuMemoryBufferRequest> request =
+      new CreateGpuMemoryBufferRequest(event.Pass(), 0, SYNC);
+  return request;
+}
+
+scoped_refptr<BrowserGpuChannelHostFactory::CreateGpuMemoryBufferRequest>
+BrowserGpuChannelHostFactory::CreateGpuMemoryBufferRequest::CreateForCallback(
+    uint32 request_id) {
+  scoped_refptr<CreateGpuMemoryBufferRequest> request =
+      new CreateGpuMemoryBufferRequest(
+          scoped_ptr<base::WaitableEvent>(), request_id, CALLBACK);
+  return request;
+}
+
+BrowserGpuChannelHostFactory::CreateGpuMemoryBufferRequest::
+    CreateGpuMemoryBufferRequest(scoped_ptr<base::WaitableEvent> event,
+                                 uint32 request_id,
+                                 RequestType request_type)
+    : event_(event.Pass()),
+      request_id_(request_id),
+      request_type_(request_type) {
+}
+
+void BrowserGpuChannelHostFactory::CreateGpuMemoryBufferRequest::Wait() {
+  DCHECK(event_.get());
+  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  event_->Wait();
+}
+
+void BrowserGpuChannelHostFactory::CreateGpuMemoryBufferRequest::Signal() {
+  DCHECK(event_.get());
+  event_->Signal();
+}
+
 bool BrowserGpuChannelHostFactory::CanUseForTesting() {
   return GpuDataManager::GetInstance()->GpuAccessAllowed(NULL);
 }
 
 void BrowserGpuChannelHostFactory::Initialize(bool establish_gpu_channel) {
   DCHECK(!instance_);
   instance_ = new BrowserGpuChannelHostFactory();
   if (establish_gpu_channel) {
     instance_->EstablishGpuChannel(CAUSE_FOR_GPU_LAUNCH_BROWSER_STARTUP,
                                    base::Closure());
@@ skipping 204 matching lines @@
                  gpu_host_id_,
                  filter));
 }
 
 void BrowserGpuChannelHostFactory::CreateGpuMemoryBuffer(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     unsigned internalformat,
     unsigned usage,
     const CreateGpuMemoryBufferCallback& callback) {
+  TRACE_EVENT2("gpu",
+               "BrowserGpuChannelHostFactory::CreateGpuMemoryBuffer",
+               "primary_id",
+               handle.global_id.primary_id,
+               "secondary_id",
+               handle.global_id.secondary_id);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   uint32 request_id = next_create_gpu_memory_buffer_request_id_++;
   create_gpu_memory_buffer_requests_[request_id] = callback;
   GetIOLoopProxy()->PostTask(
       FROM_HERE,
       base::Bind(&BrowserGpuChannelHostFactory::CreateGpuMemoryBufferOnIO,
                  base::Unretained(this),
                  handle,
                  size,
                  internalformat,
                  usage,
-                 request_id));
+                 CreateGpuMemoryBufferRequest::CreateForCallback(request_id)));
+}
+
+gfx::GpuMemoryBufferHandle
+BrowserGpuChannelHostFactory::CreateGpuMemoryBufferSync(
+    const gfx::GpuMemoryBufferHandle& handle,
+    const gfx::Size& size,
+    unsigned internalformat,
+    unsigned usage) {
+  TRACE_EVENT2("gpu",
+               "BrowserGpuChannelHostFactory::CreateGpuMemoryBufferSync",
+               "primary_id",
+               handle.global_id.primary_id,
+               "secondary_id",
+               handle.global_id.secondary_id);
+  scoped_refptr<CreateGpuMemoryBufferRequest> request =
+      CreateGpuMemoryBufferRequest::CreateSync();
+  GetIOLoopProxy()->PostTask(
+      FROM_HERE,
+      base::Bind(&BrowserGpuChannelHostFactory::CreateGpuMemoryBufferOnIO,
+                 base::Unretained(this),
+                 handle,
+                 size,
+                 internalformat,
+                 usage,
+                 request));
+
+  request->Wait();
+
+  return request->result();
 }
 
 void BrowserGpuChannelHostFactory::DestroyGpuMemoryBuffer(
     const gfx::GpuMemoryBufferHandle& handle,
     int32 sync_point) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   GetIOLoopProxy()->PostTask(
       FROM_HERE,
       base::Bind(&BrowserGpuChannelHostFactory::DestroyGpuMemoryBufferOnIO,
                  base::Unretained(this),
                  handle,
                  sync_point));
 }
 
 void BrowserGpuChannelHostFactory::CreateGpuMemoryBufferOnIO(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     unsigned internalformat,
     unsigned usage,
-    uint32 request_id) {
+    scoped_refptr<CreateGpuMemoryBufferRequest> request) {
+  TRACE_EVENT2("gpu",
+               "BrowserGpuChannelHostFactory::CreateGpuMemoryBufferOnIO",
+               "primary_id",
+               handle.global_id.primary_id,
+               "secondary_id",
+               handle.global_id.secondary_id);
   GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
   if (!host) {
-    GpuMemoryBufferCreatedOnIO(request_id, gfx::GpuMemoryBufferHandle());
+    GpuMemoryBufferCreatedOnIO(request, gfx::GpuMemoryBufferHandle());
     return;
   }
 
   host->CreateGpuMemoryBuffer(
       handle,
       size,
       internalformat,
       usage,
       base::Bind(&BrowserGpuChannelHostFactory::GpuMemoryBufferCreatedOnIO,
                  base::Unretained(this),
-                 request_id));
+                 request));
 }
 
 void BrowserGpuChannelHostFactory::GpuMemoryBufferCreatedOnIO(
-    uint32 request_id,
+    scoped_refptr<CreateGpuMemoryBufferRequest> request,
     const gfx::GpuMemoryBufferHandle& handle) {
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&BrowserGpuChannelHostFactory::OnGpuMemoryBufferCreated,
-                 base::Unretained(this),
-                 request_id,
-                 handle));
+  TRACE_EVENT2("gpu",
+               "BrowserGpuChannelHostFactory::GpuMemoryBufferCreatedOnIO",
+               "primary_id",
+               handle.global_id.primary_id,
+               "secondary_id",
+               handle.global_id.secondary_id);
+  switch (request->request_type()) {
+    case CreateGpuMemoryBufferRequest::SYNC: {
+      request->set_result(handle);
+      request->Signal();
+      return;
+    }
+    case CreateGpuMemoryBufferRequest::CALLBACK: {
+      BrowserThread::PostTask(
+          BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(&BrowserGpuChannelHostFactory::OnGpuMemoryBufferCreated,
+                     base::Unretained(this),
+                     request->request_id(),
+                     handle));
+      return;
+    }
+  }
+  NOTREACHED();
 }
 
 void BrowserGpuChannelHostFactory::OnGpuMemoryBufferCreated(
     uint32 request_id,
     const gfx::GpuMemoryBufferHandle& handle) {
   CreateGpuMemoryBufferCallbackMap::iterator iter =
       create_gpu_memory_buffer_requests_.find(request_id);
   DCHECK(iter != create_gpu_memory_buffer_requests_.end());
   iter->second.Run(handle);
   create_gpu_memory_buffer_requests_.erase(iter);
 }
 
 void BrowserGpuChannelHostFactory::DestroyGpuMemoryBufferOnIO(
     const gfx::GpuMemoryBufferHandle& handle,
     int32 sync_point) {
   GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
   if (!host)
     return;
 
   host->DestroyGpuMemoryBuffer(handle, sync_point);
 }
 
 }  // namespace content