Teach GPU command buffer whether a context is webgl.

gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.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/service/gles2_cmd_decoder_unittest_base.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 139 matching lines @@
     : extensions("GL_EXT_framebuffer_object"),
       gl_version("2.1"),
       has_alpha(false),
       has_depth(false),
       has_stencil(false),
       request_alpha(false),
       request_depth(false),
       request_stencil(false),
       bind_generates_resource(false),
       lose_context_when_out_of_memory(false),
-      use_native_vao(true) {
+      use_native_vao(true),
+      webgl_version(0) {
 }
 
 void GLES2DecoderTestBase::InitDecoder(const InitState& init) {
   InitDecoderWithCommandLine(init, NULL);
 }
 
 void GLES2DecoderTestBase::InitDecoderWithCommandLine(
     const InitState& init,
     const base::CommandLine* command_line) {
   InitState normalized_init = init;
@@ skipping 49 matching lines @@
   // We initialize the ContextGroup with a MockGLES2Decoder so that
   // we can use the ContextGroup to figure out how the real GLES2Decoder
   // will initialize itself.
   mock_decoder_.reset(new MockGLES2Decoder());
 
   // Install FakeDoCommands handler so we can use individual DoCommand()
   // expectations.
   EXPECT_CALL(*mock_decoder_, DoCommands(_, _, _, _)).WillRepeatedly(
       Invoke(mock_decoder_.get(), &MockGLES2Decoder::FakeDoCommands));
 
-  EXPECT_TRUE(
-      group_->Initialize(mock_decoder_.get(), DisallowedFeatures()));
 
-  if (group_->feature_info()->IsES3Capable()) {
+  EXPECT_TRUE(group_->Initialize(
+      mock_decoder_.get(),
+      ContextGroup::GetContextType(init.webgl_version),
+      DisallowedFeatures()));
+
+  if (init.webgl_version == 2) {
     EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_COLOR_ATTACHMENTS, _))
         .WillOnce(SetArgumentPointee<1>(kMaxColorAttachments))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_DRAW_BUFFERS, _))
         .WillOnce(SetArgumentPointee<1>(kMaxDrawBuffers))
         .RetiresOnSaturation();
   }
 
   if (group_->feature_info()->feature_flags().native_vertex_array_object) {
     EXPECT_CALL(*gl_, GenVertexArraysOES(1, _))
@@ skipping 149 matching lines @@
   engine_.reset(new StrictMock<MockCommandBufferEngine>());
   scoped_refptr<gpu::Buffer> buffer =
       engine_->GetSharedMemoryBuffer(kSharedMemoryId);
   shared_memory_offset_ = kSharedMemoryOffset;
   shared_memory_address_ =
       reinterpret_cast<int8*>(buffer->memory()) + shared_memory_offset_;
   shared_memory_id_ = kSharedMemoryId;
   shared_memory_base_ = buffer->memory();
 
   static const int32 kLoseContextWhenOutOfMemory = 0x10002;
-  static const int32 kES3ContextRequired = 0x10003;
-
-  bool es3_context_required = group_->feature_info()->IsES3Capable();
+  static const int32 kWebGLVersion = 0x10003;
 
   int32 attributes[] = {
       EGL_ALPHA_SIZE,
       normalized_init.request_alpha ? 8 : 0,
       EGL_DEPTH_SIZE,
       normalized_init.request_depth ? 24 : 0,
       EGL_STENCIL_SIZE,
       normalized_init.request_stencil ? 8 : 0,
       kLoseContextWhenOutOfMemory,
       normalized_init.lose_context_when_out_of_memory ? 1 : 0,
-      kES3ContextRequired,
-      es3_context_required ? 1 : 0
+      kWebGLVersion,
+      init.webgl_version
   };
   std::vector<int32> attribs(attributes, attributes + arraysize(attributes));
 
   decoder_.reset(GLES2Decoder::Create(group_.get()));
   decoder_->SetIgnoreCachedStateForTest(ignore_cached_state_for_test_);
   decoder_->GetLogger()->set_log_synthesized_gl_errors(false);
   decoder_->Initialize(surface_,
                        context_,
                        false,
                        surface_->GetSize(),
@@ skipping 1388 matching lines @@
   SetupDefaultProgram();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_0_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu