Move content/common/gpu/client to gpu/ipc/client

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"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/generic_shared_memory_id_generator.h"
-#include "content/common/gpu/client/gpu_memory_buffer_impl.h"
-#include "content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/GLES2/gl2extchromium.h"
+#include "gpu/ipc/client/gpu_memory_buffer_impl.h"
+#include "gpu/ipc/client/gpu_memory_buffer_impl_shared_memory.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gl/gl_switches.h"
 
 namespace content {
 namespace {
 
 void HostCreateGpuMemoryBuffer(
     int surface_id,
     GpuProcessHost* host,
@@ skipping 15 matching lines @@
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int client_id,
     const BrowserGpuMemoryBufferManager::CreateCallback& callback) {
   host->CreateGpuMemoryBufferFromHandle(handle, id, size, format, client_id,
                                         callback);
 }
 
 void GpuMemoryBufferDeleted(
     scoped_refptr<base::SingleThreadTaskRunner> destruction_task_runner,
-    const GpuMemoryBufferImpl::DestructionCallback& destruction_callback,
+    const gpu::GpuMemoryBufferImpl::DestructionCallback& destruction_callback,
     const gpu::SyncToken& sync_token) {
   destruction_task_runner->PostTask(
       FROM_HERE, base::Bind(destruction_callback, sync_token));
 }
 
 bool IsNativeGpuMemoryBufferFactoryConfigurationSupported(
     gfx::BufferFormat format,
     gfx::BufferUsage usage) {
   switch (gpu::GetNativeGpuMemoryBufferType()) {
     case gfx::SHARED_MEMORY_BUFFER:
@@ skipping 219 matching lines @@
 
   // Use service side allocation for native configurations.
   if (IsNativeGpuMemoryBufferConfiguration(format, usage)) {
     CreateGpuMemoryBufferOnIO(base::Bind(&HostCreateGpuMemoryBuffer, 0), id,
                               size, format, usage, child_client_id, false,
                               callback);
     return;
   }
 
   // Early out if we cannot fallback to shared memory buffer.
-  if (!GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage) ||
-      !GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size, format)) {
+  if (!gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage) ||
+      !gpu::GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size,
+                                                                  format)) {
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
   BufferMap& buffers = clients_[child_client_id];
 
   // Allocate shared memory buffer as fallback.
   auto insert_result = buffers.insert(std::make_pair(
       id, BufferInfo(size, gfx::SHARED_MEMORY_BUFFER, format, usage, 0)));
   if (!insert_result.second) {
     DLOG(ERROR) << "Child process attempted to allocate a GpuMemoryBuffer with "
                    "an existing ID.";
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
-  callback.Run(GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
+  callback.Run(gpu::GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
       id, size, format, child_process_handle));
 }
 
 gfx::GpuMemoryBuffer*
 BrowserGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
     ClientBuffer buffer) {
-  return GpuMemoryBufferImpl::FromClientBuffer(buffer);
+  return gpu::GpuMemoryBufferImpl::FromClientBuffer(buffer);
 }
 
 void BrowserGpuMemoryBufferManager::SetDestructionSyncToken(
     gfx::GpuMemoryBuffer* buffer,
     const gpu::SyncToken& sync_token) {
-  static_cast<GpuMemoryBufferImpl*>(buffer)
-      ->set_destruction_sync_token(sync_token);
+  static_cast<gpu::GpuMemoryBufferImpl*>(buffer)->set_destruction_sync_token(
+      sync_token);
 }
 
 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 112 matching lines @@
     CreateGpuMemoryBufferOnIO(
         base::Bind(&HostCreateGpuMemoryBuffer, request->surface_id), new_id,
         request->size, request->format, request->usage, request->client_id,
         false,
         base::Bind(
             &BrowserGpuMemoryBufferManager::HandleGpuMemoryBufferCreatedOnIO,
             base::Unretained(this), base::Unretained(request)));
     return;
   }
 
