Make channel preemption not require view contexts for hookup

content/common/gpu/gpu_channel_manager.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_MANAGER_H_
 #define CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
 
 #include <deque>
 #include <string>
 #include <vector>
@@ skipping 15 matching lines @@
 
 namespace base {
 class WaitableEvent;
 }
 
 namespace gfx {
 class GLShareGroup;
 }
 
 namespace gpu {
+class PreemptionFlag;
 class SyncPointManager;
 union ValueState;
 namespace gles2 {
 class FramebufferCompletenessCache;
 class MailboxManager;
 class ProgramCache;
 class ShaderTranslatorCache;
 }
 }
 
 namespace IPC {
 struct ChannelHandle;
 class SyncChannel;
 }
 
 struct GPUCreateCommandBufferConfig;
+struct GpuMsg_EstablishChannel_Params;
 
 namespace content {
 class GpuChannel;
 class GpuMemoryBufferFactory;
 class GpuWatchdog;
 
 // A GpuChannelManager is a thread responsible for issuing rendering commands
 // managing the lifetimes of GPU channels and forwarding IPC requests from the
 // browser process to them based on the corresponding renderer ID.
 class CONTENT_EXPORT GpuChannelManager : public IPC::Listener,
@@ skipping 47 matching lines @@
 
   // Returns the maximum order number for processed IPC messages across all
   // channels.
   uint32_t GetProcessedOrderNum() const;
 
 #if defined(OS_ANDROID)
   void DidAccessGpu();
 #endif
 
  protected:
-  virtual scoped_ptr<GpuChannel> CreateGpuChannel(
-      gfx::GLShareGroup* share_group,
-      gpu::gles2::MailboxManager* mailbox_manager,
-      int client_id,
-      uint64_t client_tracing_id,
-      bool allow_future_sync_points,
-      bool allow_real_time_streams);
+  virtual scoped_ptr<GpuChannel> CreateGpuChannel(int client_id,
+                                                  uint64_t client_tracing_id,
+                                                  bool preempts,
+                                                  bool allow_future_sync_points,
+                                                  bool allow_real_time_streams);
+
+  gfx::GLShareGroup* share_group() const { return share_group_.get(); }
+  gpu::gles2::MailboxManager* mailbox_manager() const {
+    return mailbox_manager_.get();
+  }
+  gpu::PreemptionFlag* preemption_flag() const {
+    return preemption_flag_.get();
+  }
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // These objects manage channels to individual renderer processes there is
   // one channel for each renderer process that has connected to this GPU
   // process.
   base::ScopedPtrHashMap<int32, scoped_ptr<GpuChannel>> gpu_channels_;
 
  private:
   // Message handlers.
   bool OnControlMessageReceived(const IPC::Message& msg);
-  void OnEstablishChannel(int client_id,
-                          uint64_t client_tracing_id,
-                          bool share_context,
-                          bool allow_future_sync_points,
-                          bool allow_real_time_streams);
+  void OnEstablishChannel(const GpuMsg_EstablishChannel_Params& params);
   void OnCloseChannel(const IPC::ChannelHandle& channel_handle);
-  void OnVisibilityChanged(
-      int32 render_view_id, int32 client_id, bool visible);
+  void OnVisibilityChanged(int32 render_view_id, int32 client_id, bool visible);
   void OnCreateViewCommandBuffer(
       const gfx::GLSurfaceHandle& window,
-      int32 render_view_id,
       int32 client_id,
       const GPUCreateCommandBufferConfig& init_params,
       int32 route_id);
   void OnLoadedShader(std::string shader);
   void DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id, int client_id);
   void DestroyGpuMemoryBufferOnIO(gfx::GpuMemoryBufferId id, int client_id);
   void OnDestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
                                 int client_id,
                                 int32 sync_point);
 
@@ skipping 10 matching lines @@
   // Used to send and receive IPC messages from the browser process.
   IPC::SyncChannel* const channel_;
   MessageRouter router_;
 
   GpuWatchdog* watchdog_;
 
   base::WaitableEvent* shutdown_event_;
 
   scoped_refptr<gfx::GLShareGroup> share_group_;
   scoped_refptr<gpu::gles2::MailboxManager> mailbox_manager_;
+  scoped_refptr<gpu::PreemptionFlag> preemption_flag_;
   GpuMemoryManager gpu_memory_manager_;
   // SyncPointManager guaranteed to outlive running MessageLoop.
   gpu::SyncPointManager* sync_point_manager_;
   scoped_ptr<gpu::gles2::ProgramCache> program_cache_;
   scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
   scoped_refptr<gpu::gles2::FramebufferCompletenessCache>
       framebuffer_completeness_cache_;
   scoped_refptr<gfx::GLSurface> default_offscreen_surface_;
   GpuMemoryBufferFactory* const gpu_memory_buffer_factory_;
 #if defined(OS_ANDROID)
   // Last time we know the GPU was powered on. Global for tracking across all
   // transport surfaces.
   base::TimeTicks last_gpu_access_time_;
   base::TimeTicks begin_wake_up_time_;
 #endif
 
   // Member variables should appear before the WeakPtrFactory, to ensure
   // that any WeakPtrs to Controller are invalidated before its members
   // variable's destructors are executed, rendering them invalid.
   base::WeakPtrFactory<GpuChannelManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannelManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_