Revert of gpu: Raise GL_OUT_OF_MEMORY when BeginQueryEXT fails to allocate.

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>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_mock.h"
 #include "ui/gl/gl_surface.h"
 
 using ::gfx::MockGLInterface;
@@ skipping 26 matching lines @@
       client_vertex_shader_id_(121),
       client_fragment_shader_id_(122),
       client_query_id_(123),
       client_vertexarray_id_(124) {
   memset(immediate_buffer_, 0xEE, sizeof(immediate_buffer_));
 }
 
 GLES2DecoderTestBase::~GLES2DecoderTestBase() {}
 
 void GLES2DecoderTestBase::SetUp() {
-  InitState init;
-  init.gl_version = "3.0";
-  init.has_alpha = true;
-  init.has_depth = true;
-  init.request_alpha = true;
-  init.request_depth = true;
-  init.bind_generates_resource = true;
-  InitDecoder(init);
+  InitDecoder(
+      "",      // extensions
+      "3.0",   // gl version
+      true,    // has alpha
+      true,    // has depth
+      false,   // has stencil
+      true,    // request alpha
+      true,    // request depth
+      false,   // request stencil
+      true);   // bind generates resource
 }
 
 void GLES2DecoderTestBase::AddExpectationsForVertexAttribManager() {
   for (GLint ii = 0; ii < kNumVertexAttribs; ++ii) {
     EXPECT_CALL(*gl_, VertexAttrib4f(ii, 0.0f, 0.0f, 0.0f, 1.0f))
         .Times(1)
         .RetiresOnSaturation();
   }
 }
 
-GLES2DecoderTestBase::InitState::InitState()
-    : 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) {}
-
-void GLES2DecoderTestBase::InitDecoder(const InitState& init) {
-  InitDecoderWithCommandLine(init, NULL);
+void GLES2DecoderTestBase::InitDecoder(
+    const char* extensions,
+    const char* gl_version,
+    bool has_alpha,
+    bool has_depth,
+    bool has_stencil,
+    bool request_alpha,
+    bool request_depth,
+    bool request_stencil,
+    bool bind_generates_resource) {
+  InitDecoderWithCommandLine(extensions,
+                             gl_version,
+                             has_alpha,
+                             has_depth,
+                             has_stencil,
+                             request_alpha,
+                             request_depth,
+                             request_stencil,
+                             bind_generates_resource,
+                             NULL);
 }
 
 void GLES2DecoderTestBase::InitDecoderWithCommandLine(
-    const InitState& init,
+    const char* extensions,
+    const char* gl_version,
+    bool has_alpha,
+    bool has_depth,
+    bool has_stencil,
+    bool request_alpha,
+    bool request_depth,
+    bool request_stencil,
+    bool bind_generates_resource,
     const base::CommandLine* command_line) {
   Framebuffer::ClearFramebufferCompleteComboMap();
 
   gfx::SetGLGetProcAddressProc(gfx::MockGLInterface::GetGLProcAddress);
   gfx::GLSurface::InitializeOneOffWithMockBindingsForTests();
 
   gl_.reset(new StrictMock<MockGLInterface>());
   ::gfx::MockGLInterface::SetGLInterface(gl_.get());
 
   // Only create stream texture manager if extension is requested.
   std::vector<std::string> list;
-  base::SplitString(init.extensions, ' ', &list);
+  base::SplitString(std::string(extensions), ' ', &list);
   scoped_refptr<FeatureInfo> feature_info;
   if (command_line)
     feature_info = new FeatureInfo(*command_line);
-  group_ = scoped_refptr<ContextGroup>(
-      new ContextGroup(NULL,
-                       NULL,
-                       memory_tracker_,
-                       feature_info.get(),
-                       init.bind_generates_resource));
+  group_ = scoped_refptr<ContextGroup>(new ContextGroup(
+      NULL,
+      NULL,
+      memory_tracker_,
+      feature_info.get(),
+      bind_generates_resource));
 
   InSequence sequence;
 
   surface_ = new gfx::GLSurfaceStub;
   surface_->SetSize(gfx::Size(kBackBufferWidth, kBackBufferHeight));
 
   // Context needs to be created before initializing ContextGroup, which will
   // in turn initialize FeatureInfo, which needs a context to determine
   // extension support.
   context_ = new gfx::GLContextStubWithExtensions;
-  context_->AddExtensionsString(init.extensions.c_str());
-  context_->SetGLVersionString(init.gl_version.c_str());
+  context_->AddExtensionsString(extensions);
+  context_->SetGLVersionString(gl_version);
 
   context_->MakeCurrent(surface_.get());
   gfx::GLSurface::InitializeDynamicMockBindingsForTests(context_);
 
   TestHelper::SetupContextGroupInitExpectations(gl_.get(),
-                                                DisallowedFeatures(),
-                                                init.extensions.c_str(),
-                                                init.gl_version.c_str());
+      DisallowedFeatures(), extensions, gl_version);
 
   // 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());
   EXPECT_TRUE(
       group_->Initialize(mock_decoder_.get(), DisallowedFeatures()));
 
   if (group_->feature_info()->workarounds().init_vertex_attributes)
     AddExpectationsForVertexAttribManager();
@@ skipping 56 matching lines @@
         .RetiresOnSaturation();
   }
   EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
       .Times(1)
       .RetiresOnSaturation();
 
   EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER, 0))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
-      .WillOnce(SetArgumentPointee<1>(init.has_alpha ? 8 : 0))
-      .RetiresOnSaturation();
+       .WillOnce(SetArgumentPointee<1>(has_alpha ? 8 : 0))
+       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
-      .WillOnce(SetArgumentPointee<1>(init.has_depth ? 24 : 0))
-      .RetiresOnSaturation();
+       .WillOnce(SetArgumentPointee<1>(has_depth ? 24 : 0))
+       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
-      .WillOnce(SetArgumentPointee<1>(init.has_stencil ? 8 : 0))
-      .RetiresOnSaturation();
+       .WillOnce(SetArgumentPointee<1>(has_stencil ? 8 : 0))
+       .RetiresOnSaturation();
 
   EXPECT_CALL(*gl_, Enable(GL_VERTEX_PROGRAM_POINT_SIZE))
       .Times(1)
       .RetiresOnSaturation();
 
   EXPECT_CALL(*gl_, Enable(GL_POINT_SPRITE))
       .Times(1)
       .RetiresOnSaturation();
 
   static GLint max_viewport_dims[] = {
@@ skipping 36 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 = 0x10003;
-
-  int32 attributes[] = {EGL_ALPHA_SIZE,
-                        init.request_alpha ? 8 : 0,
-                        EGL_DEPTH_SIZE,
-                        init.request_depth ? 24 : 0,
-                        EGL_STENCIL_SIZE,
-                        init.request_stencil ? 8 : 0,
-                        kLoseContextWhenOutOfMemory,
-                        init.lose_context_when_out_of_memory ? 1 : 0, };
+  int32 attributes[] = {
+    EGL_ALPHA_SIZE, request_alpha ? 8 : 0,
+    EGL_DEPTH_SIZE, request_depth ? 24 : 0,
+    EGL_STENCIL_SIZE, request_stencil ? 8 : 0,
+  };
   std::vector<int32> attribs(attributes, attributes + arraysize(attributes));
 
   decoder_.reset(GLES2Decoder::Create(group_.get()));
   decoder_->GetLogger()->set_log_synthesized_gl_errors(false);
   decoder_->Initialize(surface_,
                        context_,
                        false,
                        surface_->GetSize(),
                        DisallowedFeatures(),
                        attribs);
@@ skipping 1154 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