Enable sync allocation of GpuMemoryBuffers from the browser process.

content/common/gpu/client/gpu_memory_buffer_factory_host.h

 // Copyright 2014 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_MEMORY_BUFFER_FACTORY_HOST_H_
 #define CONTENT_COMMON_GPU_CLIENT_GPU_MEMORY_BUFFER_FACTORY_HOST_H_
 
 #include "base/callback.h"
 #include "content/common/content_export.h"
 
@@ skipping 10 matching lines @@
       CreateGpuMemoryBufferCallback;
 
   static GpuMemoryBufferFactoryHost* GetInstance();
 
   virtual void CreateGpuMemoryBuffer(
       const gfx::GpuMemoryBufferHandle& handle,
       const gfx::Size& size,
       unsigned internalformat,
       unsigned usage,
       const CreateGpuMemoryBufferCallback& callback) = 0;
+  // This function is to be called only for images allocated from the
+  // browser process command buffer. Allocations originating from the renderers
+  // should use the async version of the function.
+  virtual gfx::GpuMemoryBufferHandle CreateGpuMemoryBufferSync(
+      const gfx::GpuMemoryBufferHandle& handle,
+      const gfx::Size& size,
+      unsigned internalformat,
+      unsigned usage) = 0;

[reveman, 2014/09/04 19:43:31]

Not a fan of this alternative function for doing this. Is there a way we can
just block on the browser UI thread and have everything on the IO thread work
exactly the same?

[piman, 2014/09/04 19:59:20]

We should not block the UI thread except when we really need to. In particular,
we don't need to block in response to the renderer's messages, and so we
shouldn't.

[reveman, 2014/09/04 22:37:24]

Agree. I guess my question was, can we make this interface be something that is
used on the IO thread instead?

We'd have the renderer usage be completely asynchronous on the browser side and
all work done on the IO thread. While the browser would use the exact same code
on the IO thread, just block on the reply on the UI thread. I think that would
be much cleaner if possible.

   virtual void DestroyGpuMemoryBuffer(const gfx::GpuMemoryBufferHandle& handle,
                                       int32 sync_point) = 0;
 
  protected:
   GpuMemoryBufferFactoryHost();
   virtual ~GpuMemoryBufferFactoryHost();
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_CLIENT_GPU_MEMORY_BUFFER_FACTORY_HOST_H_