gpu_messages.h => gpu/ipc/common

content/common/gpu/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 <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 15 matching lines @@
 #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 "content/common/gpu/gpu_messages.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 "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
 
@@ skipping 14 matching lines @@
 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,
-    GpuStreamPriority stream_priority,
+    gpu::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) {
   return new GpuChannelMessageQueue(stream_id, stream_priority, channel,
                                     io_task_runner, preempting_flag,
                                     preempted_flag, sync_point_manager);
 }
 
 scoped_refptr<gpu::SyncPointOrderData>
 GpuChannelMessageQueue::GetSyncPointOrderData() {
   return sync_point_order_data_;
 }
 
 GpuChannelMessageQueue::GpuChannelMessageQueue(
     int32_t stream_id,
-    GpuStreamPriority stream_priority,
+    gpu::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)
     : stream_id_(stream_id),
       stream_priority_(stream_priority),
       enabled_(true),
       scheduled_(true),
       channel_(channel),
@@ skipping 500 matching lines @@
       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_STREAM_DEFAULT, GpuStreamPriority::HIGH);
-  AddRouteToStream(MSG_ROUTING_CONTROL, GPU_STREAM_DEFAULT);
+      CreateStream(gpu::GPU_STREAM_DEFAULT, gpu::GpuStreamPriority::HIGH);
+  AddRouteToStream(MSG_ROUTING_CONTROL, gpu::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 208 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,
-    GpuStreamPriority stream_priority) {
+    gpu::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_STREAM_DEFAULT) ? preempting_flag_ : nullptr,
+      (stream_id == gpu::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 65 matching lines @@
     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;
   }
 
-  GpuStreamPriority stream_priority = init_params.stream_priority;
+  gpu::GpuStreamPriority stream_priority = init_params.stream_priority;
   if (!allow_real_time_streams_ &&
-      stream_priority == GpuStreamPriority::REAL_TIME) {
+      stream_priority == gpu::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 94 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content