command_buffer: Add support for creating non-WebGL ES 3 contexts

gpu/command_buffer/tests/gl_manager.cc

 // Copyright (c) 2012 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/tests/gl_manager.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
@@ skipping 91 matching lines @@
 scoped_refptr<gfx::GLContext>* GLManager::base_context_;
 
 GLManager::Options::Options()
     : size(4, 4),
       share_group_manager(NULL),
       share_mailbox_manager(NULL),
       virtual_manager(NULL),
       bind_generates_resource(false),
       lose_context_when_out_of_memory(false),
       context_lost_allowed(false),
-      webgl_version(0) {
-}
+      context_type(gles2::CONTEXT_TYPE_OPENGLES2) {}
 
 GLManager::GLManager() : context_lost_allowed_(false) {
   SetupBaseContext();
 }
 
 GLManager::~GLManager() {
   --use_count_;
   if (!use_count_) {
     if (base_share_group_) {
       delete base_context_;
@@ skipping 66 matching lines @@
 
   gfx::GpuPreference gpu_preference(gfx::PreferDiscreteGpu);
   std::vector<int32> attribs;
   gles2::ContextCreationAttribHelper attrib_helper;
   attrib_helper.red_size = 8;
   attrib_helper.green_size = 8;
   attrib_helper.blue_size = 8;
   attrib_helper.alpha_size = 8;
   attrib_helper.depth_size = 16;
   attrib_helper.stencil_size = 8;
-  attrib_helper.webgl_version = options.webgl_version;
+  attrib_helper.context_type = options.context_type;
+
   attrib_helper.Serialize(&attribs);
 
   DCHECK(!command_line || !context_group);
   if (!context_group) {
     scoped_refptr<gles2::FeatureInfo> feature_info;
     if (command_line)
       feature_info = new gles2::FeatureInfo(*command_line);
     context_group = new gles2::ContextGroup(
         mailbox_manager_.get(), NULL, new gpu::gles2::ShaderTranslatorCache,
         new gpu::gles2::FramebufferCompletenessCache, feature_info, NULL, NULL,
@@ skipping 30 matching lines @@
     } else {
       context_ = gfx::GLContext::CreateGLContext(share_group_.get(),
                                                  surface_.get(),
                                                  gpu_preference);
     }
   }
   ASSERT_TRUE(context_.get() != NULL) << "could not create GL context";
 
   ASSERT_TRUE(context_->MakeCurrent(surface_.get()));
 
-  ASSERT_TRUE(decoder_->Initialize(
-      surface_.get(),
-      context_.get(),
-      true,
-      options.size,
-      ::gpu::gles2::DisallowedFeatures(),
-      attribs)) << "could not initialize decoder";
+  if (!decoder_->Initialize(surface_.get(), context_.get(), true, options.size,
+                            ::gpu::gles2::DisallowedFeatures(), attribs)) {
+    return;
+  }
 
   command_buffer_->SetPutOffsetChangeCallback(
       base::Bind(&GLManager::PumpCommands, base::Unretained(this)));
   command_buffer_->SetGetBufferChangeCallback(
       base::Bind(&GLManager::GetBufferChanged, base::Unretained(this)));
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gles2::GLES2CmdHelper(command_buffer_.get()));
   ASSERT_TRUE(gles2_helper_->Initialize(kCommandBufferSize));
 
@@ skipping 51 matching lines @@
   if (gles2_implementation_.get()) {
     MakeCurrent();
     EXPECT_TRUE(glGetError() == GL_NONE);
     gles2_implementation_->Flush();
     gles2_implementation_.reset();
   }
   transfer_buffer_.reset();
   gles2_helper_.reset();
   command_buffer_.reset();
   if (decoder_.get()) {
-    bool have_context = decoder_->GetGLContext()->MakeCurrent(surface_.get());
+    bool have_context = decoder_->GetGLContext() &&
+                        decoder_->GetGLContext()->MakeCurrent(surface_.get());
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
 }
 
 const gpu::gles2::FeatureInfo::Workarounds& GLManager::workarounds() const {
   return decoder_->GetContextGroup()->feature_info()->workarounds();
 }
 
 void GLManager::PumpCommands() {
@@ skipping 100 matching lines @@
 
 gpu::CommandBufferNamespace GLManager::GetNamespaceID() const {
   return gpu::CommandBufferNamespace::IN_PROCESS;
 }
 
 uint64_t GLManager::GetCommandBufferID() const {
   return 0;
 }
 
 }  // namespace gpu