-  DCHECK(GpuMemoryBufferImplSharedMemory::IsUsageSupported(request->usage))
+  DCHECK(gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(request->usage))
       << static_cast<int>(request->usage);
 
   BufferMap& buffers = clients_[request->client_id];
 
   // Allocate shared memory buffer as fallback.
   auto insert_result = buffers.insert(std::make_pair(
       new_id, BufferInfo(request->size, gfx::SHARED_MEMORY_BUFFER,
                          request->format, request->usage, 0)));
   DCHECK(insert_result.second);
 
   // Note: Unretained is safe as IO thread is stopped before manager is
   // destroyed.
-  request->result = GpuMemoryBufferImplSharedMemory::Create(
+  request->result = gpu::GpuMemoryBufferImplSharedMemory::Create(
       new_id, request->size, request->format,
       base::Bind(
           &GpuMemoryBufferDeleted,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
           base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
                      base::Unretained(this), new_id, request->client_id)));
   request->event.Signal();
 }
 
 void BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferFromHandleOnIO(
@@ skipping 16 matching lines @@
     CreateGpuMemoryBufferOnIO(
         base::Bind(&HostCreateGpuMemoryBufferFromHandle, request->handle),
         new_id, request->size, request->format, request->usage,
         request->client_id, false,
         base::Bind(
             &BrowserGpuMemoryBufferManager::HandleGpuMemoryBufferCreatedOnIO,
             base::Unretained(this), base::Unretained(request)));
     return;
   }
 
-  DCHECK(GpuMemoryBufferImplSharedMemory::IsUsageSupported(request->usage))
+  DCHECK(gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(request->usage))
       << static_cast<int>(request->usage);
 
   BufferMap& buffers = clients_[request->client_id];
 
   // Allocate shared memory buffer.
   auto insert_result = buffers.insert(std::make_pair(
       new_id, BufferInfo(request->size, gfx::SHARED_MEMORY_BUFFER,
                          request->format, request->usage, 0)));
   DCHECK(insert_result.second);
 
   gfx::GpuMemoryBufferHandle handle;
   handle.id = new_id;
   handle.handle = request->handle.handle;
   handle.offset = request->handle.offset;
   handle.stride = request->handle.stride;
 
   // Note: Unretained is safe as IO thread is stopped before manager is
   // destroyed.
-  request->result = GpuMemoryBufferImplSharedMemory::CreateFromHandle(
+  request->result = gpu::GpuMemoryBufferImplSharedMemory::CreateFromHandle(
       handle, request->size, request->format, request->usage,
       base::Bind(
           &GpuMemoryBufferDeleted,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
           base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
                      base::Unretained(this), new_id, request->client_id)));
   request->event.Signal();
 }
 
 void BrowserGpuMemoryBufferManager::HandleGpuMemoryBufferCreatedOnIO(
     CreateGpuMemoryBufferRequest* request,
     const gfx::GpuMemoryBufferHandle& handle) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Early out if factory failed to create the buffer.
   if (handle.is_null()) {
     request->event.Signal();
     return;
   }
 
   // Note: Unretained is safe as IO thread is stopped before manager is
   // destroyed.
-  request->result = GpuMemoryBufferImpl::CreateFromHandle(
+  request->result = gpu::GpuMemoryBufferImpl::CreateFromHandle(
       handle, request->size, request->format, request->usage,
       base::Bind(
           &GpuMemoryBufferDeleted,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
           base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
                      base::Unretained(this), handle.id, request->client_id)));
   request->event.Signal();
 }
 
 void BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferOnIO(
@@ skipping 156 matching lines @@
     return gpu_client_tracing_id_;
   }
 
   // In normal cases, |client_id| is a child process id, so we can perform
   // the standard conversion.
   return ChildProcessHostImpl::ChildProcessUniqueIdToTracingProcessId(
       client_id);
 }
 
 }  // namespace content