Remove --no-use-mus-in-renderer

content/browser/compositor/gpu_process_transport_factory.cc

 // Copyright 2014 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/browser/compositor/gpu_process_transport_factory.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 44 matching lines @@
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_constants.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/switches.h"
 #include "ui/gl/gl_switches.h"
 
 #if defined(USE_AURA)
-#include "content/browser/compositor/mus_browser_compositor_output_surface.h"
 #include "content/public/common/service_manager_connection.h"
 #include "ui/aura/window_tree_host.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "components/display_compositor/compositor_overlay_candidate_validator_win.h"
 #include "content/browser/compositor/software_output_device_win.h"
 #include "ui/gfx/win/rendering_window_manager.h"
 #elif defined(USE_OZONE)
@@ skipping 27 matching lines @@
 using cc::ContextProvider;
 using gpu::gles2::GLES2Interface;
 
 namespace {
 
 const int kNumRetriesBeforeSoftwareFallback = 4;
 // The client_id used here should not conflict with the client_id generated
 // from RenderWidgetHostImpl.
 constexpr uint32_t kDefaultClientId = 0u;
 
-bool IsUsingMus() {
-  return service_manager::ServiceManagerIsRemote();
-}
-
 bool IsGpuVSyncSignalSupported() {
 #if defined(OS_WIN)
   // TODO(stanisc): http://crbug.com/467617 Limit to Windows 8+ for now because
   // of locking issue caused by waiting for VSync on Win7.
   return base::win::GetVersion() >= base::win::VERSION_WIN8 &&
          base::FeatureList::IsEnabled(features::kD3DVsync);
 #else
   return false;
 #endif  // defined(OS_WIN)
 }
@@ skipping 164 matching lines @@
 #endif
 
   return validator;
 }
 
 static bool ShouldCreateGpuCompositorFrameSink(ui::Compositor* compositor) {
 #if defined(OS_CHROMEOS)
   // Software fallback does not happen on Chrome OS.
   return true;
 #endif
-  if (IsUsingMus())
-    return true;
-
 #if defined(OS_WIN)
   if (::GetProp(compositor->widget(), kForceSoftwareCompositor) &&
       ::RemoveProp(compositor->widget(), kForceSoftwareCompositor))
     return false;
 #endif
 
   return GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor();
 }
 
 void GpuProcessTransportFactory::CreateCompositorFrameSink(
@@ skipping 40 matching lines @@
   // The widget might have been released in the meantime.
   PerCompositorDataMap::iterator it =
       per_compositor_data_.find(compositor.get());
   if (it == per_compositor_data_.end())
     return;
 
   PerCompositorData* data = it->second.get();
   DCHECK(data);
 
   if (num_attempts > kNumRetriesBeforeSoftwareFallback) {
-    bool fatal = IsUsingMus();
+    bool fatal = false;
 #if defined(OS_CHROMEOS)
     fatal = true;
 #endif
     LOG_IF(FATAL, fatal) << "Unable to create a UI graphics context, and "
                          << "cannot use software compositing on ChromeOS.";
     create_gpu_output_surface = false;
   }
 
   bool support_stencil = false;
 #if defined(OS_CHROMEOS)
@@ skipping 54 matching lines @@
       }
 
       // The |context_provider| is used for both the browser compositor and the
       // display compositor. It shares resources with the worker context, so if
       // we failed to make a worker context, just start over and try again.
       if (shared_worker_context_provider_) {
         // For mus, we create an offscreen context for a mus window, and we will
         // use CommandBufferProxyImpl::TakeFrontBuffer() to take the context's
         // front buffer into a mailbox, insert a sync token, and send the
         // mailbox+sync to the ui service process.
-        gpu::SurfaceHandle surface_handle =
-            IsUsingMus() ? gpu::kNullSurfaceHandle : data->surface_handle;
-        bool need_alpha_channel = IsUsingMus();
+        gpu::SurfaceHandle surface_handle = data->surface_handle;
+        bool need_alpha_channel = false;
         bool support_locking = false;
         context_provider = CreateContextCommon(
             std::move(gpu_channel_host), surface_handle, need_alpha_channel,
             support_stencil, support_locking,
             shared_worker_context_provider_.get(),
             ui::command_buffer_metrics::DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
         // TODO(vadimt): Remove ScopedTracker below once crbug.com/125248 is
         // fixed. Tracking time in BindToCurrentThread.
         tracked_objects::ScopedTracker tracking_profile(
             FROM_HERE_WITH_EXPLICIT_FUNCTION(
@@ skipping 78 matching lines @@
                 CreateOverlayCandidateValidator(compositor->widget()),
                 GL_TEXTURE_2D, GL_RGB,
                 display::DisplaySnapshot::PrimaryFormat(),
                 GetGpuMemoryBufferManager());
         gpu_vsync_control = gpu_output_surface.get();
         display_output_surface = std::move(gpu_output_surface);
 #endif
       } else {
         std::unique_ptr<display_compositor::CompositorOverlayCandidateValidator>
             validator;
-        const bool use_mus = IsUsingMus();
 #if !defined(OS_MACOSX)
         // Overlays are only supported on surfaceless output surfaces on Mac.
-        if (!use_mus)
-          validator = CreateOverlayCandidateValidator(compositor->widget());
+        validator = CreateOverlayCandidateValidator(compositor->widget());
 #endif
-        if (!use_mus) {
-          auto gpu_output_surface =
-              base::MakeUnique<GpuBrowserCompositorOutputSurface>(
-                  context_provider, vsync_callback, std::move(validator));
-          gpu_vsync_control = gpu_output_surface.get();
-          display_output_surface = std::move(gpu_output_surface);
-        } else {
-#if defined(USE_AURA)
-          aura::WindowTreeHost* host =
-              aura::WindowTreeHost::GetForAcceleratedWidget(
-                  compositor->widget());
-          auto mus_output_surface =
-              base::MakeUnique<MusBrowserCompositorOutputSurface>(
-                  host->window(), context_provider, GetGpuMemoryBufferManager(),
-                  vsync_callback, std::move(validator));
-          // We use the ExternalBeginFrameSource provided by the output surface
-          // instead of our own synthetic one.
-          begin_frame_source = mus_output_surface->GetBeginFrameSource();

[stanisc, 2017/03/28 18:14:23]

Now that this line of code is removed it doesn't make sense to declare
begin_frame_source further above.

-          DCHECK(begin_frame_source);
-          display_output_surface = std::move(mus_output_surface);
-#else
-          NOTREACHED();
-#endif
-        }
+        auto gpu_output_surface =
+            base::MakeUnique<GpuBrowserCompositorOutputSurface>(
+                context_provider, vsync_callback, std::move(validator));
+        gpu_vsync_control = gpu_output_surface.get();
+        display_output_surface = std::move(gpu_output_surface);
       }
     }
   }
 
   std::unique_ptr<cc::SyntheticBeginFrameSource> synthetic_begin_frame_source;
   std::unique_ptr<GpuVSyncBeginFrameSource> gpu_vsync_begin_frame_source;
 
   if (!begin_frame_source) {

[stanisc, 2017/03/28 18:14:23]

With the mus case removed above begin_frame_source will always be nullptr, so
this condition isn't needed anymore. I also recommend moving begin_frame_source
declaration here.

     if (!compositor->GetRendererSettings().disable_display_vsync) {
       if (gpu_vsync_control && IsGpuVSyncSignalSupported()) {
         gpu_vsync_begin_frame_source =
             base::MakeUnique<GpuVSyncBeginFrameSource>(gpu_vsync_control);
         begin_frame_source = gpu_vsync_begin_frame_source.get();
       } else {
         synthetic_begin_frame_source =
             base::MakeUnique<cc::DelayBasedBeginFrameSource>(
                 base::MakeUnique<cc::DelayBasedTimeSource>(
                     compositor->task_runner().get()));
@@ skipping 364 matching lines @@
       shared_vulkan_context_provider_ =
           cc::VulkanInProcessContextProvider::Create();
     }
 
     shared_vulkan_context_provider_initialized_ = true;
   }
   return shared_vulkan_context_provider_;
 }
 
 }  // namespace content