gpu: Refactor memory buffer handling code out of content.

gpu/ipc/client/gpu_host_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 GPU_IPC_CLIENT_GPU_HOST_MEMORY_BUFFER_MANAGER_H_
+#define GPU_IPC_CLIENT_GPU_HOST_MEMORY_BUFFER_MANAGER_H_
+
+#include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
+#include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
+#include "gpu/gpu_export.h"
+
+namespace gpu {
+
+class GPU_EXPORT GpuHostMemoryBufferManager : public GpuMemoryBufferManager {
+ public:
+  using AllocationCallback =
+      base::Callback<void(const gfx::GpuMemoryBufferHandle& handle)>;
+
+  GpuHostMemoryBufferManager();
+  ~GpuHostMemoryBufferManager() override;
+
+  void AllocateGpuMemoryBufferForClient(gfx::GpuMemoryBufferId id,
+                                        const gfx::Size& size,
+                                        gfx::BufferFormat format,
+                                        gfx::BufferUsage usage,
+                                        int child_client_id,
+                                        const AllocationCallback& callback);
+
+  void SetIO(scoped_refptr<base::SingleThreadTaskRunner> r) {
+    io_task_runner_ = std::move(r);
+  }
+
+  // GpuMemoryBufferManager:
+  std::unique_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBuffer(
+      const gfx::Size& size,
+      gfx::BufferFormat format,
+      gfx::BufferUsage usage,
+      SurfaceHandle surface_handle) override;
+  std::unique_ptr<gfx::GpuMemoryBuffer> CreateGpuMemoryBufferFromHandle(
+      const gfx::GpuMemoryBufferHandle& handle,
+      const gfx::Size& size,
+      gfx::BufferFormat format) override;
+  gfx::GpuMemoryBuffer* GpuMemoryBufferFromClientBuffer(
+      ClientBuffer buffer) override;
+  void SetDestructionSyncToken(gfx::GpuMemoryBuffer* buffer,
+                               const SyncToken& sync_token) override;
+
+ private:
+  struct BufferInfo {
+    BufferInfo();
+    BufferInfo(const gfx::Size& size,
+               gfx::GpuMemoryBufferType type,
+               gfx::BufferFormat format,
+               gfx::BufferUsage usage,
+               int gpu_host_id);
+    BufferInfo(const BufferInfo& other);
+    ~BufferInfo();
+
+    gfx::Size size;
+    gfx::GpuMemoryBufferType type = gfx::EMPTY_BUFFER;
+    gfx::BufferFormat format = gfx::BufferFormat::RGBA_8888;
+    gfx::BufferUsage usage = gfx::BufferUsage::GPU_READ;
+    int gpu_host_id = 0;
+  };
+  struct CreateGpuMemoryBufferRequest;
+  struct CreateGpuMemoryBufferFromHandleRequest;
+
+  void HandleCreateGpuMemoryBufferOnIO(CreateGpuMemoryBufferRequest* request);
+  void HandleCreateGpuMemoryBufferFromHandleOnIO(
+      CreateGpuMemoryBufferFromHandleRequest* request);
+
+  void DestroyGpuMemoryBufferOnIO(gfx::GpuMemoryBufferId id,
+                                  int client_id,
+                                  const gpu::SyncToken& sync_token);
+
+
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;  // XXX
+  const int gpu_client_id_;                                     // XXX
+
+  // Stores info about buffers for all clients. This should only be accessed
+  // on the IO thread.
+  using BufferMap = base::hash_map<gfx::GpuMemoryBufferId, BufferInfo>;
+  using ClientMap = base::hash_map<int, BufferMap>;
+  ClientMap clients_;
+
+  DISALLOW_COPY_AND_ASSIGN(GpuHostMemoryBufferManager);
+};
+
+}  // namespace gpu
+
+#endif  // GPU_IPC_CLIENT_GPU_HOST_MEMORY_BUFFER_MANAGER_H_