Add gfx::SurfaceFactoryWebview

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 <utility>
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/sequence_checker.h"
 #include "base/threading/thread.h"
 #include "gpu/command_buffer/common/id_allocator.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_share_group.h"
-#include "ui/gl/gl_surface.h"
 
 namespace gpu {
 
 namespace {
 
 static base::LazyInstance<std::set<InProcessCommandBuffer*> >
     g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
 
 static bool g_use_virtualized_gl_context = false;
 static bool g_uses_explicit_scheduling = false;
@@ skipping 191 matching lines @@
       share_group_id_(0),
       last_put_offset_(-1),
       flush_event_(false, false),
       queue_(CreateSchedulerClient()) {}
 
 InProcessCommandBuffer::~InProcessCommandBuffer() {
   Destroy();
 }
 
 bool InProcessCommandBuffer::IsContextLost() {
+  CheckSequencedThread();
   if (context_lost_ || !command_buffer_) {
     return true;
   }
   CommandBuffer::State state = GetState();
   return error::IsError(state.error);
 }
 
 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();
   ScopedEvent handle_flush(&flush_event_);
   command_buffer_lock_.AssertAcquired();
 
   if (!MakeCurrent())
     return;
 
   gpu_scheduler_->PutChanged();
   CommandBuffer::State state = command_buffer_->GetState();
   DCHECK((!error::IsError(state.error) && !context_lost_) ||
          (error::IsError(state.error) && context_lost_));
 }
 
 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,
     bool is_offscreen,
     bool share_resources,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const char* allowed_extensions,
     const std::vector<int32>& attribs,
     gfx::GpuPreference gpu_preference,
     const base::Closure& context_lost_callback,
     unsigned int share_group_id) {
 
   share_resources_ = share_resources;
   context_lost_callback_ = WrapCallback(context_lost_callback);
   share_group_id_ = share_group_id;
 
-  base::WaitableEvent completion(true, false);
-  bool result = false;
+  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;
+  }
+
   base::Callback<bool(void)> init_task =
       base::Bind(&InProcessCommandBuffer::InitializeOnGpuThread,
                  base::Unretained(this),
                  is_offscreen,
                  window,
                  size,
                  allowed_extensions,
                  attribs,
                  gpu_preference);
+
+  base::WaitableEvent completion(true, false);
+  bool result = false;
   QueueTask(
       base::Bind(&RunTaskWithResult<bool>, init_task, &result, &completion));
   completion.Wait();
   return result;
 }
 
 bool InProcessCommandBuffer::InitializeOnGpuThread(
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const char* allowed_extensions,
     const std::vector<int32>& attribs,
     gfx::GpuPreference gpu_preference) {
+  CheckSequencedThread();
   // Use one share group for all contexts.
   CR_DEFINE_STATIC_LOCAL(scoped_refptr<gfx::GLShareGroup>, share_group,
                          (new gfx::GLShareGroup));
 
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
   TransferBufferManager* manager = new TransferBufferManager();
   transfer_buffer_manager_.reset(manager);
   manager->Initialize();
 
@@ skipping 36 matching lines @@
                           NULL, NULL, NULL, NULL, bind_generates_resource)));
 
   gpu_scheduler_.reset(
       new GpuScheduler(command_buffer.get(), decoder_.get(), decoder_.get()));
   command_buffer->SetGetBufferChangeCallback(base::Bind(
       &GpuScheduler::SetGetBuffer, base::Unretained(gpu_scheduler_.get())));
   command_buffer_ = command_buffer.Pass();
 
   decoder_->set_engine(gpu_scheduler_.get());
 
-  if (is_offscreen)
-    surface_ = gfx::GLSurface::CreateOffscreenGLSurface(size);
-  else
-    surface_ = gfx::GLSurface::CreateViewGLSurface(window);
+  if (!surface_) {
+    if (is_offscreen)
+      surface_ = gfx::GLSurface::CreateOffscreenGLSurface(size);
+    else
+      surface_ = gfx::GLSurface::CreateViewGLSurface(window);
+  }
 
   if (!surface_.get()) {
     LOG(ERROR) << "Could not create GLSurface.";
     DestroyOnGpuThread();
     return false;
   }
 
   if (g_use_virtualized_gl_context) {
     context_ = share_group->GetSharedContext();
     if (!context_.get()) {
@@ skipping 47 matching lines @@
   }
 
   if (share_resources_) {
     g_all_shared_contexts.Pointer()->insert(this);
   }
 
   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();
   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;
 
   g_all_shared_contexts.Pointer()->erase(this);
   return true;
 }
 
+void InProcessCommandBuffer::CheckSequencedThread() {
+  if (!sequence_checker_) {
+    DCHECK(sequence_checker_->CalledOnValidSequencedThread());

[piman, 2013/08/07 00:03:41]

maybe DCHECK(!sequence_checker_ ||
sequence_checker_->CalledOnValidSequencedThread()), that way you don't pay for
the extra test in release.

Note that the current code is wrong: you dereference a pointer that you just
tested is NULL.

[boliu, 2013/08/07 00:24:57]

Oop!! Fixed.

+  }
+}
+
 unsigned int InProcessCommandBuffer::CreateImageForGpuMemoryBuffer(
     gfx::GpuMemoryBufferHandle buffer,
     gfx::Size size) {
+  CheckSequencedThread();
   unsigned int image_id;
   {
     // TODO: ID allocation should go through CommandBuffer
     base::AutoLock lock(command_buffer_lock_);
     gles2::ContextGroup* group = decoder_->GetContextGroup();
     image_id =
         group->GetIdAllocator(gles2::id_namespaces::kImages)->AllocateID();
   }
   base::Closure image_task =
       base::Bind(&InProcessCommandBuffer::CreateImageOnGpuThread,
                  base::Unretained(this), buffer, size, image_id);
   QueueTask(image_task);
   return image_id;
 }
 
 void InProcessCommandBuffer::CreateImageOnGpuThread(
     gfx::GpuMemoryBufferHandle buffer,
     gfx::Size size,
     unsigned int image_id) {
+  CheckSequencedThread();
   scoped_refptr<gfx::GLImage> gl_image =
       gfx::GLImage::CreateGLImageForGpuMemoryBuffer(buffer, size);
    decoder_->GetContextGroup()->image_manager()->AddImage(gl_image, image_id);
 }
 
 void InProcessCommandBuffer::RemoveImage(unsigned int image_id) {
+  CheckSequencedThread();
   {
     // TODO: ID allocation should go through CommandBuffer
     base::AutoLock lock(command_buffer_lock_);
     gles2::ContextGroup* group = decoder_->GetContextGroup();
     group->GetIdAllocator(gles2::id_namespaces::kImages)->FreeID(image_id);
   }
   base::Closure image_manager_task =
       base::Bind(&InProcessCommandBuffer::RemoveImageOnGpuThread,
                  base::Unretained(this),
                  image_id);
   QueueTask(image_manager_task);
 }
 
 void InProcessCommandBuffer::RemoveImageOnGpuThread(unsigned int image_id) {
+  CheckSequencedThread();
   decoder_->GetContextGroup()->image_manager()->RemoveImage(image_id);
 }
 
 void InProcessCommandBuffer::OnContextLost() {
+  CheckSequencedThread();
   if (!context_lost_callback_.is_null()) {
     context_lost_callback_.Run();
     context_lost_callback_.Reset();
   }
 
   context_lost_ = true;
   if (share_resources_) {
     for (std::set<InProcessCommandBuffer*>::iterator it =
              g_all_shared_contexts.Get().begin();
          it != g_all_shared_contexts.Get().end();
          ++it) {
       (*it)->context_lost_ = true;
     }
   }
 }
 
 CommandBuffer::State InProcessCommandBuffer::GetStateFast() {
+  CheckSequencedThread();
   base::AutoLock lock(command_buffer_lock_);
   return last_state_ = command_buffer_->GetState();
 }
 
 CommandBuffer::State InProcessCommandBuffer::GetState() {
+  CheckSequencedThread();
   return GetStateFast();
 }
 
 CommandBuffer::State InProcessCommandBuffer::GetLastState() {
+  CheckSequencedThread();
   return last_state_;
 }
 
-int32 InProcessCommandBuffer::GetLastToken() { return last_state_.token; }
+int32 InProcessCommandBuffer::GetLastToken() {
+  CheckSequencedThread();
+  return last_state_.token;
+}
 
 void InProcessCommandBuffer::FlushOnGpuThread(int32 put_offset) {
+  CheckSequencedThread();
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->Flush(put_offset);
 }
 
 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,
                                   base::Unretained(this),
                                   put_offset);
   QueueTask(task);
 }
 
 CommandBuffer::State InProcessCommandBuffer::FlushSync(int32 put_offset,
                                                        int32 last_known_get) {
+  CheckSequencedThread();
   if (put_offset == last_known_get || last_state_.error != gpu::error::kNoError)
     return last_state_;
 
   Flush(put_offset);
   GetStateFast();
   while (last_known_get == last_state_.get_offset &&
          last_state_.error == gpu::error::kNoError) {
     flush_event_.Wait();
     GetStateFast();
   }
 
   return last_state_;
 }
 
 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;
   }
   GetStateFast();
 }
 
 gpu::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(&CommandBuffer::DestroyTransferBuffer,
                                   base::Unretained(command_buffer_.get()),
                                   id);
 
   QueueTask(task);
 }
 
 gpu::Buffer InProcessCommandBuffer::GetTransferBuffer(int32 id) {
   NOTREACHED();
   return gpu::Buffer();
 }
 
 uint32 InProcessCommandBuffer::InsertSyncPoint() {
   NOTREACHED();
   return 0;
 }
 void InProcessCommandBuffer::SignalSyncPoint(unsigned sync_point,
                                              const base::Closure& callback) {
+  CheckSequencedThread();
   QueueTask(WrapCallback(callback));
 }
 
 gpu::error::Error InProcessCommandBuffer::GetLastError() {
+  CheckSequencedThread();
   return last_state_.error;
 }
 
 bool InProcessCommandBuffer::Initialize() {
   NOTREACHED();
   return false;
 }
 
 void InProcessCommandBuffer::SetGetOffset(int32 get_offset) { NOTREACHED(); }
 
@@ skipping 52 matching lines @@
   g_uses_explicit_scheduling = true;
   g_gpu_queue.Get().SetScheduleCallback(callback);
 }
 
 // static
 void InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread() {
   g_gpu_queue.Get().RunTasks();
 }
 
 }  // namespace gpu