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();

[no sievers, 2013/08/07 01:52:38]

Does it make sense to always have a sequence checker? It seems useful for
verifying that things happen on the right thread. You could have one for the
client entry points and one for the service. And if you pass in a surface, both
would point to the same thread checker instance.

Then you'd also not need the function indirection, since it would stay a
one-liner.

[boliu, 2013/08/07 02:58:48]

Can't use scoped_ptr anymore since they could both point to the same object, and
can't refcount it directly. Going to keep this as is now.

   // 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() {
+  DCHECK(!sequence_checker_ ||
+         sequence_checker_->CalledOnValidSequencedThread());
+}
+
 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