Introduce gpu_fuzzer to fuzz the GPU command buffers

gpu/command_buffer/service/command_buffer_service.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/command_buffer_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 120 matching lines @@
   UpdateState();
 }
 
 void CommandBufferService::SetGetOffset(int32_t get_offset) {
   DCHECK(get_offset >= 0 && get_offset < num_entries_);
   get_offset_ = get_offset;
 }
 
 scoped_refptr<Buffer> CommandBufferService::CreateTransferBuffer(size_t size,
                                                                  int32_t* id) {
-  *id = -1;
   static int32_t next_id = 1;
   *id = next_id++;
-
-  if (!RegisterTransferBuffer(*id,
-                              base::MakeUnique<MemoryBufferBacking>(size))) {
-    if (error_ == error::kNoError)
-      error_ = gpu::error::kOutOfBounds;
+  auto result = CreateTransferBufferWithId(size, *id);
+  if (!result)
     *id = -1;
-    return NULL;
-  }
-
-  return GetTransferBuffer(*id);
+  return result;
 }
 
 void CommandBufferService::DestroyTransferBuffer(int32_t id) {
   transfer_buffer_manager_->DestroyTransferBuffer(id);
   if (id == ring_buffer_id_) {
     ring_buffer_id_ = -1;
     ring_buffer_ = NULL;
     num_entries_ = 0;
     get_offset_ = 0;
     put_offset_ = 0;
   }
 }
 
 scoped_refptr<Buffer> CommandBufferService::GetTransferBuffer(int32_t id) {
   return transfer_buffer_manager_->GetTransferBuffer(id);
 }
 
 bool CommandBufferService::RegisterTransferBuffer(
     int32_t id,
     std::unique_ptr<BufferBacking> buffer) {
   return transfer_buffer_manager_->RegisterTransferBuffer(id,
                                                           std::move(buffer));
 }
 
+scoped_refptr<Buffer> CommandBufferService::CreateTransferBufferWithId(
+    size_t size,
+    int32_t id) {
+  if (!RegisterTransferBuffer(id,
+                              base::MakeUnique<MemoryBufferBacking>(size))) {
+    if (error_ == error::kNoError)
+      error_ = gpu::error::kOutOfBounds;
+    return NULL;
+  }
+
+  return GetTransferBuffer(id);
+}
+
+
 void CommandBufferService::SetToken(int32_t token) {
   token_ = token;
   UpdateState();
 }
 
 void CommandBufferService::SetParseError(error::Error error) {
   if (error_ == error::kNoError) {
     error_ = error;
     if (!parse_error_callback_.is_null())
       parse_error_callback_.Run();
@@ skipping 18 matching lines @@
     const GetBufferChangedCallback& callback) {
   get_buffer_change_callback_ = callback;
 }
 
 void CommandBufferService::SetParseErrorCallback(
     const base::Closure& callback) {
   parse_error_callback_ = callback;
 }
 
 }  // namespace gpu