Update from https://crrev.com/305340

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>
 
@@ skipping 75 matching lines @@
   struct ExpectedMemoryInfo {
     uint32 offset;
     int32 id;
     uint8* ptr;
   };
 
   MockTransferBuffer(
       CommandBuffer* command_buffer,
       unsigned int size,
       unsigned int result_size,
-      unsigned int alignment)
+      unsigned int alignment,
+      bool initialize_fail)
       : command_buffer_(command_buffer),
         size_(size),
         result_size_(result_size),
         alignment_(alignment),
         actual_buffer_index_(0),
         expected_buffer_index_(0),
         last_alloc_(NULL),
         expected_offset_(result_size),
-        actual_offset_(result_size) {
+        actual_offset_(result_size),
+        initialize_fail_(initialize_fail) {
     // We have to allocate the buffers here because
     // we need to know their address before GLES2Implementation::Initialize
     // is called.
     for (int ii = 0; ii < kNumBuffers; ++ii) {
       buffers_[ii] = command_buffer_->CreateTransferBuffer(
           size_ + ii * alignment_,
           &buffer_ids_[ii]);
       EXPECT_NE(-1, buffer_ids_[ii]);
     }
   }
@@ skipping 97 matching lines @@
   size_t size_;
   size_t result_size_;
   uint32 alignment_;
   int buffer_ids_[kNumBuffers];
   scoped_refptr<Buffer> buffers_[kNumBuffers];
   int actual_buffer_index_;
   int expected_buffer_index_;
   void* last_alloc_;
   uint32 expected_offset_;
   uint32 actual_offset_;
+  bool initialize_fail_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTransferBuffer);
 };
 
 bool MockTransferBuffer::Initialize(
     unsigned int starting_buffer_size,
     unsigned int result_size,
     unsigned int /* min_buffer_size */,
     unsigned int /* max_buffer_size */,
     unsigned int alignment,
     unsigned int /* size_to_flush */) {
   // Just check they match.
   return size_ == starting_buffer_size &&
          result_size_ == result_size &&
-         alignment_ == alignment;
+         alignment_ == alignment && !initialize_fail_;
 };
 
 int MockTransferBuffer::GetShmId() {
   return buffer_ids_[actual_buffer_index_];
 }
 
 void* MockTransferBuffer::GetResultBuffer() {
   return actual_buffer() + actual_buffer_index_ * alignment_;
 }
 
@@ skipping 139 matching lines @@
 
   typedef MockTransferBuffer::ExpectedMemoryInfo ExpectedMemoryInfo;
 
   class TestContext {
    public:
     TestContext() : commands_(NULL), token_(0) {}
 
     bool Initialize(ShareGroup* share_group,
                     bool bind_generates_resource_client,
                     bool bind_generates_resource_service,
-                    bool lose_context_when_out_of_memory) {
+                    bool lose_context_when_out_of_memory,
+                    bool transfer_buffer_initialize_fail) {
       command_buffer_.reset(new StrictMock<MockClientCommandBuffer>());
       if (!command_buffer_->Initialize())
         return false;
 
       transfer_buffer_.reset(
           new MockTransferBuffer(command_buffer_.get(),
                                  kTransferBufferSize,
                                  GLES2Implementation::kStartingOffset,
-                                 GLES2Implementation::kAlignment));
+                                 GLES2Implementation::kAlignment,
+                                 transfer_buffer_initialize_fail));
 
       helper_.reset(new GLES2CmdHelper(command_buffer()));
       helper_->Initialize(kCommandBufferSizeBytes);
 
       gpu_control_.reset(new StrictMock<MockClientGpuControl>());
       Capabilities capabilities;
       capabilities.VisitPrecisions(
           [](GLenum shader, GLenum type,
              Capabilities::ShaderPrecision* precision) {
             precision->min_range = 3;
@@ skipping 98 matching lines @@
   }
 
   QueryTracker::Query* GetQuery(GLuint id) {
     return gl_->query_tracker_->GetQuery(id);
   }
 
   struct ContextInitOptions {
     ContextInitOptions()
         : bind_generates_resource_client(true),
           bind_generates_resource_service(true),
-          lose_context_when_out_of_memory(false) {}
+          lose_context_when_out_of_memory(false),
+          transfer_buffer_initialize_fail(false) {}
 
     bool bind_generates_resource_client;
     bool bind_generates_resource_service;
     bool lose_context_when_out_of_memory;
+    bool transfer_buffer_initialize_fail;
   };
 
   bool Initialize(const ContextInitOptions& init_options) {
     bool success = true;
     share_group_ = new ShareGroup(init_options.bind_generates_resource_client);
 
     for (int i = 0; i < kNumTestContexts; i++) {
       if (!test_contexts_[i].Initialize(
               share_group_.get(),
               init_options.bind_generates_resource_client,
               init_options.bind_generates_resource_service,
-              init_options.lose_context_when_out_of_memory))
+              init_options.lose_context_when_out_of_memory,
+              init_options.transfer_buffer_initialize_fail))
         success = false;
     }
 
     // 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_;
     return success;
@@ skipping 2743 matching lines @@
   EXPECT_FALSE(Initialize(init_options));
 }
 
 TEST_F(GLES2ImplementationManualInitTest, FailInitOnBGRMismatch2) {
   ContextInitOptions init_options;
   init_options.bind_generates_resource_client = true;
   init_options.bind_generates_resource_service = false;
   EXPECT_FALSE(Initialize(init_options));
 }
 
+TEST_F(GLES2ImplementationManualInitTest, FailInitOnTransferBufferFail) {
+  ContextInitOptions init_options;
+  init_options.transfer_buffer_initialize_fail = true;
+  EXPECT_FALSE(Initialize(init_options));
+}
+
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu