Mojo multiple command buffer support and sample

mojo/services/gles2/command_buffer_impl.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 "mojo/services/gles2/command_buffer_impl.h"
 
 #include "base/bind.h"
 #include "base/memory/shared_memory.h"
 
 #include "gpu/command_buffer/common/constants.h"
@@ skipping 27 matching lines @@
   };
 
  private:
   virtual ~MemoryTrackerStub() {}
 
   DISALLOW_COPY_AND_ASSIGN(MemoryTrackerStub);
 };
 
 }  // anonymous namespace
 
-CommandBufferImpl::CommandBufferImpl(gfx::AcceleratedWidget widget,
-                                     const gfx::Size& size)
-    : widget_(widget), size_(size) {}
+CommandBufferImpl::CommandBufferImpl(
+    gfx::GLShareGroup* share_group,
+    gpu::gles2::MailboxManager* mailbox_manager)
+    : widget_(gfx::kNullAcceleratedWidget),
+      size_(1, 1),
+      share_group_(share_group),
+      mailbox_manager_(mailbox_manager) {
+}
+
+CommandBufferImpl::CommandBufferImpl(
+    gfx::AcceleratedWidget widget,
+    const gfx::Size& size,
+    gfx::GLShareGroup* share_group,
+    gpu::gles2::MailboxManager* mailbox_manager)
+    : widget_(widget),
+      size_(size),
+      share_group_(share_group),
+      mailbox_manager_(mailbox_manager) {
+}
 
 CommandBufferImpl::~CommandBufferImpl() {
   client()->DidDestroy();
   if (decoder_) {
     bool have_context = decoder_->MakeCurrent();
     decoder_->Destroy(have_context);
   }
 }
 
 void CommandBufferImpl::Initialize(
     CommandBufferSyncClientPtr sync_client,
     mojo::ScopedSharedBufferHandle shared_state) {
   sync_client_ = sync_client.Pass();
   sync_client_->DidInitialize(DoInitialize(shared_state.Pass()));
 }
 
 bool CommandBufferImpl::DoInitialize(
     mojo::ScopedSharedBufferHandle shared_state) {
-  // TODO(piman): offscreen surface.
-  surface_ = gfx::GLSurface::CreateViewGLSurface(widget_);
+  if (widget_ == gfx::kNullAcceleratedWidget)
+    surface_ = gfx::GLSurface::CreateOffscreenGLSurface(size_);
+  else
+    surface_ = gfx::GLSurface::CreateViewGLSurface(widget_);
   if (!surface_.get())
     return false;
 
-  // TODO(piman): context sharing, virtual contexts, gpu preference.
-  scoped_refptr<gfx::GLContext> context = gfx::GLContext::CreateGLContext(
-      NULL, surface_.get(), gfx::PreferIntegratedGpu);
-  if (!context.get())
+  // TODO(piman): virtual contexts, gpu preference.
+  context_ = gfx::GLContext::CreateGLContext(
+      share_group_, surface_.get(), gfx::PreferIntegratedGpu);
+  if (!context_.get())
     return false;
 
-  if (!context->MakeCurrent(surface_.get()))
+  if (!context_->MakeCurrent(surface_.get()))
     return false;
 
   // TODO(piman): ShaderTranslatorCache is currently per-ContextGroup but
   // only needs to be per-thread.
   scoped_refptr<gpu::gles2::ContextGroup> context_group =
-      new gpu::gles2::ContextGroup(NULL,
+      new gpu::gles2::ContextGroup(mailbox_manager_,
                                    new MemoryTrackerStub,
                                    new gpu::gles2::ShaderTranslatorCache,
                                    NULL,
                                    true);
 
   command_buffer_.reset(
       new gpu::CommandBufferService(context_group->transfer_buffer_manager()));
   bool result = command_buffer_->Initialize();
   DCHECK(result);
 
   decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group.get()));
   scheduler_.reset(new gpu::GpuScheduler(
       command_buffer_.get(), decoder_.get(), decoder_.get()));
   decoder_->set_engine(scheduler_.get());
   decoder_->SetResizeCallback(
       base::Bind(&CommandBufferImpl::OnResize, base::Unretained(this)));
 
   gpu::gles2::DisallowedFeatures disallowed_features;
 
   // TODO(piman): attributes.
   std::vector<int32> attrib_vector;
   if (!decoder_->Initialize(surface_,
-                            context,
+                            context_,
                             false /* offscreen */,
                             size_,
                             disallowed_features,
                             attrib_vector))
     return false;
 
   command_buffer_->SetPutOffsetChangeCallback(base::Bind(
       &gpu::GpuScheduler::PutChanged, base::Unretained(scheduler_.get())));
   command_buffer_->SetGetBufferChangeCallback(base::Bind(
       &gpu::GpuScheduler::SetGetBuffer, base::Unretained(scheduler_.get())));
@@ skipping 10 matching lines @@
 
   command_buffer_->SetSharedStateBuffer(backing.Pass());
   return true;
 }
 
 void CommandBufferImpl::SetGetBuffer(int32_t buffer) {
   command_buffer_->SetGetBuffer(buffer);
 }
 
 void CommandBufferImpl::Flush(int32_t put_offset) {
+  if (!context_->MakeCurrent(surface_.get())) {
+    DLOG(WARNING) << "Context lost";
+    client()->LostContext(gpu::error::kUnknown);
+    return;
+  }
   command_buffer_->Flush(put_offset);
 }
 
 void CommandBufferImpl::MakeProgress(int32_t last_get_offset) {
   // TODO(piman): handle out-of-order.
   sync_client_->DidMakeProgress(
       CommandBufferState::From(command_buffer_->GetLastState()));
 }
 
 void CommandBufferImpl::RegisterTransferBuffer(
@@ skipping 22 matching lines @@
 void CommandBufferImpl::OnParseError() {
   gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   client()->LostContext(state.context_lost_reason);
 }
 
 void CommandBufferImpl::OnResize(gfx::Size size, float scale_factor) {
   surface_->Resize(size);
 }
 
 }  // namespace mojo