Refactor content/common/gpu into gpu/ipc/service

gpu/ipc/service/gpu_channel.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/gpu_channel.h"
+#include "gpu/ipc/service/gpu_channel.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include <algorithm>
 #include <deque>
 #include <set>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
-#include "content/common/gpu/gpu_channel_manager.h"
-#include "content/common/gpu/gpu_channel_manager_delegate.h"
-#include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "gpu/ipc/common/gpu_messages.h"
+#include "gpu/ipc/service/gpu_channel_manager.h"
+#include "gpu/ipc/service/gpu_channel_manager_delegate.h"
+#include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/message_filter.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_shared_memory.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
-namespace content {
+namespace gpu {
 namespace {
 
 // Number of milliseconds between successive vsync. Many GL commands block
 // on vsync, so thresholds for preemption should be multiples of this.
 const int64_t kVsyncIntervalMs = 17;
 
 // Amount of time that we will wait for an IPC to be processed before
 // preempting. After a preemption, we must wait this long before triggering
 // another preemption.
 const int64_t kPreemptWaitTimeMs = 2 * kVsyncIntervalMs;
 
 // Once we trigger a preemption, the maximum duration that we will wait
 // before clearing the preemption.
 const int64_t kMaxPreemptTimeMs = kVsyncIntervalMs;
 
 // Stop the preemption once the time for the longest pending IPC drops
 // below this threshold.
 const int64_t kStopPreemptThresholdMs = kVsyncIntervalMs;
 
 }  // anonymous namespace
 
 scoped_refptr<GpuChannelMessageQueue> GpuChannelMessageQueue::Create(
     int32_t stream_id,
-    gpu::GpuStreamPriority stream_priority,
+    GpuStreamPriority stream_priority,
     GpuChannel* channel,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    const scoped_refptr<gpu::PreemptionFlag>& preempting_flag,
-    const scoped_refptr<gpu::PreemptionFlag>& preempted_flag,
-    gpu::SyncPointManager* sync_point_manager) {
+    const scoped_refptr<PreemptionFlag>& preempting_flag,
+    const scoped_refptr<PreemptionFlag>& preempted_flag,
+    SyncPointManager* sync_point_manager) {
   return new GpuChannelMessageQueue(stream_id, stream_priority, channel,
                                     io_task_runner, preempting_flag,
                                     preempted_flag, sync_point_manager);
 }
 
-scoped_refptr<gpu::SyncPointOrderData>
+scoped_refptr<SyncPointOrderData>
 GpuChannelMessageQueue::GetSyncPointOrderData() {
   return sync_point_order_data_;
 }
 
 GpuChannelMessageQueue::GpuChannelMessageQueue(
     int32_t stream_id,
-    gpu::GpuStreamPriority stream_priority,
+    GpuStreamPriority stream_priority,
     GpuChannel* channel,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    const scoped_refptr<gpu::PreemptionFlag>& preempting_flag,
-    const scoped_refptr<gpu::PreemptionFlag>& preempted_flag,
-    gpu::SyncPointManager* sync_point_manager)
+    const scoped_refptr<PreemptionFlag>& preempting_flag,
+    const scoped_refptr<PreemptionFlag>& preempted_flag,
+    SyncPointManager* sync_point_manager)
     : stream_id_(stream_id),
       stream_priority_(stream_priority),
       enabled_(true),
       scheduled_(true),
       channel_(channel),
       preemption_state_(IDLE),
       max_preemption_time_(
           base::TimeDelta::FromMilliseconds(kMaxPreemptTimeMs)),
       timer_(new base::OneShotTimer),
-      sync_point_order_data_(gpu::SyncPointOrderData::Create()),
+      sync_point_order_data_(SyncPointOrderData::Create()),
       io_task_runner_(io_task_runner),
       preempting_flag_(preempting_flag),
       preempted_flag_(preempted_flag),
       sync_point_manager_(sync_point_manager) {
   timer_->SetTaskRunner(io_task_runner);
   io_thread_checker_.DetachFromThread();
 }
 
 GpuChannelMessageQueue::~GpuChannelMessageQueue() {
   DCHECK(!enabled_);
@@ skipping 449 matching lines @@
   DLOG(ERROR) << error_msg;
   if (message.is_sync()) {
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
     reply->set_reply_error();
     Send(reply);
   }
   return true;
 }
 
 GpuChannel::GpuChannel(GpuChannelManager* gpu_channel_manager,
-                       gpu::SyncPointManager* sync_point_manager,
+                       SyncPointManager* sync_point_manager,
                        GpuWatchdog* watchdog,
                        gfx::GLShareGroup* share_group,
-                       gpu::gles2::MailboxManager* mailbox,
-                       gpu::PreemptionFlag* preempting_flag,
-                       gpu::PreemptionFlag* preempted_flag,
+                       gles2::MailboxManager* mailbox,
+                       PreemptionFlag* preempting_flag,
+                       PreemptionFlag* preempted_flag,
                        base::SingleThreadTaskRunner* task_runner,
                        base::SingleThreadTaskRunner* io_task_runner,
                        int32_t client_id,
                        uint64_t client_tracing_id,
                        bool allow_view_command_buffers,
                        bool allow_real_time_streams)
     : gpu_channel_manager_(gpu_channel_manager),
       sync_point_manager_(sync_point_manager),
       unhandled_message_listener_(nullptr),
       channel_id_(IPC::Channel::GenerateVerifiedChannelID("gpu")),
       preempting_flag_(preempting_flag),
       preempted_flag_(preempted_flag),
       client_id_(client_id),
       client_tracing_id_(client_tracing_id),
       task_runner_(task_runner),
       io_task_runner_(io_task_runner),
       share_group_(share_group),
       mailbox_manager_(mailbox),
-      subscription_ref_set_(new gpu::gles2::SubscriptionRefSet),
-      pending_valuebuffer_state_(new gpu::ValueStateMap),
+      subscription_ref_set_(new gles2::SubscriptionRefSet),
+      pending_valuebuffer_state_(new ValueStateMap),
       watchdog_(watchdog),
       allow_view_command_buffers_(allow_view_command_buffers),
       allow_real_time_streams_(allow_real_time_streams),
       weak_factory_(this) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   filter_ = new GpuChannelMessageFilter();
 
   scoped_refptr<GpuChannelMessageQueue> control_queue =
-      CreateStream(gpu::GPU_STREAM_DEFAULT, gpu::GpuStreamPriority::HIGH);
-  AddRouteToStream(MSG_ROUTING_CONTROL, gpu::GPU_STREAM_DEFAULT);
+      CreateStream(GPU_STREAM_DEFAULT, GpuStreamPriority::HIGH);
+  AddRouteToStream(MSG_ROUTING_CONTROL, GPU_STREAM_DEFAULT);
 
   subscription_ref_set_->AddObserver(this);
 }
 
 GpuChannel::~GpuChannel() {
   // Clear stubs first because of dependencies.
   stubs_.clear();
 
   for (auto& kv : streams_)
     kv.second->Disable();
@@ skipping 129 matching lines @@
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateCommandBuffer,
                         OnCreateCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyCommandBuffer,
                         OnDestroyCommandBuffer)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-scoped_refptr<gpu::SyncPointOrderData> GpuChannel::GetSyncPointOrderData(
+scoped_refptr<SyncPointOrderData> GpuChannel::GetSyncPointOrderData(
     int32_t stream_id) {
   auto it = streams_.find(stream_id);
   DCHECK(it != streams_.end());
   DCHECK(it->second);
   return it->second->GetSyncPointOrderData();
 }
 
 void GpuChannel::PostHandleMessage(
     const scoped_refptr<GpuChannelMessageQueue>& queue) {
   task_runner_->PostTask(FROM_HERE,
@@ skipping 58 matching lines @@
 void GpuChannel::HandleOutOfOrderMessage(const IPC::Message& msg) {
   HandleMessageHelper(msg);
 }
 
 void GpuChannel::HandleMessageForTesting(const IPC::Message& msg) {
   HandleMessageHelper(msg);
 }
 
 scoped_refptr<GpuChannelMessageQueue> GpuChannel::CreateStream(
     int32_t stream_id,
-    gpu::GpuStreamPriority stream_priority) {
+    GpuStreamPriority stream_priority) {
   DCHECK(streams_.find(stream_id) == streams_.end());
   scoped_refptr<GpuChannelMessageQueue> queue = GpuChannelMessageQueue::Create(
       stream_id, stream_priority, this, io_task_runner_,
-      (stream_id == gpu::GPU_STREAM_DEFAULT) ? preempting_flag_ : nullptr,
+      (stream_id == GPU_STREAM_DEFAULT) ? preempting_flag_ : nullptr,
       preempted_flag_, sync_point_manager_);
   streams_.insert(std::make_pair(stream_id, queue));
   streams_to_num_routes_.insert(std::make_pair(stream_id, 0));
   return queue;
 }
 
 scoped_refptr<GpuChannelMessageQueue> GpuChannel::LookupStream(
     int32_t stream_id) {
   auto stream_it = streams_.find(stream_id);
   if (stream_it != streams_.end())
@@ skipping 34 matching lines @@
   for (const auto& kv : stubs_) {
     const GpuCommandBufferStub* stub = kv.second;
     if (stub->decoder() && !stub->decoder()->WasContextLost())
       return stub;
   }
   return nullptr;
 }
 #endif
 
 void GpuChannel::OnCreateCommandBuffer(
-    gpu::SurfaceHandle surface_handle,
+    SurfaceHandle surface_handle,
     const gfx::Size& size,
     const GPUCreateCommandBufferConfig& init_params,
     int32_t route_id,
     bool* succeeded) {
   TRACE_EVENT2("gpu", "GpuChannel::OnCreateCommandBuffer", "route_id", route_id,
-               "offscreen", (surface_handle == gpu::kNullSurfaceHandle));
+               "offscreen", (surface_handle == kNullSurfaceHandle));
   *succeeded = false;
-  if (surface_handle != gpu::kNullSurfaceHandle &&
+  if (surface_handle != kNullSurfaceHandle &&
       !allow_view_command_buffers_) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): attempt to create a "
                    "view context on a non-priviledged channel";
     return;
   }
 
   int32_t share_group_id = init_params.share_group_id;
   GpuCommandBufferStub* share_group = stubs_.get(share_group_id);
 
   if (!share_group && share_group_id != MSG_ROUTING_NONE) {
     DLOG(ERROR)
         << "GpuChannel::OnCreateCommandBuffer(): invalid share group id";
     return;
   }
 
   int32_t stream_id = init_params.stream_id;
   if (share_group && stream_id != share_group->stream_id()) {
     DLOG(ERROR) << "GpuChannel::OnCreateCommandBuffer(): stream id does not "
                    "match share group stream id";
     return;
   }
 
-  gpu::GpuStreamPriority stream_priority = init_params.stream_priority;
+  GpuStreamPriority stream_priority = init_params.stream_priority;
   if (!allow_real_time_streams_ &&
-      stream_priority == gpu::GpuStreamPriority::REAL_TIME) {
+      stream_priority == GpuStreamPriority::REAL_TIME) {
     DLOG(ERROR) << "GpuChannel::OnCreateCommandBuffer(): real time stream "
                    "priority not allowed";
     return;
   }
 
   scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
       this, sync_point_manager_, task_runner_.get(), share_group,
       surface_handle, mailbox_manager_.get(), preempted_flag_.get(),
       subscription_ref_set_.get(), pending_valuebuffer_state_.get(), size,
       disallowed_features_, init_params.attribs, init_params.gpu_preference,
@@ skipping 40 matching lines @@
 }
 
 void GpuChannel::RemoveFilter(IPC::MessageFilter* filter) {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GpuChannelMessageFilter::RemoveChannelFilter,
                             filter_, make_scoped_refptr(filter)));
 }
 
 uint64_t GpuChannel::GetMemoryUsage() {
   // Collect the unique memory trackers in use by the |stubs_|.
-  std::set<gpu::gles2::MemoryTracker*> unique_memory_trackers;
+  std::set<gles2::MemoryTracker*> unique_memory_trackers;
   for (auto& kv : stubs_)
     unique_memory_trackers.insert(kv.second->GetMemoryTracker());
 
   // Sum the memory usage for all unique memory trackers.
   uint64_t size = 0;
   for (auto* tracker : unique_memory_trackers) {
     size += gpu_channel_manager()->gpu_memory_manager()->GetTrackerMemoryUsage(
         tracker);
   }
 
@@ skipping 28 matching lines @@
           ->CreateImageForGpuMemoryBuffer(handle,
                                           size,
                                           format,
                                           internalformat,
                                           client_id_);
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
-    unsigned int target, const gpu::ValueState& state) {
+    unsigned int target, const ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
-}  // namespace content
+}  // namespace gpu