Remove WebGraphicsContext3D reason from the CauseForGpuLaunch enum

content/renderer/render_widget.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 "content/renderer/render_widget.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 697 matching lines @@
 
 #if defined(MOJO_SHELL_CLIENT)
   if (MojoShellConnection::Get() && !use_software &&
       command_line.HasSwitch(switches::kUseMusInRenderer)) {
     RenderWidgetMusConnection* connection =
         RenderWidgetMusConnection::GetOrCreate(routing_id());
     return connection->CreateOutputSurface();
   }
 #endif
 
+  uint32_t output_surface_id = next_output_surface_id_++;
+
+  if (command_line.HasSwitch(switches::kEnableVulkan)) {
+    scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider =
+        cc::VulkanInProcessContextProvider::Create();
+    if (vulkan_context_provider) {
+      return base::WrapUnique(new DelegatedCompositorOutputSurface(
+          routing_id(), output_surface_id, nullptr, nullptr,
+          vulkan_context_provider, frame_swap_message_queue_));
+    }
+  }
+
+  // Create a gpu process channel and verify we want to use GPU compositing
+  // before creating any context providers.
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host;
   if (!use_software) {
-    CauseForGpuLaunch cause =
-        CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
-    gpu_channel_host =
-        RenderThreadImpl::current()->EstablishGpuChannelSync(cause);
+    gpu_channel_host = RenderThreadImpl::current()->EstablishGpuChannelSync(
+        CAUSE_FOR_GPU_LAUNCH_RENDERER_VERIFY_GPU_COMPOSITING);
     if (!gpu_channel_host) {
       // Cause the compositor to wait and try again.
       return nullptr;
     }
     // We may get a valid channel, but with a software renderer. In that case,
     // disable GPU compositing.
     if (gpu_channel_host->gpu_info().software_rendering)
       use_software = true;
   }
 
-  scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider;
-  scoped_refptr<ContextProviderCommandBuffer> context_provider;
-  scoped_refptr<ContextProviderCommandBuffer> worker_context_provider;
-  if (!use_software) {
-    if (command_line.HasSwitch(switches::kEnableVulkan)) {
-      vulkan_context_provider = cc::VulkanInProcessContextProvider::Create();
-      if (vulkan_context_provider) {
-        uint32_t output_surface_id = next_output_surface_id_++;
-        return base::WrapUnique(new DelegatedCompositorOutputSurface(
-            routing_id(), output_surface_id, context_provider,
-            worker_context_provider, vulkan_context_provider,
-            frame_swap_message_queue_));
-      }
-    }
+  if (use_software) {

[danakj, 2016/05/04 01:16:01]

This branch didn't exist before, we'd skip down to the !layouttests branch way
at the bottom and do this.

Since layout tests cant be software, we can do this branch and early-out at the
top now.

+    return base::WrapUnique(new DelegatedCompositorOutputSurface(
+        routing_id(), output_surface_id, nullptr, nullptr, nullptr,
+        frame_swap_message_queue_));
+  }
 
-    gpu::SharedMemoryLimits limits;
-    // The renderer compositor context doesn't do a lot of stuff, so we don't
-    // expect it to need a lot of space for commands or transfer. Raster and
-    // uploads happen on the worker context instead.
-    limits.command_buffer_size = 64 * 1024;
-    limits.start_transfer_buffer_size = 64 * 1024;
-    limits.min_transfer_buffer_size = 64 * 1024;
+  scoped_refptr<ContextProviderCommandBuffer> worker_context_provider =
+      RenderThreadImpl::current()->SharedWorkerContextProvider();
+  if (!worker_context_provider) {
+    // Cause the compositor to wait and try again.
+    return nullptr;
+  }
 
-    worker_context_provider =
-        RenderThreadImpl::current()->SharedWorkerContextProvider();
-    if (!worker_context_provider) {
-      // Cause the compositor to wait and try again.
-      return nullptr;
-    }
+  gpu::SharedMemoryLimits limits;
+  // The renderer compositor context doesn't do a lot of stuff, so we don't
+  // expect it to need a lot of space for commands or transfer. Raster and
+  // uploads happen on the worker context instead.
+  limits.command_buffer_size = 64 * 1024;
+  limits.start_transfer_buffer_size = 64 * 1024;
+  limits.min_transfer_buffer_size = 64 * 1024;
 
-    // This is for an offscreen context for the compositor. So the default
-    // framebuffer doesn't need alpha, depth, stencil, antialiasing.
-    gpu::gles2::ContextCreationAttribHelper attributes;
-    attributes.alpha_size = -1;
-    attributes.depth_size = 0;
-    attributes.stencil_size = 0;
-    attributes.samples = 0;
-    attributes.sample_buffers = 0;
-    attributes.bind_generates_resource = false;
-    attributes.lose_context_when_out_of_memory = true;
+  // This is for an offscreen context for the compositor. So the default
+  // framebuffer doesn't need alpha, depth, stencil, antialiasing.
+  gpu::gles2::ContextCreationAttribHelper attributes;
+  attributes.alpha_size = -1;
+  attributes.depth_size = 0;
+  attributes.stencil_size = 0;
+  attributes.samples = 0;
+  attributes.sample_buffers = 0;
+  attributes.bind_generates_resource = false;
+  attributes.lose_context_when_out_of_memory = true;
 
-    bool automatic_flushes = false;
+  constexpr bool automatic_flushes = false;
 
-    // The compositor context shares resources with the worker context.
-    context_provider = new ContextProviderCommandBuffer(
-        std::move(gpu_channel_host), gpu::kNullSurfaceHandle,
-        GetURLForGraphicsContext3D(), gfx::PreferIntegratedGpu,
-        automatic_flushes, limits, attributes, worker_context_provider.get(),
-        command_buffer_metrics::RENDER_COMPOSITOR_CONTEXT);
+  // The compositor context shares resources with the worker context.
+  scoped_refptr<ContextProviderCommandBuffer> context_provider(
+      new ContextProviderCommandBuffer(
+          std::move(gpu_channel_host), gpu::kNullSurfaceHandle,
+          GetURLForGraphicsContext3D(), gfx::PreferIntegratedGpu,
+          automatic_flushes, limits, attributes, worker_context_provider.get(),
+          command_buffer_metrics::RENDER_COMPOSITOR_CONTEXT));
 
 #if defined(OS_ANDROID)
-    if (RenderThreadImpl::current() &&
-        RenderThreadImpl::current()->sync_compositor_message_filter()) {
-      uint32_t output_surface_id = next_output_surface_id_++;
-      return base::WrapUnique(new SynchronousCompositorOutputSurface(
-          context_provider, worker_context_provider, routing_id(),
-          output_surface_id,
-          RenderThreadImpl::current()->sync_compositor_message_filter(),
-          frame_swap_message_queue_));
-    }
+  if (RenderThreadImpl::current()->sync_compositor_message_filter()) {
+    return base::WrapUnique(new SynchronousCompositorOutputSurface(
+        context_provider, worker_context_provider, routing_id(),
+        output_surface_id,
+        RenderThreadImpl::current()->sync_compositor_message_filter(),
+        frame_swap_message_queue_));
+  }
 #endif
-  }
 
