exp/wip: Use ServerGpuMemoryBufferManager in browser.

content/browser/gpu/browser_gpu_memory_buffer_manager.cc

 // 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.
 
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 23 matching lines @@
 void GpuMemoryBufferDeleted(
     scoped_refptr<base::SingleThreadTaskRunner> destruction_task_runner,
     const gpu::GpuMemoryBufferImpl::DestructionCallback& destruction_callback,
     const gpu::SyncToken& sync_token) {
   destruction_task_runner->PostTask(
       FROM_HERE, base::Bind(destruction_callback, sync_token));
 }
 
 BrowserGpuMemoryBufferManager* g_gpu_memory_buffer_manager = nullptr;
 
+void X(scoped_refptr<viz::ServerGpuMemoryBufferManager> manager,
+       std::unique_ptr<gfx::GpuMemoryBuffer>* memory,
+       base::WaitableEvent* wait_event,
+       const gfx::Size& size,
+       gfx::BufferFormat format,
+       gfx::BufferUsage usage,
+       gpu::SurfaceHandle surface_handle,
+       GpuProcessHost* host) {
+  if (!host || !host->gpu_service()) {
+    wait_event->Signal();
+    return;
+  }
+  manager->set_gpu_service(host->gpu_service());
+  *memory = manager->CreateGpuMemoryBuffer(size, format, usage, surface_handle);
+  wait_event->Signal();
+}
+
+void RunCallback(
+    const base::Callback<void(const gfx::GpuMemoryBufferHandle&)>& callback,
+    const gfx::GpuMemoryBufferHandle& handle) {
+  callback.Run(handle);
+}
+
 }  // namespace
 
 struct BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferRequest {
   CreateGpuMemoryBufferRequest(const gfx::Size& size,
                                gfx::BufferFormat format,
                                gfx::BufferUsage usage,
                                int client_id,
                                gpu::SurfaceHandle surface_handle)
       : event(base::WaitableEvent::ResetPolicy::MANUAL,
               base::WaitableEvent::InitialState::NOT_SIGNALED),
@@ skipping 10 matching lines @@
   int client_id;
   gpu::SurfaceHandle surface_handle;
   std::unique_ptr<gfx::GpuMemoryBuffer> result;
 };
 
 BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager(
     int gpu_client_id,
     uint64_t gpu_client_tracing_id)
     : native_configurations_(gpu::GetNativeGpuMemoryBufferConfigurations()),
       gpu_client_id_(gpu_client_id),
-      gpu_client_tracing_id_(gpu_client_tracing_id) {
+      gpu_client_tracing_id_(gpu_client_tracing_id),
+      gmb_manager_(base::MakeRefCounted<viz::ServerGpuMemoryBufferManager>(
+          nullptr,
+          gpu_client_id_,
+          BrowserThread::GetTaskRunnerForThread(BrowserThread::IO))) {
   DCHECK(!g_gpu_memory_buffer_manager);
   g_gpu_memory_buffer_manager = this;
 }
 
 BrowserGpuMemoryBufferManager::~BrowserGpuMemoryBufferManager() {
   g_gpu_memory_buffer_manager = nullptr;
 }
 
 // static
 BrowserGpuMemoryBufferManager* BrowserGpuMemoryBufferManager::current() {
@@ skipping 11 matching lines @@
 
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int child_client_id,
     const AllocationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+#if 0
   // Use service side allocation for native configurations.
   if (IsNativeGpuMemoryBufferConfiguration(format, usage)) {
     CreateGpuMemoryBufferOnIO(id, size, format, usage, gpu::kNullSurfaceHandle,
                               child_client_id, callback);
     return;
   }
 
   // Early out if we cannot fallback to shared memory buffer.
   if (!gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage) ||
       !gpu::GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size,
@@ skipping 11 matching lines @@
     DLOG(ERROR) << "Child process attempted to allocate a GpuMemoryBuffer with "
                    "an existing ID.";
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
   auto handle = gpu::GpuMemoryBufferImplSharedMemory::CreateGpuMemoryBuffer(
       id, size, format);
   buffers.find(id)->second.shared_memory_guid = handle.handle.GetGUID();
   callback.Run(handle);
+#else
+  GpuProcessHost* host = GpuProcessHost::Get();
+  gmb_manager_->set_gpu_service(host->gpu_service());
+  gmb_manager_->AllocateGpuMemoryBufferHandle(
+      id, child_client_id, size, format, usage, gpu::kNullSurfaceHandle,
+      base::BindOnce(&RunCallback, callback));
+#endif
 }
 
 void BrowserGpuMemoryBufferManager::SetDestructionSyncToken(
     gfx::GpuMemoryBuffer* buffer,
     const gpu::SyncToken& sync_token) {
+  gmb_manager_->SetDestructionSyncToken(buffer, sync_token);
+#if 0
   static_cast<gpu::GpuMemoryBufferImpl*>(buffer)->set_destruction_sync_token(
       sync_token);
+#endif
 }
 
 bool BrowserGpuMemoryBufferManager::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (const auto& client : clients_) {
     int client_id = client.first;
 
@@ skipping 37 matching lines @@
   }
 
   return true;
 }
 
 void BrowserGpuMemoryBufferManager::ChildProcessDeletedGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     int child_client_id,
     const gpu::SyncToken& sync_token) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
