[ozone/headless] Add initial display fetch support for headless

Each Ozone platform creates its own NativeDisplayDelegate to get
display information. Otherwise, 'display::FakeDisplayDelegate' is
used for NativeDisplayDelegate.

Per bug, ozone headless is crashing because it uses
FakeDisplayDelegate and it doesn't invoke OnConfigurationChanged
before initialization completes so ScreenBase can't add the display.
Once NativeDisplayDelegate is initialized, DesktopScreenOzone
requires DisplayMode from DisplaySnapshot but FakeDisplayDelegate has
FakeDisplaySnapshot and it doesn't have DisplayMode.

This CL creates HeadlessNativeDisplayDelegate which owns
DisplaySnapshot and DisplayMode for ozone/headless.
DesktopScreenOzone keeps it in delegate_ and communicates with it.

To try this, compile with the following gn args
use_ozone = true
ozone_platform_headless = true

TEST=./out/Debug/chrome --ozone-platform=headless

Bug: 851375
Change-Id: I2c097bf54fafb2d9311919647801e401c59ba929
Reviewed-on: https://chromium-review.googlesource.com/1120447
Commit-Queue: Julie Jeongeun Kim <jkim@igalia.com>
Reviewed-by: Michael Spang <spang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#572488}

ui/ozone/platform/headless/BUILD.gn

