X11 and Ozone: //components: choose code path with IsUsingOzonePlatform

This patch adds for usage of ozone platform in //components.
And changes the following patterns:

#ifdef(USE_X11)
DoXxx();
#endif

to

#ifdef(USE_X11)
if (!IsUsingOzonePlatform())
  DoXxx();
#endif

and

#ifdef(USE_OZONE)
DoXxx();
#endif

to

#ifdef(USE_OZONE)
if (IsUsingOzonePlatform())
  DoXxx();
#endif

-----

Please note that this ugliness is added temporarily and
will be removed as soon as use_x11 is removed (hopefully
by Q1 2021 depending on how the finch trial goes).

Please also note that it's impossible to build use_x11 && use_ozone
without some hacks in PlatformCursor code. The changes to that are
on their way to upstream.

----

Bug: 1085700
Change-Id: Icce90019c12db275a796dcab993abffa158023af
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2250006
Commit-Queue: Maksim Sisov <msisov@igalia.com>
Reviewed-by: Thomas Anderson <thomasanderson@chromium.org>
Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
Cr-Commit-Position: refs/heads/master@{#781766}

components/dbus/menu/menu_property_list.cc

@@ -16,6 +16,7 @@
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 
+#include "ui/base/ui_base_features.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"  // nogncheck
 #endif
 
@@ -56,10 +57,12 @@ MenuItemProperties ComputeMenuPropertiesForMenuItem(ui::MenuModel* menu,
     if (accelerator.IsCmdDown())
       parts.push_back(DbusString("Super"));
 #if defined(USE_X11)
-    parts.push_back(DbusString(XKeysymToString(
-        XKeysymForWindowsKeyCode(accelerator.key_code(), false))));
-    properties["shortcut"] =
-        MakeDbusVariant(MakeDbusArray(DbusArray<DbusString>(std::move(parts))));
+    if (!features::IsUsingOzonePlatform()) {
+      parts.push_back(DbusString(XKeysymToString(
+          XKeysymForWindowsKeyCode(accelerator.key_code(), false))));
+      properties["shortcut"] = MakeDbusVariant(
+          MakeDbusArray(DbusArray<DbusString>(std::move(parts))));
+    }
 #else
     NOTIMPLEMENTED();
 #endif

components/viz/demo/demo_main.cc

@@ -34,6 +34,7 @@
 #endif
 
 #if defined(USE_X11)
+#include "ui/base/ui_base_features.h"           // nogncheck
 #include "ui/platform_window/x11/x11_window.h"  // nogncheck
 #endif
 
@@ -84,7 +85,8 @@ class InitUI {
  public:
   InitUI() {
 #if defined(USE_X11)
-    XInitThreads();
+    if (!features::IsUsingOzonePlatform())
+      XInitThreads();
 #endif
     event_source_ = ui::PlatformEventSource::CreateDefault();
   }

components/viz/host/BUILD.gn

@@ -95,6 +95,10 @@ viz_source_set("unit_tests") {
   if (use_ozone) {
     deps += [ "//ui/ozone" ]
   }
+
+  if (use_x11 || use_ozone) {
+    deps += [ "//ui/base:features" ]
+  }
 }
 
 fuzzer_test("hit_test_query_fuzzer") {

components/viz/host/gpu_host_impl.cc

@@ -36,6 +36,10 @@
 #include "ui/gfx/win/rendering_window_manager.h"
 #endif
 
+#if defined(USE_OZONE)
+#include "ui/base/ui_base_features.h"
+#endif
+
 namespace viz {
 namespace {
 
@@ -125,7 +129,8 @@ GpuHostImpl::GpuHostImpl(Delegate* delegate,
                               GetFontRenderParams().Get()->subpixel_rendering);
 
 #if defined(USE_OZONE)
-  InitOzone();
+  if (features::IsUsingOzonePlatform())
+    InitOzone();
 #endif  // defined(USE_OZONE)
 }
 
@@ -294,6 +299,7 @@ mojom::InfoCollectionGpuService* GpuHostImpl::info_collection_gpu_service() {
 #if defined(USE_OZONE)
 
 void GpuHostImpl::InitOzone() {
+  DCHECK(features::IsUsingOzonePlatform());
   // Ozone needs to send the primary DRM device to GPU service as early as
   // possible to ensure the latter always has a valid device.
   // https://crbug.com/608839

components/viz/host/host_gpu_memory_buffer_manager.cc

@@ -15,6 +15,7 @@
 #include "gpu/ipc/common/gpu_memory_buffer_impl_shared_memory.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
 #include "services/viz/privileged/mojom/gl/gpu_service.mojom.h"
+#include "ui/base/ui_base_features.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/buffer_usage_util.h"
 
@@ -46,11 +47,15 @@ HostGpuMemoryBufferManager::HostGpuMemoryBufferManager(
       client_id_(client_id),
       gpu_memory_buffer_support_(std::move(gpu_memory_buffer_support)),
       task_runner_(std::move(task_runner)) {
-#if !defined(USE_X11)
-  native_configurations_ = gpu::GetNativeGpuMemoryBufferConfigurations(
-      gpu_memory_buffer_support_.get());
-  native_configurations_initialized_.Signal();
+  bool should_get_native_configs = true;
+#if defined(USE_X11)
+  should_get_native_configs = features::IsUsingOzonePlatform();
 #endif
+  if (should_get_native_configs) {
+    native_configurations_ = gpu::GetNativeGpuMemoryBufferConfigurations(
+        gpu_memory_buffer_support_.get());
+    native_configurations_initialized_.Signal();
+  }
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, "HostGpuMemoryBufferManager", task_runner_);
 }

components/viz/host/host_gpu_memory_buffer_manager_unittest.cc

@@ -19,6 +19,10 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/client_native_pixmap_factory.h"
 
+#if defined(USE_OZONE) || defined(USE_X11)
+#include "ui/base/ui_base_features.h"  // nogncheck
+#endif
+
 #if defined(USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #endif
@@ -229,7 +233,8 @@ class HostGpuMemoryBufferManagerTest : public ::testing::Test {
         base::ThreadTaskRunnerHandle::Get());
 #if defined(USE_X11)
     // X11 requires GPU process initialization to determine GMB support.
-    gpu_memory_buffer_manager_->native_configurations_initialized_.Signal();
+    if (!features::IsUsingOzonePlatform())
+      gpu_memory_buffer_manager_->native_configurations_initialized_.Signal();
 #endif
   }
 
@@ -238,9 +243,11 @@ class HostGpuMemoryBufferManagerTest : public ::testing::Test {
   bool IsNativePixmapConfigSupported() {
     bool native_pixmap_supported = false;
 #if defined(USE_OZONE)
-    native_pixmap_supported =
-        ui::OzonePlatform::GetInstance()->IsNativePixmapConfigSupported(
-            gfx::BufferFormat::RGBA_8888, gfx::BufferUsage::GPU_READ);
+    if (features::IsUsingOzonePlatform()) {
+      native_pixmap_supported =
+          ui::OzonePlatform::GetInstance()->IsNativePixmapConfigSupported(
+              gfx::BufferFormat::RGBA_8888, gfx::BufferUsage::GPU_READ);
+    }
 #elif defined(OS_ANDROID)
     native_pixmap_supported =
         base::AndroidHardwareBufferCompat::IsSupportAvailable();

components/viz/host/renderer_settings_creation.cc

@@ -20,6 +20,7 @@
 #endif
 
 #if defined(USE_OZONE)
+#include "ui/base/ui_base_features.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
@@ -86,16 +87,18 @@ RendererSettings CreateRendererSettings() {
   }
 
 #if defined(USE_OZONE)
-  if (command_line->HasSwitch(switches::kEnableHardwareOverlays)) {
-    renderer_settings.overlay_strategies = ParseOverlayStrategies(
-        command_line->GetSwitchValueASCII(switches::kEnableHardwareOverlays));
-  } else {
-    auto& host_properties =
-        ui::OzonePlatform::GetInstance()->GetInitializedHostProperties();
-    if (host_properties.supports_overlays) {
-      renderer_settings.overlay_strategies = {OverlayStrategy::kFullscreen,
-                                              OverlayStrategy::kSingleOnTop,
-                                              OverlayStrategy::kUnderlay};
+  if (features::IsUsingOzonePlatform()) {
+    if (command_line->HasSwitch(switches::kEnableHardwareOverlays)) {
+      renderer_settings.overlay_strategies = ParseOverlayStrategies(
+          command_line->GetSwitchValueASCII(switches::kEnableHardwareOverlays));
+    } else {
+      auto& host_properties =
+          ui::OzonePlatform::GetInstance()->GetInitializedHostProperties();
+      if (host_properties.supports_overlays) {
+        renderer_settings.overlay_strategies = {OverlayStrategy::kFullscreen,
+                                                OverlayStrategy::kSingleOnTop,
+                                                OverlayStrategy::kUnderlay};
+      }
     }
   }
 #endif

components/viz/service/display/gl_renderer.cc

@@ -83,6 +83,10 @@
 #include "ui/gfx/rrect_f.h"
 #include "ui/gfx/skia_util.h"
 
+#if defined(USE_X11)
+#include "ui/base/ui_base_features.h"
+#endif
+
 using gpu::gles2::GLES2Interface;
 
 namespace viz {
@@ -2826,7 +2830,12 @@ void GLRenderer::FinishDrawingFrame() {
   ScheduleOutputSurfaceAsOverlay();
 
 #if defined(OS_ANDROID) || defined(USE_OZONE)
-  ScheduleOverlays();
+  bool schedule_overlays = true;
+#if defined(USE_X11)
+  schedule_overlays = features::IsUsingOzonePlatform();
+#endif
+  if (schedule_overlays)
+    ScheduleOverlays();
 #elif defined(OS_MACOSX)
   ScheduleCALayers();
 #elif defined(OS_WIN)

components/viz/service/display/overlay_processor_interface.cc

@@ -8,6 +8,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "components/viz/common/display/renderer_settings.h"
 #include "components/viz/common/features.h"
+#include "components/viz/service/display/overlay_processor_stub.h"
 
 #if defined(OS_MACOSX)
 #include "components/viz/service/display/overlay_processor_mac.h"
@@ -18,10 +19,9 @@
 #include "components/viz/service/display/overlay_processor_surface_control.h"
 #elif defined(USE_OZONE)
 #include "components/viz/service/display/overlay_processor_ozone.h"
+#include "ui/base/ui_base_features.h"
 #include "ui/ozone/public/overlay_manager_ozone.h"
 #include "ui/ozone/public/ozone_platform.h"
-#else
-#include "components/viz/service/display/overlay_processor_stub.h"
 #endif
 
 namespace viz {
@@ -98,6 +98,8 @@ OverlayProcessorInterface::CreateOverlayProcessor(
       enable_dc_overlay,
       std::make_unique<DCLayerOverlayProcessor>(renderer_settings)));
 #elif defined(USE_OZONE)
+  if (!features::IsUsingOzonePlatform())
+    return std::make_unique<OverlayProcessorStub>();
   bool overlay_enabled = surface_handle != gpu::kNullSurfaceHandle;
   overlay_enabled &= !renderer_settings.overlay_strategies.empty();
   std::unique_ptr<ui::OverlayCandidatesOzone> overlay_candidates;

components/viz/service/display/skia_renderer.cc

@@ -64,6 +64,10 @@
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
+#if defined(USE_OZONE)
+#include "ui/base/ui_base_features.h"
+#endif
+
 namespace viz {
 
 namespace {
@@ -2207,10 +2211,19 @@ void SkiaRenderer::ScheduleOverlays() {
   skia_output_surface_->ScheduleOverlays(
       std::move(current_frame()->overlay_list), std::move(sync_tokens));
 #elif defined(USE_OZONE)
+  // For platforms that don't support overlays, the
+  // current_frame()->overlay_list should be empty, and this code should not be
+  // reached.
+  if (!features::IsUsingOzonePlatform()) {
+    NOTREACHED();
+    return;
+  }
+
   NOTIMPLEMENTED_LOG_ONCE();
 #else
-  // For platforms doesn't support overlays, the current_frame()->overlay_list
-  // should be empty, and here should not be reached.
+  // For platforms that don't support overlays, the
+  // current_frame()->overlay_list should be empty, and this code should not be
+  // reached.
   NOTREACHED();
 #endif
 }

components/viz/service/display_embedder/output_surface_provider_impl.cc

@@ -57,6 +57,7 @@
 
 #if defined(USE_OZONE)
 #include "components/viz/service/display_embedder/software_output_device_ozone.h"
+#include "ui/base/ui_base_features.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/platform_window_surface.h"
@@ -177,6 +178,10 @@ std::unique_ptr<OutputSurface> OutputSurfaceProviderImpl::CreateOutputSurface(
           std::move(context_provider));
     } else if (context_provider->ContextCapabilities().surfaceless) {
 #if defined(USE_OZONE) || defined(OS_MACOSX) || defined(OS_ANDROID)
+#if defined(USE_OZONE)
+      if (!features::IsUsingOzonePlatform())
+        NOTREACHED();
+#endif
       output_surface = std::make_unique<GLOutputSurfaceBufferQueue>(
           std::move(context_provider), surface_handle,
           std::make_unique<BufferQueue>(
@@ -228,24 +233,31 @@ OutputSurfaceProviderImpl::CreateSoftwareOutputDeviceForPlatform(
   NOTREACHED();
   return nullptr;
 #elif defined(USE_OZONE)
-  ui::SurfaceFactoryOzone* factory =
-      ui::OzonePlatform::GetInstance()->GetSurfaceFactoryOzone();
-  std::unique_ptr<ui::PlatformWindowSurface> platform_window_surface =
-      factory->CreatePlatformWindowSurface(surface_handle);
-  bool in_host_process =
-      !gpu_service_impl_ || gpu_service_impl_->in_host_process();
-  std::unique_ptr<ui::SurfaceOzoneCanvas> surface_ozone =
-      factory->CreateCanvasForWidget(
-          surface_handle,
-          in_host_process ? nullptr : gpu_service_impl_->main_runner());
-  CHECK(surface_ozone);
-  return std::make_unique<SoftwareOutputDeviceOzone>(
-      std::move(platform_window_surface), std::move(surface_ozone));
-#elif defined(USE_X11)
+  if (features::IsUsingOzonePlatform()) {
+    ui::SurfaceFactoryOzone* factory =
+        ui::OzonePlatform::GetInstance()->GetSurfaceFactoryOzone();
+    std::unique_ptr<ui::PlatformWindowSurface> platform_window_surface =
+        factory->CreatePlatformWindowSurface(surface_handle);
+    bool in_host_process =
+        !gpu_service_impl_ || gpu_service_impl_->in_host_process();
+    std::unique_ptr<ui::SurfaceOzoneCanvas> surface_ozone =
+        factory->CreateCanvasForWidget(
+            surface_handle,
+            in_host_process ? nullptr : gpu_service_impl_->main_runner());
+    CHECK(surface_ozone);
+    return std::make_unique<SoftwareOutputDeviceOzone>(
+        std::move(platform_window_surface), std::move(surface_ozone));
+  }
+#endif
+
+#if defined(USE_X11)
   return std::make_unique<SoftwareOutputDeviceX11>(
       surface_handle, gpu_service_impl_->in_host_process()
                           ? nullptr
                           : gpu_service_impl_->main_runner());
+#else
+  NOTREACHED();
+  return nullptr;
 #endif
 }
 

components/viz/service/display_embedder/skia_output_surface_impl_on_gpu.cc

@@ -89,6 +89,10 @@
 #endif
 #endif
 
+#if defined(USE_OZONE) || defined(USE_X11)
+#include "ui/base/ui_base_features.h"
+#endif
+
 namespace viz {
 
 namespace {
@@ -1473,11 +1477,13 @@ bool SkiaOutputSurfaceImplOnGpu::Initialize() {
                "is_using_vulkan", is_using_vulkan());
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 #if defined(USE_OZONE)
-  gpu::SurfaceHandle surface_handle = dependency_->GetSurfaceHandle();
-  if (surface_handle != gpu::kNullSurfaceHandle) {
-    window_surface_ = ui::OzonePlatform::GetInstance()
-                          ->GetSurfaceFactoryOzone()
-                          ->CreatePlatformWindowSurface(surface_handle);
+  if (features::IsUsingOzonePlatform()) {
+    gpu::SurfaceHandle surface_handle = dependency_->GetSurfaceHandle();
+    if (surface_handle != gpu::kNullSurfaceHandle) {
+      window_surface_ = ui::OzonePlatform::GetInstance()
+                            ->GetSurfaceFactoryOzone()
+                            ->CreatePlatformWindowSurface(surface_handle);
+    }
   }
 #endif
 
@@ -1591,42 +1597,45 @@ bool SkiaOutputSurfaceImplOnGpu::InitializeForVulkan() {
     supports_alpha_ = renderer_settings_.requires_alpha_channel;
   } else {
 #if defined(USE_X11)
-    supports_alpha_ = true;
-    if (!gpu_preferences_.disable_vulkan_surface) {
-      output_device_ = SkiaOutputDeviceVulkan::Create(
-          vulkan_context_provider_, dependency_->GetSurfaceHandle(),
-          memory_tracker_.get(), did_swap_buffer_complete_callback_);
+    if (!features::IsUsingOzonePlatform()) {
+      supports_alpha_ = true;
+      if (!gpu_preferences_.disable_vulkan_surface) {
+        output_device_ = SkiaOutputDeviceVulkan::Create(
+            vulkan_context_provider_, dependency_->GetSurfaceHandle(),
+            memory_tracker_.get(), did_swap_buffer_complete_callback_);
+      }
+      if (!output_device_) {
+        output_device_ = std::make_unique<SkiaOutputDeviceX11>(
+            context_state_, dependency_->GetSurfaceHandle(),
+            memory_tracker_.get(), did_swap_buffer_complete_callback_);
+      }
     }
+#endif
     if (!output_device_) {
-      output_device_ = std::make_unique<SkiaOutputDeviceX11>(
-          context_state_, dependency_->GetSurfaceHandle(),
-          memory_tracker_.get(), did_swap_buffer_complete_callback_);
-    }
-#else
-    auto output_presenter =
-        OutputPresenterGL::Create(dependency_, memory_tracker_.get());
-    if (output_presenter) {
-      // TODO(https://crbug.com/1012401): don't depend on GL.
-      gl_surface_ = output_presenter->gl_surface();
-      output_device_ = std::make_unique<SkiaOutputDeviceBufferQueue>(
-          std::move(output_presenter), dependency_, memory_tracker_.get(),
-          did_swap_buffer_complete_callback_);
-    } else {
-      auto output_device = SkiaOutputDeviceVulkan::Create(
-          vulkan_context_provider_, dependency_->GetSurfaceHandle(),
-          memory_tracker_.get(), did_swap_buffer_complete_callback_);
+      auto output_presenter =
+          OutputPresenterGL::Create(dependency_, memory_tracker_.get());
+      if (output_presenter) {
+        // TODO(https://crbug.com/1012401): don't depend on GL.
+        gl_surface_ = output_presenter->gl_surface();
+        output_device_ = std::make_unique<SkiaOutputDeviceBufferQueue>(
+            std::move(output_presenter), dependency_, memory_tracker_.get(),
+            did_swap_buffer_complete_callback_);
+      } else {
+        auto output_device = SkiaOutputDeviceVulkan::Create(
+            vulkan_context_provider_, dependency_->GetSurfaceHandle(),
+            memory_tracker_.get(), did_swap_buffer_complete_callback_);
 #if defined(OS_WIN)
-      gpu::SurfaceHandle child_surface =
-          output_device ? output_device->GetChildSurfaceHandle()
-                        : gpu::kNullSurfaceHandle;
-      if (child_surface != gpu::kNullSurfaceHandle) {
-        DidCreateAcceleratedSurfaceChildWindow(dependency_->GetSurfaceHandle(),
-                                               child_surface);
-      }
+        gpu::SurfaceHandle child_surface =
+            output_device ? output_device->GetChildSurfaceHandle()
+                          : gpu::kNullSurfaceHandle;
+        if (child_surface != gpu::kNullSurfaceHandle) {
+          DidCreateAcceleratedSurfaceChildWindow(
+              dependency_->GetSurfaceHandle(), child_surface);
+        }
 #endif
-      output_device_ = std::move(output_device);
+        output_device_ = std::move(output_device);
+      }
     }
-#endif
   }
 #endif
   return !!output_device_;
@@ -1646,9 +1655,13 @@ bool SkiaOutputSurfaceImplOnGpu::InitializeForDawn() {
 #if defined(USE_X11)
     // TODO(sgilhuly): Set up a Vulkan swapchain so that Linux can also use
     // SkiaOutputDeviceDawn.
-    output_device_ = std::make_unique<SkiaOutputDeviceX11>(
-        context_state_, dependency_->GetSurfaceHandle(), memory_tracker_.get(),
-        did_swap_buffer_complete_callback_);
+    if (!features::IsUsingOzonePlatform()) {
+      output_device_ = std::make_unique<SkiaOutputDeviceX11>(
+          context_state_, dependency_->GetSurfaceHandle(),
+          memory_tracker_.get(), did_swap_buffer_complete_callback_);
+    } else {
+      return false;
+    }
 #elif defined(OS_WIN)
     std::unique_ptr<SkiaOutputDeviceDawn> output_device =
         std::make_unique<SkiaOutputDeviceDawn>(

components/viz/test/test_gpu_service_holder.cc

@@ -35,6 +35,7 @@
 #endif
 
 #if defined(USE_OZONE)
+#include "ui/base/ui_base_features.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
@@ -147,15 +148,17 @@ TestGpuServiceHolder::TestGpuServiceHolder(
     : gpu_thread_("GPUMainThread"), io_thread_("GPUIOThread") {
   base::Thread::Options gpu_thread_options;
 #if defined(USE_OZONE)
-  base::MessagePumpType message_pump_type_for_gpu =
-      ui::OzonePlatform::GetInstance()
-          ->GetPlatformProperties()
-          .message_pump_type_for_gpu;
-  // X11 platform uses UI thread for GPU main, but 2 UI threads is
-  // causing crashes in linux-ozone-rel.
-  // TODO(crbug.com/1078392): Investigate and fix.
-  if (message_pump_type_for_gpu != base::MessagePumpType::UI) {
-    gpu_thread_options.message_pump_type = message_pump_type_for_gpu;
+  if (features::IsUsingOzonePlatform()) {
+    base::MessagePumpType message_pump_type_for_gpu =
+        ui::OzonePlatform::GetInstance()
+            ->GetPlatformProperties()
+            .message_pump_type_for_gpu;
+    // X11 platform uses UI thread for GPU main, but 2 UI threads is
+    // causing crashes in linux-ozone-rel.
+    // TODO(crbug.com/1078392): Investigate and fix.
+    if (message_pump_type_for_gpu != base::MessagePumpType::UI) {
+      gpu_thread_options.message_pump_type = message_pump_type_for_gpu;
+    }
   }
 #endif