-  uint32_t output_surface_id = next_output_surface_id_++;
   // Composite-to-mailbox is currently used for layout tests in order to cause
   // them to draw inside in the renderer to do the readback there. This should
   // no longer be the case when crbug.com/311404 is fixed.
-  if (!RenderThreadImpl::current() ||
-      !RenderThreadImpl::current()->layout_test_mode()) {
-    DCHECK(compositor_deps_->GetCompositorImplThreadTaskRunner());
-    return base::WrapUnique(new DelegatedCompositorOutputSurface(
+  if (RenderThreadImpl::current()->layout_test_mode()) {
+    return base::WrapUnique(new MailboxOutputSurface(
         routing_id(), output_surface_id, std::move(context_provider),
-        std::move(worker_context_provider),
-        vulkan_context_provider,
-        frame_swap_message_queue_));
+        std::move(worker_context_provider), frame_swap_message_queue_,
+        cc::RGBA_8888));
   }
 
-  if (!context_provider) {

[danakj, 2016/05/04 01:16:01]

Turns out this branch is only for layout tests in software compositing, which
doesn't exist anymore, so I dropped it. That means nothing makes a
"CompositorOutputSurface" anymore.

-    std::unique_ptr<cc::SoftwareOutputDevice> software_device(
-        new cc::SoftwareOutputDevice());
-
-    return base::WrapUnique(new CompositorOutputSurface(
-        routing_id(), output_surface_id, nullptr, nullptr, nullptr,
-        std::move(software_device), frame_swap_message_queue_, true));
-  }
-
-  return base::WrapUnique(new MailboxOutputSurface(
+  return base::WrapUnique(new DelegatedCompositorOutputSurface(
       routing_id(), output_surface_id, std::move(context_provider),
-      std::move(worker_context_provider), frame_swap_message_queue_,
-      cc::RGBA_8888));
+      std::move(worker_context_provider), nullptr, frame_swap_message_queue_));
 }
 
 std::unique_ptr<cc::BeginFrameSource>
 RenderWidget::CreateExternalBeginFrameSource() {
   return compositor_deps_->CreateExternalBeginFrameSource(routing_id_);
 }
 
 void RenderWidget::DidCommitAndDrawCompositorFrame() {
   // NOTE: Tests may break if this event is renamed or moved. See
   // tab_capture_performancetest.cc.
@@ skipping 1259 matching lines @@
 }
 
 float RenderWidget::GetOriginalDeviceScaleFactor() const {
   return
       screen_metrics_emulator_ ?
       screen_metrics_emulator_->original_screen_info().deviceScaleFactor :
       device_scale_factor_;
 }
 
 }  // namespace content