Clean up SyncCompositorFactory context creation

gpu/command_buffer/service/in_process_command_buffer.h

 // Copyright 2013 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 GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 55 matching lines @@
  public:
   class Service;
   explicit InProcessCommandBuffer(const scoped_refptr<Service>& service);
   virtual ~InProcessCommandBuffer();
 
   static void SetGpuMemoryBufferFactory(GpuMemoryBufferFactory* factory);
 
   // If |surface| is not NULL, use it directly; in this case, the command
   // buffer gpu thread must be the same as the client thread. Otherwise create
   // a new GLSurface.
-  bool Initialize(scoped_refptr<gfx::GLSurface> surface,
+  bool Initialize(gfx::GLSurface* surface,
                   bool is_offscreen,
                   gfx::AcceleratedWidget window,
                   const gfx::Size& size,
                   const std::vector<int32>& attribs,
                   gfx::GpuPreference gpu_preference,
                   const base::Closure& context_lost_callback,
                   InProcessCommandBuffer* share_group);
   void Destroy();
 
   // CommandBuffer implementation:
@@ skipping 49 matching lines @@
         shader_translator_cache() = 0;
   };
 
 #if defined(OS_ANDROID)
   scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
       uint32 stream_id);
 #endif
 
  private:
   struct InitializeOnGpuThreadParams {
+    gfx::GLSurface* surface;
     bool is_offscreen;
     gfx::AcceleratedWidget window;
     const gfx::Size& size;
     const std::vector<int32>& attribs;
     gfx::GpuPreference gpu_preference;
     gpu::Capabilities* capabilities;  // Ouptut.
     InProcessCommandBuffer* context_group;
 
-    InitializeOnGpuThreadParams(bool is_offscreen,
+    InitializeOnGpuThreadParams(gfx::GLSurface* surface,
+                                bool is_offscreen,
                                 gfx::AcceleratedWidget window,
                                 const gfx::Size& size,
                                 const std::vector<int32>& attribs,
                                 gfx::GpuPreference gpu_preference,
                                 gpu::Capabilities* capabilities,
                                 InProcessCommandBuffer* share_group)
-        : is_offscreen(is_offscreen),
+        : surface(surface),
+          is_offscreen(is_offscreen),
           window(window),
           size(size),
           attribs(attribs),
           gpu_preference(gpu_preference),
           capabilities(capabilities),
           context_group(share_group) {}
   };
 
   bool InitializeOnGpuThread(const InitializeOnGpuThreadParams& params);
   bool DestroyOnGpuThread();
   void FlushOnGpuThread(int32 put_offset);
   uint32 CreateStreamTextureOnGpuThread(uint32 client_texture_id);
   bool MakeCurrent();
   base::Closure WrapCallback(const base::Closure& callback);
   State GetStateFast();
   void QueueTask(const base::Closure& task) { service_->ScheduleTask(task); }
-  void CheckSequencedThread();
   void RetireSyncPointOnGpuThread(uint32 sync_point);
   void SignalSyncPointOnGpuThread(uint32 sync_point,
                                   const base::Closure& callback);
   void DestroyTransferBufferOnGputhread(int32 id);
 
   // Callbacks:
   void OnContextLost();
   void OnResizeView(gfx::Size size, float scale_factor);
   bool GetBufferChanged(int32 transfer_buffer_id);
   void PumpCommands();
@@ skipping 25 matching lines @@
   scoped_refptr<Service> service_;
   State state_after_last_flush_;
   base::Lock state_after_last_flush_lock_;
   scoped_ptr<GpuControlService> gpu_control_;
   scoped_refptr<gfx::GLShareGroup> gl_share_group_;
 
 #if defined(OS_ANDROID)
   scoped_ptr<StreamTextureManagerInProcess> stream_texture_manager_;
 #endif
 
-  // Only used with explicit scheduling and the gpu thread is the same as
-  // the client thread.
-  scoped_ptr<base::SequenceChecker> sequence_checker_;
-
   base::WeakPtr<InProcessCommandBuffer> gpu_thread_weak_ptr_;
   base::WeakPtrFactory<InProcessCommandBuffer> gpu_thread_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InProcessCommandBuffer);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_