gpu: Raise GL_OUT_OF_MEMORY when BeginQueryEXT fails to allocate.

gpu/command_buffer/client/gles2_implementation_unittest.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.
 
 // Tests for GLES2Implementation.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
+#include <limits>
+
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include "base/compiler_specific.h"
 #include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/client/program_info_manager.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ skipping 364 matching lines @@
   static const GLuint kTexturesStartId = 1;
   static const GLuint kQueriesStartId = 1;
   static const GLuint kVertexArraysStartId = 1;
 
   typedef MockTransferBuffer::ExpectedMemoryInfo ExpectedMemoryInfo;
 
   class TestContext {
    public:
     TestContext() : commands_(NULL), token_(0) {}
 
-    void Initialize(ShareGroup* share_group, bool bind_generates_resource) {
+    void Initialize(ShareGroup* share_group,
+                    bool bind_generates_resource,
+                    bool lose_context_when_out_of_memory) {
       command_buffer_.reset(new StrictMock<MockClientCommandBuffer>());
       ASSERT_TRUE(command_buffer_->Initialize());
 
       transfer_buffer_.reset(
           new MockTransferBuffer(command_buffer_.get(),
                                  kTransferBufferSize,
                                  GLES2Implementation::kStartingOffset,
                                  GLES2Implementation::kAlignment));
 
       helper_.reset(new GLES2CmdHelper(command_buffer()));
@@ skipping 28 matching lines @@
           sizeof(cmds::GetShaderPrecisionFormat::Result) * 12);
 
       {
         InSequence sequence;
 
         EXPECT_CALL(*command_buffer_, OnFlush())
             .WillOnce(SetMemory(mem1.ptr + sizeof(int_state), int_state))
             .RetiresOnSaturation();
         GetNextToken();  // eat the token that starting up will use.
 
-        gl_.reset(
-            new GLES2Implementation(helper_.get(),
-                                    share_group,
-                                    transfer_buffer_.get(),
-                                    bind_generates_resource,
-                                    gpu_control_.get()));
+        gl_.reset(new GLES2Implementation(helper_.get(),
+                                          share_group,
+                                          transfer_buffer_.get(),
+                                          bind_generates_resource,
+                                          lose_context_when_out_of_memory,
+                                          gpu_control_.get()));
         ASSERT_TRUE(gl_->Initialize(kTransferBufferSize,
                                     kTransferBufferSize,
                                     kTransferBufferSize,
                                     GLES2Implementation::kNoLimit));
       }
 
       EXPECT_CALL(*command_buffer_, OnFlush()).Times(1).RetiresOnSaturation();
       helper_->CommandBufferHelper::Finish();
       ::testing::Mock::VerifyAndClearExpectations(gl_.get());
 
@@ skipping 49 matching lines @@
         return false;
       }
     }
     return true;
   }
 
   QueryTracker::Query* GetQuery(GLuint id) {
     return gl_->query_tracker_->GetQuery(id);
   }
 
-  void Initialize(bool bind_generates_resource) {
+  void Initialize(bool bind_generates_resource,
+                  bool lose_context_when_out_of_memory) {
     share_group_ = new ShareGroup(bind_generates_resource);
 
     for (int i = 0; i < kNumTestContexts; i++)
-      test_contexts_[i].Initialize(share_group_.get(), bind_generates_resource);
+      test_contexts_[i].Initialize(share_group_.get(),
+                                   bind_generates_resource,
+                                   lose_context_when_out_of_memory);
 
     // Default to test context 0.
     gpu_control_ = test_contexts_[0].gpu_control_.get();
     helper_ = test_contexts_[0].helper_.get();
     transfer_buffer_ = test_contexts_[0].transfer_buffer_.get();
     gl_ = test_contexts_[0].gl_.get();
     commands_ = test_contexts_[0].commands_;
   }
 
   MockClientCommandBuffer* command_buffer() const {
@@ skipping 46 matching lines @@
 
   scoped_refptr<ShareGroup> share_group_;
   MockClientGpuControl* gpu_control_;
   GLES2CmdHelper* helper_;
   MockTransferBuffer* transfer_buffer_;
   GLES2Implementation* gl_;
   CommandBufferEntry* commands_;
 };
 
 void GLES2ImplementationTest::SetUp() {
-  Initialize(true);
+  bool bind_generates_resource = true;
+  bool lose_context_when_out_of_memory = false;
+  Initialize(bind_generates_resource, lose_context_when_out_of_memory);
 }
 
 void GLES2ImplementationTest::TearDown() {
   for (int i = 0; i < kNumTestContexts; i++)
     test_contexts_[i].TearDown();
 }
 
+class GLES2ImplementationManualInitTest : public GLES2ImplementationTest {
+ protected:
+  virtual void SetUp() OVERRIDE {}
+};
+
 class GLES2ImplementationStrictSharedTest : public GLES2ImplementationTest {
  protected:
   virtual void SetUp() OVERRIDE;
 
   template <class ResApi>
   void FlushGenerationTest() {
     GLuint id1, id2, id3;
 
     // Generate valid id.
     ResApi::Gen(gl_, 1, &id1);
@@ skipping 70 matching lines @@
     EXPECT_NE(id1, id3);
 
     // Lazy release triggered by another Delete.  Should reuse id1.
     ResApi::Delete(gl1, 1, &id2);
     ResApi::Gen(gl2, 1, &id3);
     EXPECT_EQ(id1, id3);
   }
 };
 
 void GLES2ImplementationStrictSharedTest::SetUp() {
-  Initialize(false);
+  bool bind_generates_resource = false;
+  bool lose_context_when_out_of_memory = false;
+  Initialize(bind_generates_resource, lose_context_when_out_of_memory);
 }
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
 const uint8 GLES2ImplementationTest::kInitialValue;
 const int32 GLES2ImplementationTest::kNumCommandEntries;
 const int32 GLES2ImplementationTest::kCommandBufferSizeBytes;
 const size_t GLES2ImplementationTest::kTransferBufferSize;
 const GLint GLES2ImplementationTest::kMaxCombinedTextureImageUnits;
 const GLint GLES2ImplementationTest::kMaxCubeMapTextureSize;
@@ skipping 2396 matching lines @@
     GLbyte data[64];
   };
 
   Mailbox mailbox = Mailbox::Generate();
   Cmds expected;
   expected.cmd.Init(GL_TEXTURE_2D, mailbox.name);
   gl_->ProduceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
+TEST_F(GLES2ImplementationManualInitTest, LoseContextOnOOM) {
+  bool bind_generates_resource = false;
+  bool lose_context_when_out_of_memory = true;
+  Initialize(bind_generates_resource, lose_context_when_out_of_memory);
+
+  struct Cmds {
+    cmds::LoseContextCHROMIUM cmd;
+  };
+
+  GLsizei max = std::numeric_limits<GLsizei>::max();
+  EXPECT_CALL(*gpu_control_, CreateGpuMemoryBuffer(max, max, _, _))
+      .WillOnce(Return(static_cast<gfx::GpuMemoryBuffer*>(NULL)));
+  gl_->CreateImageCHROMIUM(max, max, 0);
+  // The context should be lost.
+  Cmds expected;
+  expected.cmd.Init(GL_GUILTY_CONTEXT_RESET_ARB, GL_UNKNOWN_CONTEXT_RESET_ARB);
+  EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+}
+
+TEST_F(GLES2ImplementationManualInitTest, NoLoseContextOnOOM) {
+  bool bind_generates_resource = false;
+  bool lose_context_when_out_of_memory = false;
+  Initialize(bind_generates_resource, lose_context_when_out_of_memory);
+
+  struct Cmds {
+    cmds::LoseContextCHROMIUM cmd;
+  };
+
+  GLsizei max = std::numeric_limits<GLsizei>::max();
+  EXPECT_CALL(*gpu_control_, CreateGpuMemoryBuffer(max, max, _, _))
+      .WillOnce(Return(static_cast<gfx::GpuMemoryBuffer*>(NULL)));
+  gl_->CreateImageCHROMIUM(max, max, 0);
+  // The context should not be lost.
+  EXPECT_TRUE(NoCommandsWritten());
+}
+
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu