Add gpu_angle_passthrough_fuzzer.

gpu/command_buffer/tests/fuzzer_main.cc

 // Copyright 2016 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
+#include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "gpu/command_buffer/service/mailbox_manager_impl.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_context_egl.h"
 #include "ui/gl/gl_context_stub.h"
 #include "ui/gl/gl_image_ref_counted_memory.h"
 #include "ui/gl/gl_share_group.h"
@@ skipping 54 matching lines @@
   CommandBufferSetup()
       : atexit_manager_(),
         sync_point_manager_(new SyncPointManager()),
         sync_point_order_data_(SyncPointOrderData::Create()),
         mailbox_manager_(new gles2::MailboxManagerImpl),
         share_group_(new gl::GLShareGroup),
         command_buffer_id_(CommandBufferId::FromUnsafeValue(1)) {
     logging::SetMinLogLevel(logging::LOG_FATAL);
     base::CommandLine::Init(0, NULL);
 
+    auto* command_line = base::CommandLine::ForCurrentProcess();
+    ALLOW_UNUSED_LOCAL(command_line);
+
+#if defined(GPU_FUZZER_USE_PASSTHROUGH_CMD_DECODER)
+    command_line->AppendSwitch(switches::kUsePassthroughCmdDecoder);
+    gpu_preferences_.use_passthrough_cmd_decoder = true;
+    recreate_context_ = true;
+#endif
+
 #if defined(GPU_FUZZER_USE_ANGLE)
-    auto* command_line = base::CommandLine::ForCurrentProcess();
     command_line->AppendSwitchASCII(switches::kUseGL,
                                     gl::kGLImplementationANGLEName);
     command_line->AppendSwitchASCII(switches::kUseANGLE,
                                     gl::kANGLEImplementationNullName);
     gl::init::InitializeGLOneOffImplementation(gl::kGLImplementationEGLGLES2,
                                                false, false, false);
+
     surface_ = new gl::PbufferGLSurfaceEGL(gfx::Size());
     surface_->Initialize();
-
-    context_ = new gl::GLContextEGL(share_group_.get());
-    context_->Initialize(surface_.get(), gl::GLContextAttribs());
+    if (!recreate_context_) {
+      InitContext();
+    }
 #else
     surface_ = new gl::GLSurfaceStub;
-    scoped_refptr<gl::GLContextStub> context_stub =
-        new gl::GLContextStub(share_group_.get());
-    context_stub->SetGLVersionString("OpenGL ES 3.1");
-    context_stub->SetExtensionsString(kExtensions);
-    context_stub->SetUseStubApi(true);
-    context_ = context_stub;
+    InitContext();
     gl::GLSurfaceTestSupport::InitializeOneOffWithMockBindings();
 #endif
 
     sync_point_client_ = base::MakeUnique<SyncPointClient>(
         sync_point_manager_.get(), sync_point_order_data_,
         CommandBufferNamespace::IN_PROCESS, command_buffer_id_);
 
     translator_cache_ = new gles2::ShaderTranslatorCache(gpu_preferences_);
     completeness_cache_ = new gles2::FramebufferCompletenessCache;
   }
 
   void InitDecoder() {
+    if (recreate_context_) {
+      InitContext();
+    }
+
     context_->MakeCurrent(surface_.get());
     scoped_refptr<gles2::FeatureInfo> feature_info =
         new gles2::FeatureInfo();
     scoped_refptr<gles2::ContextGroup> context_group = new gles2::ContextGroup(
         gpu_preferences_, mailbox_manager_.get(), nullptr, translator_cache_,
         completeness_cache_, feature_info, true /* bind_generates_resource */,
         nullptr /* image_factory */, nullptr /* progress_reporter */,
         GpuFeatureInfo());
     command_buffer_.reset(
         new CommandBufferService(context_group->transfer_buffer_manager()));
@@ skipping 32 matching lines @@
     if (!vertex_translator_) {
       // Keep a reference to the translators, which keeps them in the cache even
       // after the decoder is reset. They are expensive to initialize, but they
       // don't keep state.
       vertex_translator_ = decoder_->GetTranslator(GL_VERTEX_SHADER);
       fragment_translator_ = decoder_->GetTranslator(GL_FRAGMENT_SHADER);
     }
   }
 
   void ResetDecoder() {
+    if (recreate_context_) {
+      context_->ReleaseCurrent(nullptr);
+      context_ = nullptr;
+    }
     decoder_->Destroy(true);
     decoder_.reset();
     command_buffer_.reset();
   }
 
   ~CommandBufferSetup() {
     sync_point_client_ = nullptr;
     if (sync_point_order_data_) {
       sync_point_order_data_->Destroy();
       sync_point_order_data_ = nullptr;
@@ skipping 68 matching lines @@
     CHECK(buffer_);
     // Create some transfer buffers. This is somewhat arbitrary, but having a
     // reasonably sized buffer in slot 4 allows us to prime the corpus with data
     // extracted from unit tests.
     CreateTransferBuffer(kTransferBufferSize, 2);
     CreateTransferBuffer(kSmallTransferBufferSize, 3);
     CreateTransferBuffer(kTransferBufferSize, 4);
     CreateTransferBuffer(kTinyTransferBufferSize, 5);
   }
 
+  void InitContext() {
+#if defined(GPU_FUZZER_USE_ANGLE)
+    context_ = new gl::GLContextEGL(share_group_.get());
+    context_->Initialize(surface_.get(), gl::GLContextAttribs());
+#else
+    surface_ = new gl::GLSurfaceStub;

[piman, 2017/03/16 18:14:33]

nit: do we need to recreate the surface too? We don't in the other case. I don't
think the stub one keeps any useful state, so I think we can just leave this
out.

[Geoff Lang, 2017/03/16 19:43:03]

Whoops, yes, that should not be re-created.  Fixed.

+    scoped_refptr<gl::GLContextStub> context_stub =
+        new gl::GLContextStub(share_group_.get());
+    context_stub->SetGLVersionString("OpenGL ES 3.1");
+    context_stub->SetExtensionsString(kExtensions);
+    context_stub->SetUseStubApi(true);
+    context_ = context_stub;
+#endif
+  }
+
   base::AtExitManager atexit_manager_;
 
   GpuPreferences gpu_preferences_;
 
   std::unique_ptr<SyncPointManager> sync_point_manager_;
   scoped_refptr<SyncPointOrderData> sync_point_order_data_;
   std::unique_ptr<SyncPointClient> sync_point_client_;
   scoped_refptr<gles2::MailboxManager> mailbox_manager_;
   scoped_refptr<gl::GLShareGroup> share_group_;
   const gpu::CommandBufferId command_buffer_id_;
 
+  bool recreate_context_ = false;
   scoped_refptr<gl::GLSurface> surface_;
   scoped_refptr<gl::GLContext> context_;
 
   scoped_refptr<gles2::ShaderTranslatorCache> translator_cache_;
   scoped_refptr<gles2::FramebufferCompletenessCache> completeness_cache_;
 
   std::unique_ptr<CommandBufferService> command_buffer_;
 
   std::unique_ptr<gles2::GLES2Decoder> decoder_;
   std::unique_ptr<CommandExecutor> executor_;
@@ skipping 12 matching lines @@
 // registered, causing crashes.
 CommandBufferSetup* g_setup = new CommandBufferSetup();
 
 }  // anonymous namespace
 }  // namespace gpu
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   gpu::g_setup->RunCommandBuffer(data, size);
   return 0;
 }