[Fuchsia] Implement ui::PlatformScreen for Scenic

The new PlatformScreen implementation allows to propagate display
settings (such as device_pixel_scale) to the renderer.

Bug: 850650
Change-Id: I088c1c46ba57596bd55bf57db854f8b3a2367e83
Reviewed-on: https://chromium-review.googlesource.com/1162426
Commit-Queue: Sergey Ulanov <sergeyu@chromium.org>
Reviewed-by: Michael Spang <spang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#582823}

ui/ozone/platform/scenic/BUILD.gn

@@ -10,6 +10,8 @@ source_set("scenic") {
     "client_native_pixmap_factory_scenic.h",
     "ozone_platform_scenic.cc",
     "ozone_platform_scenic.h",
+    "scenic_screen.cc",
+    "scenic_screen.h",
     "scenic_session.cc",
     "scenic_session.h",
     "scenic_surface_factory.cc",

ui/ozone/platform/scenic/ozone_platform_scenic.cc

@@ -97,6 +97,10 @@ class OzonePlatformScenic : public OzonePlatform {
     return std::make_unique<display::FakeDisplayDelegate>();
   }
 
+  std::unique_ptr<PlatformScreen> CreateScreen() override {
+    return window_manager_.CreateScreen();
+  }
+
   void InitializeUI(const InitParams& params) override {
     if (!PlatformEventSource::GetInstance())
       platform_event_source_ = std::make_unique<ScenicPlatformEventSource>();

ui/ozone/platform/scenic/scenic_screen.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/scenic/scenic_screen.h"
+
+#include "ui/display/display.h"
+#include "ui/display/display_observer.h"
+#include "ui/gfx/geometry/point.h"
+
+namespace ui {
+
+ScenicScreen::ScenicScreen() : weak_factory_(this) {}
+
+ScenicScreen::~ScenicScreen() = default;
+
+void ScenicScreen::OnWindowAdded(int32_t window_id) {
+  // Ensure that |window_id| is greater than the id of all other windows. This
+  // allows pushing the new entry to the end of the list while keeping it
+  // sorted.
+  DCHECK(displays_.empty() || (window_id > displays_.back().id()));
+  displays_.push_back(display::Display(window_id));
+
+  for (auto& observer : observers_)
+    observer.OnDisplayAdded(displays_.back());
+}
+
+void ScenicScreen::OnWindowRemoved(int32_t window_id) {
+  auto it = FindDisplayById(window_id);
+  DCHECK(it != displays_.end());
+  display::Display removed_display = *it;
+  displays_.erase(it);
+
+  for (auto& observer : observers_)
+    observer.OnDisplayAdded(removed_display);
+}
+
+void ScenicScreen::OnWindowMetrics(int32_t window_id,
+                                   float device_pixel_ratio) {
+  DisplayVector::const_iterator const_it = FindDisplayById(window_id);
+  DisplayVector::iterator it =
+      displays_.begin() + (const_it - displays_.begin());
+
+  DCHECK(it != displays_.end());
+  it->set_device_scale_factor(device_pixel_ratio);
+
+  for (auto& observer : observers_) {
+    observer.OnDisplayMetricsChanged(
+        *it, display::DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR);
+  }
+}
+
+base::WeakPtr<ScenicScreen> ScenicScreen::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
+const std::vector<display::Display>& ScenicScreen::GetAllDisplays() const {
+  return displays_;
+}
+
+display::Display ScenicScreen::GetPrimaryDisplay() const {
+  // There is no primary display.
+  return display::Display();
+}
+
+display::Display ScenicScreen::GetDisplayForAcceleratedWidget(
+    gfx::AcceleratedWidget widget) const {
+  auto display_it = FindDisplayById(widget);
+  if (display_it == displays_.end()) {
+    NOTREACHED();
+    return display::Display();
+  }
+
+  return *display_it;
+}
+
+gfx::Point ScenicScreen::GetCursorScreenPoint() const {
+  NOTIMPLEMENTED();
+  return gfx::Point();
+}
+
+gfx::AcceleratedWidget ScenicScreen::GetAcceleratedWidgetAtScreenPoint(
+    const gfx::Point& point) const {
+  NOTIMPLEMENTED();
+  return gfx::kNullAcceleratedWidget;
+}
+
+display::Display ScenicScreen::GetDisplayNearestPoint(
+    const gfx::Point& point) const {
+  NOTREACHED();
+  return display::Display();
+}
+
+display::Display ScenicScreen::GetDisplayMatching(
+    const gfx::Rect& match_rect) const {
+  NOTREACHED();
+  return display::Display();
+}
+
+void ScenicScreen::AddObserver(display::DisplayObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ScenicScreen::RemoveObserver(display::DisplayObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+ScenicScreen::DisplayVector::const_iterator ScenicScreen::FindDisplayById(
+    int32_t id) const {
+  DisplayVector::const_iterator r =
+      std::lower_bound(displays_.begin(), displays_.end(), id,
+                       [](const display::Display& display, int32_t id) {
+                         return display.id() < id;
+                       });
+  if (r != displays_.end() && r->id() == id)
+    return r;
+  return displays_.end();
+}
+
+}  // namespace ui

ui/ozone/platform/scenic/scenic_screen.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_SCENIC_SCENIC_SCREEN_H_
+#define UI_OZONE_PLATFORM_SCENIC_SCENIC_SCREEN_H_
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
+#include "ui/ozone/public/ozone_platform.h"
+#include "ui/ozone/public/platform_screen.h"
+
+namespace ui {
+
+// A PlatformScreen implementation for Scenic.
+class ScenicScreen : public PlatformScreen {
+ public:
+  ScenicScreen();
+  ~ScenicScreen() override;
+
+  void OnWindowAdded(int32_t window_id);
+  void OnWindowRemoved(int32_t window_id);
+  void OnWindowMetrics(int32_t window_id, float device_pixel_ratio);
+
+  base::WeakPtr<ScenicScreen> GetWeakPtr();
+
+  // display::Screen implementation.
+  const std::vector<display::Display>& GetAllDisplays() const override;
+  display::Display GetPrimaryDisplay() const override;
+  display::Display GetDisplayForAcceleratedWidget(
+      gfx::AcceleratedWidget widget) const override;
+  gfx::Point GetCursorScreenPoint() const override;
+  gfx::AcceleratedWidget GetAcceleratedWidgetAtScreenPoint(
+      const gfx::Point& point) const override;
+  display::Display GetDisplayNearestPoint(
+      const gfx::Point& point) const override;
+  display::Display GetDisplayMatching(
+      const gfx::Rect& match_rect) const override;
+  void AddObserver(display::DisplayObserver* observer) override;
+  void RemoveObserver(display::DisplayObserver* observer) override;
+
+ private:
+  using DisplayVector = std::vector<display::Display>;
+
+  DisplayVector::const_iterator FindDisplayById(int32_t id) const;
+
+  DisplayVector displays_;
+
+  base::ObserverList<display::DisplayObserver> observers_;
+
+  base::WeakPtrFactory<ScenicScreen> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScenicScreen);
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_PLATFORM_SCENIC_SCENIC_SCREEN_H_

ui/ozone/platform/scenic/scenic_window.cc

@@ -220,21 +220,18 @@ void ScenicWindow::OnScenicEvents(
       continue;
 
     auto& metrics = event.gfx().metrics();
-    if (metrics.node_id == parent_node_id_) {
-      float new_device_pixel_ratio =
-          std::max(metrics.metrics.scale_x, metrics.metrics.scale_y);
-      if (device_pixel_ratio_ == 0.0) {
-        device_pixel_ratio_ = new_device_pixel_ratio;
-        if (!size_dips_.IsEmpty())
-          UpdateSize();
-      } else if (device_pixel_ratio_ != new_device_pixel_ratio) {
-        // Ozone currently doesn't support dynamic changes in
-        // device_pixel_ratio.
-        // TODO(crbug.com/850650): Update Ozone/Aura to allow DPI changes
-        // after OnAcceleratedWidgetAvailable().
-        NOTIMPLEMENTED() << "Ignoring display metrics event.";
-      }
-    }
+    if (metrics.node_id != parent_node_id_)
+      continue;
+
+    device_pixel_ratio_ =
+        std::max(metrics.metrics.scale_x, metrics.metrics.scale_y);
+
+    ScenicScreen* screen = manager_->screen();
+    if (screen)
+      screen->OnWindowMetrics(window_id_, device_pixel_ratio_);
+
+    if (!size_dips_.IsEmpty())
+      UpdateSize();
   }
 }
 

ui/ozone/platform/scenic/scenic_window_manager.cc

@@ -11,6 +11,13 @@ namespace ui {
 ScenicWindowManager::ScenicWindowManager() = default;
 ScenicWindowManager::~ScenicWindowManager() = default;
 
+std::unique_ptr<PlatformScreen> ScenicWindowManager::CreateScreen() {
+  DCHECK(windows_.IsEmpty());
+  auto screen = std::make_unique<ScenicScreen>();
+  screen_ = screen->GetWeakPtr();
+  return screen;
+}
+
 fuchsia::ui::viewsv1::ViewManager* ScenicWindowManager::GetViewManager() {
   if (!view_manager_) {
     view_manager_ = base::fuchsia::ComponentContext::GetDefault()
@@ -32,13 +39,18 @@ fuchsia::ui::scenic::Scenic* ScenicWindowManager::GetScenic() {
 }
 
 int32_t ScenicWindowManager::AddWindow(ScenicWindow* window) {
-  return windows_.Add(window);
+  int32_t id = windows_.Add(window);
+  if (screen_)
+    screen_->OnWindowAdded(id);
+  return id;
 }
 
 void ScenicWindowManager::RemoveWindow(int32_t window_id,
                                        ScenicWindow* window) {
   DCHECK_EQ(window, windows_.Lookup(window_id));
   windows_.Remove(window_id);
+  if (screen_)
+    screen_->OnWindowRemoved(window_id);
 }
 
 ScenicWindow* ScenicWindowManager::GetWindow(int32_t window_id) {

ui/ozone/platform/scenic/scenic_window_manager.h

@@ -15,6 +15,7 @@
 #include "base/threading/thread_checker.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/ozone/ozone_export.h"
+#include "ui/ozone/platform/scenic/scenic_screen.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 
 namespace ui {
@@ -33,6 +34,8 @@ class OZONE_EXPORT ScenicWindowManager {
   ScenicWindowManager();
   ~ScenicWindowManager();
 
+  std::unique_ptr<PlatformScreen> CreateScreen();
+
   // ViewManager and Scenic services that are used by ScenicWindow. Both
   // interfaces are initialized lazily on the first call and they don't change
   // afterwards. ScenicWindowManager keeps the ownership.
@@ -46,11 +49,15 @@ class OZONE_EXPORT ScenicWindowManager {
   // Called by ScenicWindow destructor to unregister |window|.
   void RemoveWindow(int32_t window_id, ScenicWindow* window);
 
+  ScenicScreen* screen() { return screen_.get(); }
+
   ScenicWindow* GetWindow(int32_t window_id);
 
  private:
   base::IDMap<ScenicWindow*> windows_;
 
+  base::WeakPtr<ScenicScreen> screen_;
+
   fuchsia::ui::viewsv1::ViewManagerPtr view_manager_;
   fuchsia::ui::scenic::ScenicPtr scenic_;