@@ -10,6 +10,8 @@ source_set("headless") {
     "client_native_pixmap_factory_headless.h",
     "gl_surface_osmesa_png.cc",
     "gl_surface_osmesa_png.h",
+    "headless_native_display_delegate.cc",
+    "headless_native_display_delegate.h",
     "headless_surface_factory.cc",
     "headless_surface_factory.h",
     "headless_window.cc",

ui/ozone/platform/headless/headless_native_display_delegate.cc

+// Copyright 2018 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 "ui/ozone/platform/headless/headless_native_display_delegate.h"
+
+#include "ui/display/types/display_snapshot.h"
+#include "ui/display/types/native_display_observer.h"
+
+namespace ui {
+
+namespace {
+constexpr gfx::Size kDefaultWindowSize(800, 600);
+constexpr int default_refresh = 60;
+}  // namespace
+
+HeadlessNativeDisplayDelegate::HeadlessNativeDisplayDelegate() = default;
+
+HeadlessNativeDisplayDelegate::~HeadlessNativeDisplayDelegate() = default;
+
+void HeadlessNativeDisplayDelegate::Initialize() {
+  // This shouldn't be called twice.
+  DCHECK(!current_snapshot_);
+
+  if (next_display_id_ == std::numeric_limits<int64_t>::max()) {
+    LOG(FATAL) << "Exceeded display id limit";
+    return;
+  }
+
+  display::DisplaySnapshot::DisplayModeList modes;
+  std::unique_ptr<display::DisplayMode> display_mode =
+      std::make_unique<display::DisplayMode>(kDefaultWindowSize, false,
+                                             default_refresh);
+  modes.push_back(std::move(display_mode));
+  const display::DisplayMode* mode = modes.back().get();
+
+  current_snapshot_ = std::make_unique<display::DisplaySnapshot>(
+      next_display_id(), gfx::Point(0, 0), kDefaultWindowSize,
+      display::DisplayConnectionType::DISPLAY_CONNECTION_TYPE_NONE, false,
+      false, false, false, gfx::ColorSpace(), "", base::FilePath(),
+      std::move(modes), std::vector<uint8_t>(), mode, mode, 0, 0, gfx::Size());
+
+  for (display::NativeDisplayObserver& observer : observers_)
+    observer.OnConfigurationChanged();
+}
+
+void HeadlessNativeDisplayDelegate::TakeDisplayControl(
+    display::DisplayControlCallback callback) {
+  NOTREACHED();
+}
+
+void HeadlessNativeDisplayDelegate::RelinquishDisplayControl(
+    display::DisplayControlCallback callback) {
+  NOTREACHED();
+}
+
+void HeadlessNativeDisplayDelegate::GetDisplays(
+    display::GetDisplaysCallback callback) {
+  std::vector<display::DisplaySnapshot*> snapshot;
+  snapshot.push_back(current_snapshot_.get());
+  std::move(callback).Run(snapshot);
+}
+
+void HeadlessNativeDisplayDelegate::Configure(
+    const display::DisplaySnapshot& output,
+    const display::DisplayMode* mode,
+    const gfx::Point& origin,
+    display::ConfigureCallback callback) {
+  NOTIMPLEMENTED();
+
+  // It should call |callback| after configuration.
+  // Even if we don't have implementation, it calls |callback| to finish the
+  // logic.
+  std::move(callback).Run(true);
+}
+
+void HeadlessNativeDisplayDelegate::GetHDCPState(
+    const display::DisplaySnapshot& output,
+    display::GetHDCPStateCallback callback) {
+  NOTREACHED();
+}
+
+void HeadlessNativeDisplayDelegate::SetHDCPState(
+    const display::DisplaySnapshot& output,
+    display::HDCPState state,
+    display::SetHDCPStateCallback callback) {
+  NOTREACHED();
+}
+
+bool HeadlessNativeDisplayDelegate::SetColorMatrix(
+    int64_t display_id,
+    const std::vector<float>& color_matrix) {
+  NOTREACHED();
+  return false;
+}
+
+bool HeadlessNativeDisplayDelegate::SetGammaCorrection(
+    int64_t display_id,
+    const std::vector<display::GammaRampRGBEntry>& degamma_lut,
+    const std::vector<display::GammaRampRGBEntry>& gamma_lut) {
+  NOTREACHED();
+  return false;
+}
+
+void HeadlessNativeDisplayDelegate::AddObserver(
+    display::NativeDisplayObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void HeadlessNativeDisplayDelegate::RemoveObserver(
+    display::NativeDisplayObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+display::FakeDisplayController*
+HeadlessNativeDisplayDelegate::GetFakeDisplayController() {
+  return nullptr;
+}
+
+}  // namespace ui

ui/ozone/platform/headless/headless_native_display_delegate.h

+// Copyright 2018 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.
+
+#ifndef UI_OZONE_PLATFORM_HEADLESS_HEADLESS_NATIVE_DISPLAY_DELEGATE_H_
+#define UI_OZONE_PLATFORM_HEADLESS_HEADLESS_NATIVE_DISPLAY_DELEGATE_H_
+
+#include "base/observer_list.h"
+#include "ui/display/types/native_display_delegate.h"
+
+namespace display {
+class DisplayMode;
+class DisplaySnapshot;
+}  // namespace display
+
+namespace ui {
+
+class HeadlessNativeDisplayDelegate : public display::NativeDisplayDelegate {
+ public:
+  HeadlessNativeDisplayDelegate();
+  ~HeadlessNativeDisplayDelegate() override;
+
+  // display::NativeDisplayDelegate overrides:
+  void Initialize() override;
+  void TakeDisplayControl(display::DisplayControlCallback callback) override;
+  void RelinquishDisplayControl(
+      display::DisplayControlCallback callback) override;
+  void GetDisplays(display::GetDisplaysCallback callback) override;
+  void Configure(const display::DisplaySnapshot& output,
+                 const display::DisplayMode* mode,
+                 const gfx::Point& origin,
+                 display::ConfigureCallback callback) override;
+  void GetHDCPState(const display::DisplaySnapshot& output,
+                    display::GetHDCPStateCallback callback) override;
+  void SetHDCPState(const display::DisplaySnapshot& output,
+                    display::HDCPState state,
+                    display::SetHDCPStateCallback callback) override;
+  bool SetColorMatrix(int64_t display_id,
+                      const std::vector<float>& color_matrix) override;
+  bool SetGammaCorrection(
+      int64_t display_id,
+      const std::vector<display::GammaRampRGBEntry>& degamma_lut,
+      const std::vector<display::GammaRampRGBEntry>& gamma_lut) override;
+  void AddObserver(display::NativeDisplayObserver* observer) override;
+  void RemoveObserver(display::NativeDisplayObserver* observer) override;
+  display::FakeDisplayController* GetFakeDisplayController() override;
+
+ private:
+  int64_t next_display_id() { return next_display_id_++; }
+  std::unique_ptr<display::DisplaySnapshot> current_snapshot_;
+
+  base::ObserverList<display::NativeDisplayObserver> observers_;
+
+  // The next available display id.
+  int64_t next_display_id_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(HeadlessNativeDisplayDelegate);
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_PLATFORM_HEADLESS_HEADLESS_NATIVE_DISPLAY_DELEGATE_H_

ui/ozone/platform/headless/ozone_platform_headless.cc

@@ -8,12 +8,12 @@
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h"
-#include "ui/display/manager/fake_display_delegate.h"
 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
 #include "ui/events/ozone/layout/stub/stub_keyboard_layout_engine.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/system_input_injector.h"
 #include "ui/ozone/common/stub_overlay_manager.h"
+#include "ui/ozone/platform/headless/headless_native_display_delegate.h"
 #include "ui/ozone/platform/headless/headless_surface_factory.h"
 #include "ui/ozone/platform/headless/headless_window.h"
 #include "ui/ozone/platform/headless/headless_window_manager.h"
@@ -74,7 +74,7 @@ class OzonePlatformHeadless : public OzonePlatform {
   }
   std::unique_ptr<display::NativeDisplayDelegate> CreateNativeDisplayDelegate()
       override {
-    return std::make_unique<display::FakeDisplayDelegate>();
+    return std::make_unique<HeadlessNativeDisplayDelegate>();
   }
 
   void InitializeUI(const InitParams& params) override {