+#if 0
   DestroyGpuMemoryBufferOnIO(id, child_client_id, sync_token);
+#else
+  gmb_manager_->DestroyGpuMemoryBuffer(id, child_client_id, sync_token);
+#endif
 }
 
 void BrowserGpuMemoryBufferManager::ProcessRemoved(
     int client_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+#if 0
   ClientMap::iterator client_it = clients_.find(client_id);
   if (client_it == clients_.end())
     return;
 
   for (const auto& buffer : client_it->second) {
     // This might happen if buffer is currenlty in the process of being
     // allocated. The buffer will in that case be cleaned up when allocation
     // completes.
     if (buffer.second.type == gfx::EMPTY_BUFFER)
       continue;
 
     GpuProcessHost* host = GpuProcessHost::FromID(buffer.second.gpu_host_id);
     if (host)
       host->DestroyGpuMemoryBuffer(buffer.first, client_id, gpu::SyncToken());
   }
 
   clients_.erase(client_it);
+#else
+  gmb_manager_->DestroyAllGpuMemoryBufferForClient(client_id);
+#endif
 }
 
 bool BrowserGpuMemoryBufferManager::IsNativeGpuMemoryBufferConfiguration(
     gfx::BufferFormat format,
     gfx::BufferUsage usage) const {
   return native_configurations_.find(std::make_pair(format, usage)) !=
          native_configurations_.end();
 }
 
 std::unique_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface(
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gpu::SurfaceHandle surface_handle) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+#if 0
   CreateGpuMemoryBufferRequest request(size, format, usage, gpu_client_id_,
                                        surface_handle);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferOnIO,
           base::Unretained(this),  // Safe as we wait for result below.
           base::Unretained(&request)));
 
   // We're blocking the UI thread, which is generally undesirable.
   TRACE_EVENT0(
       "browser",
       "BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface");
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   request.event.Wait();
   return std::move(request.result);
+#else
+  std::unique_ptr<gfx::GpuMemoryBuffer> memory;
+  base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
+                            base::WaitableEvent::InitialState::NOT_SIGNALED);
+  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  GpuProcessHost::CallOnIO(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED, true,
+                           base::Bind(&X, gmb_manager_, &memory, &event, size,
+                                      format, usage, surface_handle));
+  event.Wait();
+  return memory;
+#endif
 }
 
 void BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferOnIO(
     CreateGpuMemoryBufferRequest* request) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   gfx::GpuMemoryBufferId new_id = content::GetNextGenericSharedMemoryId();
 
   // Use service side allocation for native configurations.
   if (IsNativeGpuMemoryBufferConfiguration(request->format, request->usage)) {
@@ skipping 208 matching lines @@
       format(format),
       usage(usage),
       gpu_host_id(gpu_host_id) {}
 
 BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo(const BufferInfo& other) =
     default;
 
 BrowserGpuMemoryBufferManager::BufferInfo::~BufferInfo() {}
 
 }  // namespace content