viz: Convert a sync api in ServerGpuMemoryBufferManager into async.

components/viz/common/server_gpu_memory_buffer_manager.h

 // Copyright 2016 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 COMPONENTS_VIZ_COMMON_SERVER_GPU_MEMORY_BUFFER_MANAGER_H_
 #define COMPONENTS_VIZ_COMMON_SERVER_GPU_MEMORY_BUFFER_MANAGER_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "base/threading/thread_checker.h"
+#include "base/single_thread_task_runner.h"

[danakj, 2017/06/15 23:02:42]

sequenced (and forward declare?)

+#include "base/synchronization/waitable_event.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "gpu/ipc/host/gpu_memory_buffer_support.h"
 
 namespace ui {
 namespace mojom {
 class GpuService;
 }
 }
 
 namespace viz {
 
 // This GpuMemoryBufferManager implementation is for [de]allocating gpu memory
 // from the gpu process over the mojom.GpuService api.
-class ServerGpuMemoryBufferManager : public gpu::GpuMemoryBufferManager,
-                                     public base::ThreadChecker {
+class ServerGpuMemoryBufferManager : public gpu::GpuMemoryBufferManager {
  public:
   ServerGpuMemoryBufferManager(ui::mojom::GpuService* gpu_service,
                                int client_id);
   ~ServerGpuMemoryBufferManager() override;
 
   void DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
                               int client_id,
                               const gpu::SyncToken& sync_token);
 
   void DestroyAllGpuMemoryBufferForClient(int client_id);
 
-  gfx::GpuMemoryBufferHandle CreateGpuMemoryBufferHandle(
+  void AllocateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,
       int client_id,
       const gfx::Size& size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
-      gpu::SurfaceHandle surface_handle);
+      gpu::SurfaceHandle surface_handle,
+      base::OnceCallback<void(const gfx::GpuMemoryBufferHandle&)> callback);
 
   // Overridden from gpu::GpuMemoryBufferManager:
   std::unique_ptr<gfx::GpuMemoryBuffer> CreateGpuMemoryBuffer(

[danakj, 2017/06/15 23:02:42]

Please document threading restrictions clearly here for this method. Also
perhaps for all other methods in the class comment? Also how about adding
OnFooThread suffixes to every method that isn't the interface? OnOriginThread
for the thread this is created on?

Alternatively.. we could push this impl out to a member nested class which calls
back to this outer class...? would that make the threading model clear also?

[sadrul, 2017/06/16 12:52:19]

I can comment on the interface [1] that this can be called from any thread.
Other than that, the rest of the functions in this class are expected to be
called on the same thread (see DCHECK()s).

[1]
https://cs.chromium.org/chromium/src/gpu/command_buffer/client/gpu_memory_buf...

[danakj, 2017/06/20 16:27:26]

That'd be good, and a top level class comment explaining what you just said here
also.

[sadrul, 2017/06/20 18:21:02]

Done.

       const gfx::Size& size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
       gpu::SurfaceHandle surface_handle) override;
   void SetDestructionSyncToken(gfx::GpuMemoryBuffer* buffer,
                                const gpu::SyncToken& sync_token) override;
 
  private:
+  void OnGpuMemoryBufferAllocated(
+      int client_id,
+      base::OnceCallback<void(const gfx::GpuMemoryBufferHandle&)> callback,
+      const gfx::GpuMemoryBufferHandle& handle);
+  void SignalGpuMemoryBufferAllocated(
+      gfx::GpuMemoryBufferHandle* handle,
+      base::WaitableEvent* wait_event,
+      const gfx::GpuMemoryBufferHandle& allocated_buffer_handle);
+
   ui::mojom::GpuService* gpu_service_;
   const int client_id_;
   int next_gpu_memory_id_ = 1;
 
   using NativeBuffers =
       std::unordered_set<gfx::GpuMemoryBufferId,
                          BASE_HASH_NAMESPACE::hash<gfx::GpuMemoryBufferId>>;
   std::unordered_map<int, NativeBuffers> native_buffers_;
+  std::unordered_set<int> pending_buffers_;
 
   const gpu::GpuMemoryBufferConfigurationSet native_configurations_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
   base::WeakPtrFactory<ServerGpuMemoryBufferManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServerGpuMemoryBufferManager);
 };
 
 }  // namespace viz
 
 #endif  // COMPONENTS_VIZ_COMMON_SERVER_GPU_MEMORY_BUFFER_MANAGER_H_