Connect up --disable-gl-multisampling to command buffer

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2010 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.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 652 matching lines @@
   virtual Error DoCommand(unsigned int command,
                           unsigned int arg_count,
                           const void* args);
 
   // Overridden from AsyncAPIInterface.
   virtual const char* GetCommandName(unsigned int command_id) const;
 
   // Overridden from GLES2Decoder.
   virtual bool Initialize(gfx::GLContext* context,
                           const gfx::Size& size,
+                          const DisallowedExtensions& disallowed_extensions,
                           const char* allowed_extensions,
                           const std::vector<int32>& attribs,
                           GLES2Decoder* parent,
                           uint32 parent_client_texture_id);
   virtual void Destroy();
   virtual void ResizeOffscreenFrameBuffer(const gfx::Size& size);
   virtual bool UpdateOffscreenFrameBufferSize();
   virtual bool MakeCurrent();
   virtual GLES2Util* GetGLES2Util() { return &util_; }
   virtual gfx::GLContext* GetGLContext() { return context_.get(); }
@@ skipping 752 matching lines @@
   // The last error message set.
   std::string last_error_;
 
   // The current decoder error.
   error::Error current_decoder_error_;
 
   bool use_shader_translator_;
   scoped_ptr<ShaderTranslator> vertex_translator_;
   scoped_ptr<ShaderTranslator> fragment_translator_;
 
+  DisallowedExtensions disallowed_extensions_;
+
   // Cached from ContextGroup
   const Validators* validators_;
   FeatureInfo* feature_info_;
 
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 ScopedGLErrorSuppressor::ScopedGLErrorSuppressor(GLES2DecoderImpl* decoder)
     : decoder_(decoder) {
   decoder_->CopyRealGLErrorsToWrapper();
@@ skipping 325 matching lines @@
   // GLES2DecoderWithShaderTest.GetShaderInfoLogValidArgs passes the
   // empty string to CompileShader and this is not a valid shader.
   // TODO(apatrick): fix this test.
   if ((gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 &&
        !feature_info_->feature_flags().chromium_webglsl) ||
       gfx::GetGLImplementation() == gfx::kGLImplementationMockGL) {
     use_shader_translator_ = false;
   }
 }
 
-bool GLES2DecoderImpl::Initialize(gfx::GLContext* context,
-                                  const gfx::Size& size,
-                                  const char* allowed_extensions,
-                                  const std::vector<int32>& attribs,
-                                  GLES2Decoder* parent,
-                                  uint32 parent_client_texture_id) {
+bool GLES2DecoderImpl::Initialize(
+    gfx::GLContext* context,
+    const gfx::Size& size,
+    const DisallowedExtensions& disallowed_extensions,
+    const char* allowed_extensions,
+    const std::vector<int32>& attribs,
+    GLES2Decoder* parent,
+    uint32 parent_client_texture_id) {
   DCHECK(context);
   DCHECK(!context_.get());
 
   // Take ownership of the GLContext.
   context_.reset(context);
 
   // Keep only a weak pointer to the parent so we don't unmap its client
   // frame buffer after it has been destroyed.
   if (parent)
     parent_ = static_cast<GLES2DecoderImpl*>(parent)->AsWeakPtr();
 
   if (!MakeCurrent()) {
     LOG(ERROR) << "GLES2DecoderImpl::Initialize failed because "
                << "MakeCurrent failed.";
     Destroy();
     return false;
   }
 
-  if (!group_->Initialize(allowed_extensions)) {
+  if (!group_->Initialize(disallowed_extensions, allowed_extensions)) {
     LOG(ERROR) << "GPUProcessor::InitializeCommon failed because group "
                << "failed to initialize.";
     Destroy();
     return false;
   }
 
   CHECK_GL_ERROR();
+  disallowed_extensions_ = disallowed_extensions;
 
   vertex_attrib_manager_.Initialize(group_->max_vertex_attribs());
 
   GLint v = 0;
   glGetIntegerv(GL_ALPHA_BITS, &v);
   back_buffer_color_format_ = v ? GL_RGBA : GL_RGB;
 
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     // We have to enable vertex array 0 on OpenGL or it won't render. Note that
     // OpenGL ES 2.0 does not have this issue.
@@ skipping 4329 matching lines @@
 
   *result = 1;  // true.
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetRequestableExtensionsCHROMIUM(
     uint32 immediate_data_size,
     const gles2::GetRequestableExtensionsCHROMIUM& c) {
   Bucket* bucket = CreateBucket(c.bucket_id);
   scoped_ptr<FeatureInfo> info(new FeatureInfo());
-  info->Initialize(NULL);
+  info->Initialize(disallowed_extensions_, NULL);
   bucket->SetFromString(info->extensions().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleRequestExtensionCHROMIUM(
     uint32 immediate_data_size, const gles2::RequestExtensionCHROMIUM& c) {
   Bucket* bucket = GetBucket(c.bucket_id);
   std::string feature_str;
   if (!bucket->GetAsString(&feature_str)) {
     return error::kInvalidArguments;
@@ skipping 18 matching lines @@
   return error::kNoError;
 }
 
 // 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_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu