gpu_messages.h => gpu/ipc/common

content/common/gpu/gpu_channel.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_GPU_CHANNEL_H_
 #define CONTENT_COMMON_GPU_GPU_CHANNEL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process/process.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "build/build_config.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_memory_manager.h"
-#include "content/common/gpu/gpu_stream_constants.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
+#include "gpu/ipc/common/gpu_stream_constants.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/message_router.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gpu_preference.h"
 
 struct GPUCreateCommandBufferConfig;
 
 namespace base {
@@ skipping 153 matching lines @@
 
   // Some messages such as WaitForGetOffsetInRange and WaitForTokenInRange are
   // processed as soon as possible because the client is blocked until they
   // are completed.
   void HandleOutOfOrderMessage(const IPC::Message& msg);
 
   void HandleMessageHelper(const IPC::Message& msg);
 
   scoped_refptr<GpuChannelMessageQueue> CreateStream(
       int32_t stream_id,
-      GpuStreamPriority stream_priority);
+      gpu::GpuStreamPriority stream_priority);
 
   scoped_refptr<GpuChannelMessageQueue> LookupStream(int32_t stream_id);
 
   void DestroyStreamIfNecessary(
       const scoped_refptr<GpuChannelMessageQueue>& queue);
 
   void AddRouteToStream(int32_t route_id, int32_t stream_id);
   void RemoveRouteFromStream(int32_t route_id);
 
   // Message handlers for control messages.
@@ skipping 141 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GpuChannelMessage);
 };
 
 class GpuChannelMessageQueue
     : public base::RefCountedThreadSafe<GpuChannelMessageQueue> {
  public:
   static scoped_refptr<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);
 
   void Disable();
   void DisableIO();
 
   int32_t stream_id() const { return stream_id_; }
-  GpuStreamPriority stream_priority() const { return stream_priority_; }
+  gpu::GpuStreamPriority stream_priority() const { return stream_priority_; }
 
   bool IsScheduled() const;
   void OnRescheduled(bool scheduled);
 
   bool HasQueuedMessages() const;
 
   base::TimeTicks GetNextMessageTimeTick() const;
 
   scoped_refptr<gpu::SyncPointOrderData> GetSyncPointOrderData();
 
@@ skipping 28 matching lines @@
     // We are currently preempting (i.e. no stub is descheduled).
     PREEMPTING,
     // We would like to preempt, but some stub is descheduled.
     WOULD_PREEMPT_DESCHEDULED,
   };
 
   friend class base::RefCountedThreadSafe<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);
   ~GpuChannelMessageQueue();
 
   void UpdatePreemptionState();
   void UpdatePreemptionStateHelper();
 
   void UpdateStateIdle();
   void UpdateStateWaiting();
   void UpdateStateChecking();
   void UpdateStatePreempting();
   void UpdateStateWouldPreemptDescheduled();
 
   void TransitionToIdle();
   void TransitionToWaiting();
   void TransitionToChecking();
   void TransitionToPreempting();
   void TransitionToWouldPreemptDescheduled();
 
   bool ShouldTransitionToIdle() const;
 
   const int32_t stream_id_;
-  const GpuStreamPriority stream_priority_;
+  const gpu::GpuStreamPriority stream_priority_;
 
   // These can be accessed from both IO and main threads and are protected by
   // |channel_lock_|.
   bool enabled_;
   bool scheduled_;
   GpuChannel* const channel_;
   std::deque<scoped_ptr<GpuChannelMessage>> channel_messages_;
   mutable base::Lock channel_lock_;
 
   // The following are accessed on the IO thread only.
@@ skipping 14 matching lines @@
   scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
   scoped_refptr<gpu::PreemptionFlag> preempted_flag_;
   gpu::SyncPointManager* const sync_point_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannelMessageQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_H_