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

gpu/ipc/service/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_
+#ifndef GPU_IPC_SERVICE_GPU_CHANNEL_H_
+#define GPU_IPC_SERVICE_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 "gpu/command_buffer/service/valuebuffer_manager.h"
+#include "gpu/gpu_export.h"
 #include "gpu/ipc/common/gpu_stream_constants.h"
+#include "gpu/ipc/service/gpu_command_buffer_stub.h"
+#include "gpu/ipc/service/gpu_memory_manager.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 {
 class WaitableEvent;
 }
 
-namespace gpu {
-class PreemptionFlag;
-class SyncPointOrderData;
-class SyncPointManager;
-union ValueState;
-class ValueStateMap;
-namespace gles2 {
-class SubscriptionRefSet;
-}
-}
-
 namespace IPC {
 class MessageFilter;
 }
 
-namespace content {
+namespace gpu {
+
+class PreemptionFlag;
+class SyncPointOrderData;
+class SyncPointManager;
+union ValueState;
+class ValueStateMap;
 class GpuChannelManager;
 class GpuChannelMessageFilter;
 class GpuChannelMessageQueue;
 class GpuWatchdog;
 
+namespace gles2 {
+class SubscriptionRefSet;
+}
+
 // Encapsulates an IPC channel between the GPU process and one renderer
 // process. On the renderer side there's a corresponding GpuChannelHost.
-class CONTENT_EXPORT GpuChannel
+class GPU_EXPORT GpuChannel
     : public IPC::Listener,
       public IPC::Sender,
-      public gpu::gles2::SubscriptionRefSet::Observer {
+      public gles2::SubscriptionRefSet::Observer {
  public:
   // Takes ownership of the renderer process handle.
   GpuChannel(GpuChannelManager* gpu_channel_manager,
-             gpu::SyncPointManager* sync_point_manager,
+             SyncPointManager* sync_point_manager,
              GpuWatchdog* watchdog,
              gfx::GLShareGroup* share_group,
-             gpu::gles2::MailboxManager* mailbox_manager,
-             gpu::PreemptionFlag* preempting_flag,
-             gpu::PreemptionFlag* preempted_flag,
+             gles2::MailboxManager* mailbox_manager,
+             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);
   ~GpuChannel() override;
 
   // Initializes the IPC channel. Caller takes ownership of the client FD in
   // the returned handle and is responsible for closing it.
@@ skipping 54 matching lines @@
 
   uint64_t GetMemoryUsage();
 
   scoped_refptr<gl::GLImage> CreateImageForGpuMemoryBuffer(
       const gfx::GpuMemoryBufferHandle& handle,
       const gfx::Size& size,
       gfx::BufferFormat format,
       uint32_t internalformat);
 
   void HandleUpdateValueState(unsigned int target,
-                              const gpu::ValueState& state);
+                              const ValueState& state);
 
   GpuChannelMessageFilter* filter() const { return filter_.get(); }
 
   // Visible for testing.
-  const gpu::ValueStateMap* pending_valuebuffer_state() const {
+  const ValueStateMap* pending_valuebuffer_state() const {
     return pending_valuebuffer_state_.get();
   }
 
   // Returns the global order number for the last processed IPC message.
   uint32_t GetProcessedOrderNum() const;
 
   // Returns the global order number for the last unprocessed IPC message.
   uint32_t GetUnprocessedOrderNum() const;
 
   // Returns the shared sync point global order data for the stream.
-  scoped_refptr<gpu::SyncPointOrderData> GetSyncPointOrderData(
+  scoped_refptr<SyncPointOrderData> GetSyncPointOrderData(
       int32_t stream_id);
 
   void PostHandleOutOfOrderMessage(const IPC::Message& message);
   void PostHandleMessage(const scoped_refptr<GpuChannelMessageQueue>& queue);
 
   // Synchronously handle the message to make testing convenient.
   void HandleMessageForTesting(const IPC::Message& msg);
 
 #if defined(OS_ANDROID)
   const GpuCommandBufferStub* GetOneStub() const;
@@ skipping 13 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,
-      gpu::GpuStreamPriority stream_priority);
+      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.
-  void OnCreateCommandBuffer(gpu::SurfaceHandle surface_handle,
+  void OnCreateCommandBuffer(SurfaceHandle surface_handle,
                              const gfx::Size& size,
                              const GPUCreateCommandBufferConfig& init_params,
                              int32_t route_id,
                              bool* succeeded);
   void OnDestroyCommandBuffer(int32_t route_id);
 
 
   // The lifetime of objects of this class is managed by a GpuChannelManager.
   // The GpuChannelManager destroy all the GpuChannels that they own when they
   // are destroyed. So a raw pointer is safe.
   GpuChannelManager* const gpu_channel_manager_;
 
   // Sync point manager. Outlives the channel and is guaranteed to outlive the
   // message loop.
-  gpu::SyncPointManager* const sync_point_manager_;
+  SyncPointManager* const sync_point_manager_;
 
   scoped_ptr<IPC::SyncChannel> channel_;
 
   IPC::Listener* unhandled_message_listener_;
 
   // Uniquely identifies the channel within this GPU process.
   std::string channel_id_;
 
   // Used to implement message routing functionality to CommandBuffer objects
   IPC::MessageRouter router_;
 
   // Whether the processing of IPCs on this channel is stalled and we should
   // preempt other GpuChannels.
-  scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
+  scoped_refptr<PreemptionFlag> preempting_flag_;
 
   // If non-NULL, all stubs on this channel should stop processing GL
   // commands (via their CommandExecutor) when preempted_flag_->IsSet()
-  scoped_refptr<gpu::PreemptionFlag> preempted_flag_;
+  scoped_refptr<PreemptionFlag> preempted_flag_;
 
   // The id of the client who is on the other side of the channel.
   const int32_t client_id_;
 
   // The tracing ID used for memory allocations associated with this client.
   const uint64_t client_tracing_id_;
 
   // The task runners for the main thread and the io thread.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // The share group that all contexts associated with a particular renderer
   // process use.
   scoped_refptr<gfx::GLShareGroup> share_group_;
 
-  scoped_refptr<gpu::gles2::MailboxManager> mailbox_manager_;
+  scoped_refptr<gles2::MailboxManager> mailbox_manager_;
 
-  scoped_refptr<gpu::gles2::SubscriptionRefSet> subscription_ref_set_;
+  scoped_refptr<gles2::SubscriptionRefSet> subscription_ref_set_;
 
-  scoped_refptr<gpu::ValueStateMap> pending_valuebuffer_state_;
+  scoped_refptr<ValueStateMap> pending_valuebuffer_state_;
 
-  gpu::gles2::DisallowedFeatures disallowed_features_;
+  gles2::DisallowedFeatures disallowed_features_;
   GpuWatchdog* const watchdog_;
 
   // Map of stream id to appropriate message queue.
   base::hash_map<int32_t, scoped_refptr<GpuChannelMessageQueue>> streams_;
 
   // Multimap of stream id to route ids.
   base::hash_map<int32_t, int> streams_to_num_routes_;
 
   // Map of route id to stream id;
   base::hash_map<int32_t, int32_t> routes_to_streams_;
@@ skipping 16 matching lines @@
 // - it counts and timestamps each message forwarded to the channel
 //   so that we can preempt other channels if a message takes too long to
 //   process. To guarantee fairness, we must wait a minimum amount of time
 //   before preempting and we limit the amount of time that we can preempt in
 //   one shot (see constants above).
 // - it handles the GpuCommandBufferMsg_InsertSyncPoint message on the IO
 //   thread, generating the sync point ID and responding immediately, and then
 //   posting a task to insert the GpuCommandBufferMsg_RetireSyncPoint message
 //   into the channel's queue.
 // - it generates mailbox names for clients of the GPU process on the IO thread.
-class GpuChannelMessageFilter : public IPC::MessageFilter {
+class GPU_EXPORT GpuChannelMessageFilter : public IPC::MessageFilter {
  public:
   GpuChannelMessageFilter();
 
   // IPC::MessageFilter implementation.
   void OnFilterAdded(IPC::Sender* sender) override;
   void OnFilterRemoved() override;
   void OnChannelConnected(int32_t peer_pid) override;
   void OnChannelError() override;
   void OnChannelClosing() override;
   bool OnMessageReceived(const IPC::Message& message) override;
@@ skipping 38 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GpuChannelMessage);
 };
 
 class GpuChannelMessageQueue
     : public base::RefCountedThreadSafe<GpuChannelMessageQueue> {
  public:
   static scoped_refptr<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);
 
   void Disable();
   void DisableIO();
 
   int32_t stream_id() const { return stream_id_; }
-  gpu::GpuStreamPriority stream_priority() const { return stream_priority_; }
+  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();
+  scoped_refptr<SyncPointOrderData> GetSyncPointOrderData();
 
   // Returns the global order number for the last unprocessed IPC message.
   uint32_t GetUnprocessedOrderNum() const;
 
   // Returns the global order number for the last unprocessed IPC message.
   uint32_t GetProcessedOrderNum() const;
 
   // Should be called before a message begins to be processed. Returns false if
   // there are no messages to process.
   const GpuChannelMessage* BeginMessageProcessing();
@@ skipping 19 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,
-      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);
   ~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 gpu::GpuStreamPriority stream_priority_;
+  const 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.
   // No lock is necessary for preemption state because it's only accessed on the
   // IO thread.
   PreemptionState preemption_state_;
   // Maximum amount of time that we can spend in PREEMPTING.
   // It is reset when we transition to IDLE.
   base::TimeDelta max_preemption_time_;
   // This timer is used and runs tasks on the IO thread.
   scoped_ptr<base::OneShotTimer> timer_;
   base::ThreadChecker io_thread_checker_;
 
   // Keeps track of sync point related state such as message order numbers.
-  scoped_refptr<gpu::SyncPointOrderData> sync_point_order_data_;
+  scoped_refptr<SyncPointOrderData> sync_point_order_data_;
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
-  scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
-  scoped_refptr<gpu::PreemptionFlag> preempted_flag_;
-  gpu::SyncPointManager* const sync_point_manager_;
+  scoped_refptr<PreemptionFlag> preempting_flag_;
+  scoped_refptr<PreemptionFlag> preempted_flag_;
+  SyncPointManager* const sync_point_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannelMessageQueue);
 };
 
-}  // namespace content
+}  // namespace gpu
 
-#endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_H_
+#endif  // GPU_IPC_SERVICE_GPU_CHANNEL_H_