Mandoline: WebGL: Pass context creation attributes to GPU.

components/mus/gles2/command_buffer_driver.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 "components/mus/gles2/command_buffer_driver.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "components/mus/gles2/command_buffer_type_conversions.h"
@@ skipping 28 matching lines @@
 CommandBufferDriver::CommandBufferDriver(scoped_refptr<GpuState> gpu_state)
     : client_(nullptr), gpu_state_(gpu_state), weak_factory_(this) {}
 
 CommandBufferDriver::~CommandBufferDriver() {
   DestroyDecoder();
 }
 
 void CommandBufferDriver::Initialize(
     mojo::CommandBufferSyncClientPtr sync_client,
     mojo::CommandBufferLostContextObserverPtr loss_observer,
-    mojo::ScopedSharedBufferHandle shared_state) {
+    mojo::ScopedSharedBufferHandle shared_state,
+    mojo::Array<int32_t> attribs) {
   sync_client_ = sync_client.Pass();
   loss_observer_ = loss_observer.Pass();
-  bool success = DoInitialize(shared_state.Pass());
+  bool success = DoInitialize(shared_state.Pass(), attribs.Pass());
   mojo::GpuCapabilitiesPtr capabilities =
       success ? mojo::GpuCapabilities::From(decoder_->GetCapabilities())
               : nullptr;
   sync_client_->DidInitialize(success, capabilities.Pass());
 }
 
 bool CommandBufferDriver::MakeCurrent() {
   if (!decoder_)
     return false;
   if (decoder_->MakeCurrent())
     return true;
   DLOG(ERROR) << "Context lost because MakeCurrent failed.";
   gpu::error::ContextLostReason reason =
       static_cast<gpu::error::ContextLostReason>(
           decoder_->GetContextLostReason());
   command_buffer_->SetContextLostReason(reason);
   command_buffer_->SetParseError(gpu::error::kLostContext);
   OnContextLost(reason);
   return false;
 }
 
 bool CommandBufferDriver::DoInitialize(
-    mojo::ScopedSharedBufferHandle shared_state) {
+    mojo::ScopedSharedBufferHandle shared_state,
+    mojo::Array<int32_t> attribs) {
+  gpu::gles2::ContextCreationAttribHelper attrib_helper;
+  if (!attrib_helper.Parse(attribs.storage()))
+    return false;
+
   surface_ = gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size(1, 1));
 
   if (!surface_.get())
     return false;
 
   // TODO(piman): virtual contexts, gpu preference.
   context_ = gfx::GLContext::CreateGLContext(
       gpu_state_->share_group(), surface_.get(), gfx::PreferIntegratedGpu);
   if (!context_.get())
     return false;
 
   if (!context_->MakeCurrent(surface_.get()))
     return false;
 
   // TODO(piman): ShaderTranslatorCache is currently per-ContextGroup but
   // only needs to be per-thread.
-  bool bind_generates_resource = false;
+  const bool bind_generates_resource = attrib_helper.bind_generates_resource;
   scoped_refptr<gpu::gles2::ContextGroup> context_group =
       new gpu::gles2::ContextGroup(
           gpu_state_->mailbox_manager(), new GpuMemoryTracker,
           new gpu::gles2::ShaderTranslatorCache,
           new gpu::gles2::FramebufferCompletenessCache, nullptr, nullptr,
           nullptr, bind_generates_resource);
 
   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(&CommandBufferDriver::OnResize, base::Unretained(this)));
   decoder_->SetWaitSyncPointCallback(base::Bind(
       &CommandBufferDriver::OnWaitSyncPoint, base::Unretained(this)));
 
   gpu::gles2::DisallowedFeatures disallowed_features;
 
-  // TODO(piman): attributes.
   const bool offscreen = true;
   std::vector<int32> attrib_vector;
+  attrib_helper.Serialize(&attrib_vector);
   if (!decoder_->Initialize(surface_, context_, offscreen, gfx::Size(1, 1),
                             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())));
   command_buffer_->SetParseErrorCallback(
       base::Bind(&CommandBufferDriver::OnParseError, base::Unretained(this)));
@@ skipping 167 matching lines @@
 
 void CommandBufferDriver::DestroyDecoder() {
   if (decoder_) {
     bool have_context = decoder_->MakeCurrent();
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
 }
 
 }  // namespace gles2