Start to decouple display::Display from ws::PlatformDisplay.

services/ui/ws/test_utils.cc

 // Copyright 2016 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 "services/ui/ws/test_utils.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "cc/output/copy_output_request.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "services/service_manager/public/interfaces/connector.mojom.h"
 #include "services/ui/public/interfaces/cursor.mojom.h"
 #include "services/ui/ws/display_binding.h"
 #include "services/ui/ws/display_manager.h"
-#include "services/ui/ws/platform_display_init_params.h"
 #include "services/ui/ws/window_manager_access_policy.h"
 #include "services/ui/ws/window_manager_window_tree_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/dip_util.h"
 
 namespace ui {
 namespace ws {
 namespace test {
 namespace {
 
 // -----------------------------------------------------------------------------
 // Empty implementation of PlatformDisplay.
 class TestPlatformDisplay : public PlatformDisplay {
  public:
-  explicit TestPlatformDisplay(const PlatformDisplayInitParams& params,
+  explicit TestPlatformDisplay(const display::ViewportMetrics& metrics,
                                mojom::Cursor* cursor_storage)
-      : id_(params.display_id),
-        display_metrics_(params.metrics),
-        cursor_storage_(cursor_storage) {
-    display_metrics_.bounds = gfx::Rect(0, 0, 400, 300);
-    display_metrics_.device_scale_factor = 1.f;
-  }
+      : metrics_(metrics), cursor_storage_(cursor_storage) {}
   ~TestPlatformDisplay() override {}
 
   // PlatformDisplay:
   void Init(PlatformDisplayDelegate* delegate) override {
     delegate->OnAcceleratedWidgetAvailable();
   }
-  int64_t GetId() const override { return id_; }
   void SetViewportSize(const gfx::Size& size) override {}
   void SetTitle(const base::string16& title) override {}
   void SetCapture() override {}
   void ReleaseCapture() override {}
   void SetCursorById(mojom::Cursor cursor) override {
     *cursor_storage_ = cursor;
   }
   void UpdateTextInputState(const ui::TextInputState& state) override {}
   void SetImeVisibility(bool visible) override {}
-  gfx::Rect GetBounds() const override { return display_metrics_.bounds; }
   bool UpdateViewportMetrics(const display::ViewportMetrics& metrics) override {
-    if (display_metrics_ == metrics)
+    if (metrics_ == metrics)
       return false;
-    display_metrics_ = metrics;
+    metrics_ = metrics;
     return true;
   }
-  const display::ViewportMetrics& GetViewportMetrics() const override {
-    return display_metrics_;
-  }
   gfx::AcceleratedWidget GetAcceleratedWidget() const override {
     return gfx::kNullAcceleratedWidget;
   }
   FrameGenerator* GetFrameGenerator() override { return nullptr; }
 
  private:
-  const int64_t id_;
-  display::ViewportMetrics display_metrics_;
+  display::ViewportMetrics metrics_;
   mojom::Cursor* cursor_storage_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPlatformDisplay);
 };
 
 ClientWindowId NextUnusedClientWindowId(WindowTree* tree) {
   ClientWindowId client_id;
   for (ClientSpecificId id = 1;; ++id) {
     // Used the id of the client in the upper bits to simplify things.
     const ClientWindowId client_id =
         ClientWindowId(WindowIdToTransportId(WindowId(tree->id(), id)));
     if (!tree->GetWindowByClientId(client_id))
       return client_id;
   }
 }
 
-// Creates a Display with |id| and same attributes as |metrics|.
-display::Display CreateDisplay(int64_t id,
-                               const display::ViewportMetrics& metrics) {
-  display::Display display(id);
-  display.set_bounds(metrics.bounds);
-  display.set_work_area(metrics.work_area);
-  display.set_device_scale_factor(metrics.device_scale_factor);
-  display.set_rotation(metrics.rotation);
-  display.set_touch_support(metrics.touch_support);
-  return display;
+display::ViewportMetrics MakeViewportMetrics(const display::Display& display) {
+  gfx::Size pixel_size = gfx::ConvertSizeToPixel(display.device_scale_factor(),
+                                                 display.bounds().size());
+
+  display::ViewportMetrics metrics;
+  metrics.bounds_in_pixels.set_size(pixel_size);
+  metrics.device_scale_factor = display.device_scale_factor();
+  return metrics;
 }
 
 }  // namespace
 
 // TestScreenManager  -------------------------------------------------
 
 TestScreenManager::TestScreenManager() {}
 
 TestScreenManager::~TestScreenManager() {
   display::Screen::SetScreenInstance(nullptr);
 }
 
 int64_t TestScreenManager::AddDisplay() {
-  return AddDisplay(MakeViewportMetrics(0, 0, 100, 100, 1.0f));
+  return AddDisplay(
+      display::Display(display::kInvalidDisplayId, gfx::Rect(100, 100)));
 }
 
-int64_t TestScreenManager::AddDisplay(const display::ViewportMetrics& metrics) {
+int64_t TestScreenManager::AddDisplay(const display::Display& input_display) {
   // Generate a unique display id.
   int64_t display_id = display_ids_.empty() ? 1 : *display_ids_.rbegin() + 1;
   display_ids_.insert(display_id);
 
+  display::Display display = input_display;
+  display.set_id(display_id);
+
   // First display added will be the primary display.
   display::DisplayList::Type type = display::DisplayList::Type::NOT_PRIMARY;
   if (display_ids_.size() == 1)
     type = display::DisplayList::Type::PRIMARY;
 
-  screen_->display_list().AddDisplay(CreateDisplay(display_id, metrics), type);
-  delegate_->OnDisplayAdded(display_id, metrics);
+  screen_->display_list().AddDisplay(display, type);
+  delegate_->OnDisplayAdded(display, MakeViewportMetrics(display));
 
   if (type == display::DisplayList::Type::PRIMARY)
     delegate_->OnPrimaryDisplayChanged(display_id);
 
   return display_id;
 }
 
-void TestScreenManager::ModifyDisplay(int64_t display_id,
-                                      const display::ViewportMetrics& metrics) {
-  DCHECK(display_ids_.count(display_id) == 1);
-  screen_->display_list().UpdateDisplay(CreateDisplay(display_id, metrics));
-  delegate_->OnDisplayModified(display_id, metrics);
+void TestScreenManager::ModifyDisplay(const display::Display& display) {
+  DCHECK(display_ids_.count(display.id()) == 1);
+  screen_->display_list().UpdateDisplay(display);
+  delegate_->OnDisplayModified(display, MakeViewportMetrics(display));
 }
 
 void TestScreenManager::RemoveDisplay(int64_t display_id) {
   DCHECK(display_ids_.count(display_id) == 1);
   screen_->display_list().RemoveDisplay(display_id);
   delegate_->OnDisplayRemoved(display_id);
   display_ids_.erase(display_id);
 }
 
 void TestScreenManager::Init(display::ScreenManagerDelegate* delegate) {
   delegate_ = delegate;
 
   // Reset everything.
   display_ids_.clear();
   display::Screen::SetScreenInstance(nullptr);
   screen_ = base::MakeUnique<display::ScreenBase>();
   display::Screen::SetScreenInstance(screen_.get());
 }
 
 // TestPlatformDisplayFactory  -------------------------------------------------
 
 TestPlatformDisplayFactory::TestPlatformDisplayFactory(
     mojom::Cursor* cursor_storage)
     : cursor_storage_(cursor_storage) {}
 
 TestPlatformDisplayFactory::~TestPlatformDisplayFactory() {}
 
 std::unique_ptr<PlatformDisplay>
 TestPlatformDisplayFactory::CreatePlatformDisplay(
-    const PlatformDisplayInitParams& init_params) {
-  return base::MakeUnique<TestPlatformDisplay>(init_params, cursor_storage_);
+    ServerWindow* root_window,
+    const display::ViewportMetrics& metrics) {
+  return base::MakeUnique<TestPlatformDisplay>(metrics, cursor_storage_);
 }
 
 // TestFrameGeneratorDelegate -------------------------------------------------
 
 TestFrameGeneratorDelegate::TestFrameGeneratorDelegate() {}
 
 TestFrameGeneratorDelegate::~TestFrameGeneratorDelegate() {}
 
 bool TestFrameGeneratorDelegate::IsInHighContrastMode() {
   return false;
@@ skipping 335 matching lines @@
 WindowServerTestHelper::~WindowServerTestHelper() {
   // Destroy |window_server_| while the message-loop is still alive.
   window_server_.reset();
 }
 
 // WindowEventTargetingHelper ------------------------------------------------
 
 WindowEventTargetingHelper::WindowEventTargetingHelper() {
   display_ = new Display(window_server());
   display_binding_ = new TestDisplayBinding(window_server());
-  display_->Init(PlatformDisplayInitParams(),
+  display_->Init(display::ViewportMetrics(),
                  base::WrapUnique(display_binding_));
   wm_client_ = ws_test_helper_.window_server_delegate()->last_client();
   wm_client_->tracker()->changes()->clear();
 }
 
 WindowEventTargetingHelper::~WindowEventTargetingHelper() {}
 
 ServerWindow* WindowEventTargetingHelper::CreatePrimaryTree(
     const gfx::Rect& root_window_bounds,
     const gfx::Rect& window_bounds) {
@@ skipping 59 matching lines @@
 }
 
 // ----------------------------------------------------------------------------
 
 void AddWindowManager(WindowServer* window_server, const UserId& user_id) {
   window_server->window_manager_window_tree_factory_set()
       ->Add(user_id, nullptr)
       ->CreateWindowTree(nullptr, nullptr);
 }
 
-display::ViewportMetrics MakeViewportMetrics(int origin_x,
-                                             int origin_y,
-                                             int width_pixels,
-                                             int height_pixels,
-                                             float scale_factor) {
-  display::ViewportMetrics metrics;
+display::Display MakeDisplay(int origin_x,
+                             int origin_y,
+                             int width_pixels,
+                             int height_pixels,
+                             float scale_factor) {
   gfx::Size scaled_size = gfx::ConvertSizeToDIP(
       scale_factor, gfx::Size(width_pixels, height_pixels));
-  metrics.bounds = gfx::Rect(gfx::Point(origin_x, origin_y), scaled_size);
-  metrics.work_area = metrics.bounds;
-  metrics.pixel_size = gfx::Size(width_pixels, height_pixels);
-  metrics.device_scale_factor = scale_factor;
-  return metrics;
+  gfx::Rect bounds(gfx::Point(origin_x, origin_y), scaled_size);
+
+  display::Display display;
+  display.set_bounds(bounds);
+  display.set_work_area(bounds);
+  display.set_device_scale_factor(scale_factor);
+  return display;
 }
 
 ServerWindow* FirstRoot(WindowTree* tree) {
   return tree->roots().size() == 1u
              ? tree->GetWindow((*tree->roots().begin())->id())
              : nullptr;
 }
 
 ClientWindowId FirstRootId(WindowTree* tree) {
   ServerWindow* first_root = FirstRoot(tree);
@@ skipping 29 matching lines @@
   if (!tree->AddWindow(parent_client_id, client_window_id))
     return nullptr;
   if (client_id)
     *client_id = client_window_id;
   return tree->GetWindowByClientId(client_window_id);
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui