Clean up SyncCompositorFactory context creation

gpu/command_buffer/service/in_process_command_buffer.cc

 // 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.
 
 #include "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
@@ skipping 206 matching lines @@
   }
 }
 
 InProcessCommandBuffer::~InProcessCommandBuffer() {
   Destroy();
   base::AutoLock lock(default_thread_clients_lock_.Get());
   default_thread_clients_.Get().erase(this);
 }
 
 void InProcessCommandBuffer::OnResizeView(gfx::Size size, float scale_factor) {
-  CheckSequencedThread();
   DCHECK(!surface_->IsOffscreen());
   surface_->Resize(size);
 }
 
 bool InProcessCommandBuffer::MakeCurrent() {
-  CheckSequencedThread();
   command_buffer_lock_.AssertAcquired();
 
   if (!context_lost_ && decoder_->MakeCurrent())
     return true;
   DLOG(ERROR) << "Context lost because MakeCurrent failed.";
   command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
   command_buffer_->SetParseError(gpu::error::kLostContext);
   return false;
 }
 
 void InProcessCommandBuffer::PumpCommands() {
-  CheckSequencedThread();
   command_buffer_lock_.AssertAcquired();
 
   if (!MakeCurrent())
     return;
 
   gpu_scheduler_->PutChanged();
 }
 
 bool InProcessCommandBuffer::GetBufferChanged(int32 transfer_buffer_id) {
-  CheckSequencedThread();
   command_buffer_lock_.AssertAcquired();
   command_buffer_->SetGetBuffer(transfer_buffer_id);
   return true;
 }
 
 bool InProcessCommandBuffer::Initialize(
-    scoped_refptr<gfx::GLSurface> surface,
+    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) {
   DCHECK(!share_group || service_ == share_group->service_);
   context_lost_callback_ = WrapCallback(context_lost_callback);
 
-  if (surface) {
-    // GPU thread must be the same as client thread due to GLSurface not being
-    // thread safe.
-    sequence_checker_.reset(new base::SequenceChecker);
-    surface_ = surface;
-  }
-
   gpu::Capabilities capabilities;
-  InitializeOnGpuThreadParams params(is_offscreen,
+  InitializeOnGpuThreadParams params(surface,
+                                     is_offscreen,
                                      window,
                                      size,
                                      attribs,
                                      gpu_preference,
                                      &capabilities,
                                      share_group);
 
   base::Callback<bool(void)> init_task =
       base::Bind(&InProcessCommandBuffer::InitializeOnGpuThread,
                  base::Unretained(this),
                  params);
 
   base::WaitableEvent completion(true, false);
   bool result = false;
   QueueTask(
       base::Bind(&RunTaskWithResult<bool>, init_task, &result, &completion));
   completion.Wait();
 
   if (result) {
     capabilities_ = capabilities;
     capabilities_.map_image =
         capabilities_.map_image && g_gpu_memory_buffer_factory;
   }
   return result;
 }
 
 bool InProcessCommandBuffer::InitializeOnGpuThread(
     const InitializeOnGpuThreadParams& params) {
-  CheckSequencedThread();
   gpu_thread_weak_ptr_ = gpu_thread_weak_ptr_factory_.GetWeakPtr();
 
   DCHECK(params.size.width() >= 0 && params.size.height() >= 0);
 
+  surface_ = params.surface;
+
   TransferBufferManager* manager = new TransferBufferManager();
   transfer_buffer_manager_.reset(manager);
   manager->Initialize();
 
   scoped_ptr<CommandBufferService> command_buffer(
       new CommandBufferService(transfer_buffer_manager_.get()));
   command_buffer->SetPutOffsetChangeCallback(base::Bind(
       &InProcessCommandBuffer::PumpCommands, gpu_thread_weak_ptr_));
   command_buffer->SetParseErrorCallback(base::Bind(
       &InProcessCommandBuffer::OnContextLost, gpu_thread_weak_ptr_));
@@ skipping 97 matching lines @@
   if (!params.is_offscreen) {
     decoder_->SetResizeCallback(base::Bind(
         &InProcessCommandBuffer::OnResizeView, gpu_thread_weak_ptr_));
   }
   decoder_->SetWaitSyncPointCallback(base::Bind(&WaitSyncPoint));
 
   return true;
 }
 
 void InProcessCommandBuffer::Destroy() {
-  CheckSequencedThread();
-
   base::WaitableEvent completion(true, false);
   bool result = false;
   base::Callback<bool(void)> destroy_task = base::Bind(
       &InProcessCommandBuffer::DestroyOnGpuThread, base::Unretained(this));
   QueueTask(
       base::Bind(&RunTaskWithResult<bool>, destroy_task, &result, &completion));
   completion.Wait();
 }
 
 bool InProcessCommandBuffer::DestroyOnGpuThread() {
-  CheckSequencedThread();
   gpu_thread_weak_ptr_factory_.InvalidateWeakPtrs();
   command_buffer_.reset();
   // Clean up GL resources if possible.
   bool have_context = context_ && context_->MakeCurrent(surface_);
   if (decoder_) {
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
   context_ = NULL;
   surface_ = NULL;
   gl_share_group_ = NULL;
 #if defined(OS_ANDROID)
   stream_texture_manager_.reset();
 #endif
 
   return true;
 }
 
-void InProcessCommandBuffer::CheckSequencedThread() {
-  DCHECK(!sequence_checker_ ||
-         sequence_checker_->CalledOnValidSequencedThread());
-}
-
 void InProcessCommandBuffer::OnContextLost() {
-  CheckSequencedThread();
   if (!context_lost_callback_.is_null()) {
     context_lost_callback_.Run();
     context_lost_callback_.Reset();
   }
 
   context_lost_ = true;
 }
 
 CommandBuffer::State InProcessCommandBuffer::GetStateFast() {
-  CheckSequencedThread();
   base::AutoLock lock(state_after_last_flush_lock_);
   if (state_after_last_flush_.generation - last_state_.generation < 0x80000000U)
     last_state_ = state_after_last_flush_;
   return last_state_;
 }
 
 CommandBuffer::State InProcessCommandBuffer::GetLastState() {
-  CheckSequencedThread();
   return last_state_;
 }
 
 int32 InProcessCommandBuffer::GetLastToken() {
-  CheckSequencedThread();
   GetStateFast();
   return last_state_.token;
 }
 
 void InProcessCommandBuffer::FlushOnGpuThread(int32 put_offset) {
-  CheckSequencedThread();
   ScopedEvent handle_flush(&flush_event_);
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->Flush(put_offset);
   {
     // Update state before signaling the flush event.
     base::AutoLock lock(state_after_last_flush_lock_);
     state_after_last_flush_ = command_buffer_->GetLastState();
   }
   DCHECK((!error::IsError(state_after_last_flush_.error) && !context_lost_) ||
          (error::IsError(state_after_last_flush_.error) && context_lost_));
 
   // If we've processed all pending commands but still have pending queries,
   // pump idle work until the query is passed.
   if (put_offset == state_after_last_flush_.get_offset &&
       gpu_scheduler_->HasMoreWork()) {
     service_->ScheduleIdleWork(
         base::Bind(&InProcessCommandBuffer::ScheduleMoreIdleWork,
                    gpu_thread_weak_ptr_));
   }
 }
 
 void InProcessCommandBuffer::ScheduleMoreIdleWork() {
-  CheckSequencedThread();
   base::AutoLock lock(command_buffer_lock_);
   if (gpu_scheduler_->HasMoreWork()) {
     gpu_scheduler_->PerformIdleWork();
     service_->ScheduleIdleWork(
         base::Bind(&InProcessCommandBuffer::ScheduleMoreIdleWork,
                    gpu_thread_weak_ptr_));
   }
 }
 
 void InProcessCommandBuffer::Flush(int32 put_offset) {
-  CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   if (last_put_offset_ == put_offset)
     return;
 
   last_put_offset_ = put_offset;
   base::Closure task = base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
                                   gpu_thread_weak_ptr_,
                                   put_offset);
   QueueTask(task);
 }
 
 void InProcessCommandBuffer::WaitForTokenInRange(int32 start, int32 end) {
-  CheckSequencedThread();
   while (!InRange(start, end, GetLastToken()) &&
          last_state_.error == gpu::error::kNoError)
     flush_event_.Wait();
 }
 
 void InProcessCommandBuffer::WaitForGetOffsetInRange(int32 start, int32 end) {
-  CheckSequencedThread();
-
   GetStateFast();
   while (!InRange(start, end, last_state_.get_offset) &&
          last_state_.error == gpu::error::kNoError) {
     flush_event_.Wait();
     GetStateFast();
   }
 }
 
 void InProcessCommandBuffer::SetGetBuffer(int32 shm_id) {
-  CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   {
     base::AutoLock lock(command_buffer_lock_);
     command_buffer_->SetGetBuffer(shm_id);
     last_put_offset_ = 0;
   }
   {
     base::AutoLock lock(state_after_last_flush_lock_);
     state_after_last_flush_ = command_buffer_->GetLastState();
   }
 }
 
 scoped_refptr<Buffer> InProcessCommandBuffer::CreateTransferBuffer(size_t size,
                                                                    int32* id) {
-  CheckSequencedThread();
   base::AutoLock lock(command_buffer_lock_);
   return command_buffer_->CreateTransferBuffer(size, id);
 }
 
 void InProcessCommandBuffer::DestroyTransferBuffer(int32 id) {
-  CheckSequencedThread();
   base::Closure task =
       base::Bind(&InProcessCommandBuffer::DestroyTransferBufferOnGputhread,
                  base::Unretained(this),
                  id);
 
   QueueTask(task);
 }
 
 void InProcessCommandBuffer::DestroyTransferBufferOnGputhread(int32 id) {
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 gpu::Capabilities InProcessCommandBuffer::GetCapabilities() {
   return capabilities_;
 }
 
 gfx::GpuMemoryBuffer* InProcessCommandBuffer::CreateGpuMemoryBuffer(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage,
     int32* id) {
-  CheckSequencedThread();
 
   *id = -1;
   linked_ptr<gfx::GpuMemoryBuffer> buffer =
       make_linked_ptr(g_gpu_memory_buffer_factory->CreateGpuMemoryBuffer(
           width, height, internalformat, usage));
   if (!buffer.get())
     return NULL;
 
   static int32 next_id = 1;
   *id = next_id++;
 
   base::Closure task = base::Bind(&GpuControlService::RegisterGpuMemoryBuffer,
                                   base::Unretained(gpu_control_.get()),
                                   *id,
                                   buffer->GetHandle(),
                                   width,
                                   height,
                                   internalformat);
 
   QueueTask(task);
 
   gpu_memory_buffers_[*id] = buffer;
   return buffer.get();
 }
 
 void InProcessCommandBuffer::DestroyGpuMemoryBuffer(int32 id) {
-  CheckSequencedThread();
   GpuMemoryBufferMap::iterator it = gpu_memory_buffers_.find(id);
   if (it != gpu_memory_buffers_.end())
     gpu_memory_buffers_.erase(it);
   base::Closure task = base::Bind(&GpuControlService::UnregisterGpuMemoryBuffer,
                                   base::Unretained(gpu_control_.get()),
                                   id);
 
   QueueTask(task);
 }
 
 uint32 InProcessCommandBuffer::InsertSyncPoint() {
   uint32 sync_point = g_sync_point_manager.Get().GenerateSyncPoint();
   QueueTask(base::Bind(&InProcessCommandBuffer::RetireSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point));
   return sync_point;
 }
 
 void InProcessCommandBuffer::RetireSyncPointOnGpuThread(uint32 sync_point) {
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent())
     mailbox_manager->PushTextureUpdates();
   g_sync_point_manager.Get().RetireSyncPoint(sync_point);
 }
 
 void InProcessCommandBuffer::SignalSyncPoint(unsigned sync_point,
                                              const base::Closure& callback) {
-  CheckSequencedThread();
   QueueTask(base::Bind(&InProcessCommandBuffer::SignalSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point,
                        WrapCallback(callback)));
 }
 
 void InProcessCommandBuffer::SignalSyncPointOnGpuThread(
     unsigned sync_point,
     const base::Closure& callback) {
   if (g_sync_point_manager.Get().IsSyncPointPassed(sync_point)) {
     callback.Run();
   } else {
     service_->ScheduleIdleWork(
         base::Bind(&InProcessCommandBuffer::SignalSyncPointOnGpuThread,
                    gpu_thread_weak_ptr_,
                    sync_point,
                    callback));
   }
 }
 
 void InProcessCommandBuffer::SignalQuery(unsigned query,
                                          const base::Closure& callback) {
-  CheckSequencedThread();
   QueueTask(base::Bind(&GpuControlService::SignalQuery,
                        base::Unretained(gpu_control_.get()),
                        query,
                        WrapCallback(callback)));
 }
 
 void InProcessCommandBuffer::SetSurfaceVisible(bool visible) {}
 
 void InProcessCommandBuffer::SendManagedMemoryStats(
     const gpu::ManagedMemoryStats& stats) {
@@ skipping 20 matching lines @@
     uint32 client_texture_id) {
 #if defined(OS_ANDROID)
   return stream_texture_manager_->CreateStreamTexture(
       client_texture_id, decoder_->GetContextGroup()->texture_manager());
 #else
   return 0;
 #endif
 }
 
 gpu::error::Error InProcessCommandBuffer::GetLastError() {
-  CheckSequencedThread();
   return last_state_.error;
 }
 
 bool InProcessCommandBuffer::Initialize() {
   NOTREACHED();
   return false;
 }
 
 namespace {
 
@@ skipping 34 matching lines @@
 }
 #endif
 
 // static
 void InProcessCommandBuffer::SetGpuMemoryBufferFactory(
     GpuMemoryBufferFactory* factory) {
   g_gpu_memory_buffer_factory = factory;
 }
 
 }  // namespace gpu