[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: Ib0d6dc66e6d9c538db38e1c6f04c35b149f9b6e6
Reviewed-on: https://chromium-review.googlesource.com/1094851Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
Commit-Queue: Julie Jeongeun Kim <jkim@igalia.com>
Cr-Commit-Position: refs/heads/master@{#567929}

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;
+  }
+
+  current_snapshot_.reset(new display::DisplaySnapshot(
+      get_next_display_id(), gfx::Point(0, 0), kDefaultWindowSize,
+      display::DisplayConnectionType::DISPLAY_CONNECTION_TYPE_NONE, false,
+      false, false, gfx::ColorSpace(), "", base::FilePath(),
+      display::DisplaySnapshot::DisplayModeList(), std::vector<uint8_t>(),
+      nullptr, nullptr, 0, 0, gfx::Size()));
+
+  current_mode_.reset(
+      new display::DisplayMode(kDefaultWindowSize, false, default_refresh));
+  current_snapshot_->set_current_mode(current_mode_.get());
+
+  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) {
+  NOTREACHED();
+}
+
+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/macros.h"
+#include "base/observer_list.h"
+#include "ui/display/types/display_snapshot.h"
+#include "ui/display/types/native_display_delegate.h"
+
+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 get_next_display_id() { return next_display_id_++; }
+  std::unique_ptr<display::DisplaySnapshot> current_snapshot_;
+  std::unique_ptr<display::DisplayMode> current_mode_;
+
+  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 {