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

gpu/ipc/client/gpu_channel_host.cc

 // Copyright (c) 2012 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/common/gpu/client/gpu_channel_host.h"
+#include "gpu/ipc/client/gpu_channel_host.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
-#include "content/common/gpu/client/command_buffer_proxy_impl.h"
+#include "gpu/ipc/client/command_buffer_proxy_impl.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/common/gpu_param_traits_macros.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "url/gurl.h"
 
 using base::AutoLock;
 
-namespace content {
+namespace gpu {
 namespace {
 
 // Global atomic to generate unique transfer buffer IDs.
 base::StaticAtomicSequenceNumber g_next_transfer_buffer_id;
 
 }  // namespace
 
 GpuChannelHost::StreamFlushInfo::StreamFlushInfo()
     : next_stream_flush_id(1),
       flushed_stream_flush_id(0),
@@ skipping 11 matching lines @@
 
 // static
 scoped_refptr<GpuChannelHost> GpuChannelHost::Create(
     GpuChannelHostFactory* factory,
     int channel_id,
     const gpu::GPUInfo& gpu_info,
     const IPC::ChannelHandle& channel_handle,
     base::WaitableEvent* shutdown_event,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
   DCHECK(factory->IsMainThread());
-  scoped_refptr<GpuChannelHost> host =
-      new GpuChannelHost(factory, channel_id, gpu_info,
-                         gpu_memory_buffer_manager);
+  scoped_refptr<GpuChannelHost> host = new GpuChannelHost(
+      factory, channel_id, gpu_info, gpu_memory_buffer_manager);
   host->Connect(channel_handle, shutdown_event);
   return host;
 }
 
 GpuChannelHost::GpuChannelHost(
     GpuChannelHostFactory* factory,
     int channel_id,
     const gpu::GPUInfo& gpu_info,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager)
     : factory_(factory),
@@ skipping 183 matching lines @@
   if (flush_info.flush_pending && flush_info.route_id == route_id)
     flush_info.flush_pending = false;
 }
 
 void GpuChannelHost::DestroyChannel() {
   DCHECK(factory_->IsMainThread());
   AutoLock lock(context_lock_);
   channel_.reset();
 }
 
-void GpuChannelHost::AddRoute(
-    int route_id, base::WeakPtr<IPC::Listener> listener) {
+void GpuChannelHost::AddRoute(int route_id,
+                              base::WeakPtr<IPC::Listener> listener) {
   AddRouteWithTaskRunner(route_id, listener,
                          base::ThreadTaskRunnerHandle::Get());
 }
 
 void GpuChannelHost::AddRouteWithTaskRunner(
     int route_id,
     base::WeakPtr<IPC::Listener> listener,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
       factory_->GetIOThreadTaskRunner();
@@ skipping 128 matching lines @@
 #endif
 }
 
 GpuChannelHost::MessageFilter::ListenerInfo::ListenerInfo() {}
 
 GpuChannelHost::MessageFilter::ListenerInfo::ListenerInfo(
     const ListenerInfo& other) = default;
 
 GpuChannelHost::MessageFilter::ListenerInfo::~ListenerInfo() {}
 
-GpuChannelHost::MessageFilter::MessageFilter()
-    : lost_(false) {
-}
+GpuChannelHost::MessageFilter::MessageFilter() : lost_(false) {}
 
 GpuChannelHost::MessageFilter::~MessageFilter() {}
 
 void GpuChannelHost::MessageFilter::AddRoute(
     int32_t route_id,
     base::WeakPtr<IPC::Listener> listener,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   DCHECK(listeners_.find(route_id) == listeners_.end());
   DCHECK(task_runner);
   ListenerInfo info;
@@ skipping 42 matching lines @@
   }
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
-}  // namespace content
+}  // namespace gpu