Enable sync allocation of GpuMemoryBuffers from the browser process.

content/browser/gpu/browser_gpu_channel_host_factory.cc

Index: content/browser/gpu/browser_gpu_channel_host_factory.cc
diff --git a/content/browser/gpu/browser_gpu_channel_host_factory.cc b/content/browser/gpu/browser_gpu_channel_host_factory.cc
index de4e791683b05fcc57f8184051c6a49ccacaee56..8e018a829fe44aa5b10d5579721d67b4ba2197fd 100644
--- a/content/browser/gpu/browser_gpu_channel_host_factory.cc
+++ b/content/browser/gpu/browser_gpu_channel_host_factory.cc
@@ -188,6 +188,77 @@ void BrowserGpuChannelHostFactory::EstablishRequest::Cancel() {
   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);
 }
@@ -412,6 +483,12 @@ void BrowserGpuChannelHostFactory::CreateGpuMemoryBuffer(
     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;
@@ -423,7 +500,36 @@ void BrowserGpuChannelHostFactory::CreateGpuMemoryBuffer(
                  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(
@@ -443,10 +549,16 @@ void BrowserGpuChannelHostFactory::CreateGpuMemoryBufferOnIO(
     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;
   }
 
@@ -457,19 +569,36 @@ void BrowserGpuChannelHostFactory::CreateGpuMemoryBufferOnIO(
       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(