Handle modified displays in mustash.

services/ui/display/platform_screen_ozone_unittests.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 <memory>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "services/ui/display/platform_screen.h"
 #include "services/ui/display/platform_screen_ozone.h"
+#include "services/ui/display/viewport_metrics.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/chromeos/display_configurator.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/fake_display_snapshot.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/ozone/public/ozone_platform.h"
 
 namespace display {
 
 using ui::DisplayConfigurator;
 using ui::DisplayMode;
 using ui::DisplaySnapshot;
 using ui::DisplaySnapshotVirtual;
 using testing::IsEmpty;
 using testing::SizeIs;
 
 namespace {
 
 // The ID of default "display" that gets added when running off device.
 const int64_t kDefaultDisplayId = 1;
 
 // Holds info about the display state we want to test.
 struct DisplayState {
   int64_t id;
-  gfx::Rect bounds;
-  gfx::Size size;
-  float device_scale_factor;
+  ViewportMetrics metrics;
 };
 
 // Matchers that operate on DisplayState.
 MATCHER_P(DisplayId, display_id, "") {
   *result_listener << "has id " << arg.id;
   return arg.id == display_id;
 }
 
 MATCHER_P(DisplaySize, size_string, "") {
-  *result_listener << "has size " << arg.bounds.size().ToString();
-  return arg.bounds.size().ToString() == size_string;
+  *result_listener << "has size " << arg.metrics.bounds.size().ToString();
+  return arg.metrics.bounds.size().ToString() == size_string;
 }
 
 MATCHER_P(DisplayOrigin, origin_string, "") {
-  *result_listener << "has origin " << arg.bounds.origin().ToString();
-  return arg.bounds.origin().ToString() == origin_string;
+  *result_listener << "has origin " << arg.metrics.bounds.origin().ToString();
+  return arg.metrics.bounds.origin().ToString() == origin_string;
 }
 
 // Make a DisplaySnapshot with specified id and size.
 std::unique_ptr<DisplaySnapshot> MakeSnapshot(int64_t id,
                                               const gfx::Size& size) {
   return FakeDisplaySnapshot::Builder()
       .SetId(id)
       .SetNativeMode(size)
       .SetCurrentMode(size)
       .Build();
 }
 
 // Test delegate to track what functions calls the delegate receives.
 class TestPlatformScreenDelegate : public PlatformScreenDelegate {
  public:
   TestPlatformScreenDelegate() {}
   ~TestPlatformScreenDelegate() override {}
 
   std::vector<DisplayState> added() { return added_; }
   std::vector<DisplayState> removed() { return removed_; }
   std::vector<DisplayState> modified() { return modified_; }
 
   void Reset() {
     added_.clear();
     removed_.clear();
     modified_.clear();
   }
 
  private:
-  void OnDisplayAdded(int64_t id,
-                      const gfx::Rect& bounds,
-                      const gfx::Size& pixel_size,
-                      float device_scale_factor) override {
-    added_.push_back({id, bounds, pixel_size, device_scale_factor});
+  void OnDisplayAdded(int64_t id, const ViewportMetrics& metrics) override {
+    added_.push_back({id, metrics});
   }
 
   void OnDisplayRemoved(int64_t id) override {
-    removed_.push_back({id, gfx::Rect(), gfx::Size(), 1.0f});
+    removed_.push_back({id, ViewportMetrics()});
   }
 
-  void OnDisplayModified(int64_t id,
-                         const gfx::Rect& bounds,
-                         const gfx::Size& pixel_size,
-                         float device_scale_factor) override {
-    modified_.push_back({id, bounds, pixel_size, device_scale_factor});
+  void OnDisplayModified(int64_t id, const ViewportMetrics& metrics) override {
+    modified_.push_back({id, metrics});
   }
 
   std::vector<DisplayState> added_;
   std::vector<DisplayState> removed_;
   std::vector<DisplayState> modified_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPlatformScreenDelegate);
 };
 
 // Test fixture with helpers to act like ui::DisplayConfigurator and send
@@ skipping 214 matching lines @@
   // Check that the default display was modified with a new size and display 2
   // was modified with a new origin.
   ASSERT_THAT(delegate()->modified(), SizeIs(2));
   EXPECT_THAT(delegate()->modified()[0], DisplayId(kDefaultDisplayId));
   EXPECT_THAT(delegate()->modified()[0], DisplaySize(size.ToString()));
   EXPECT_THAT(delegate()->modified()[1], DisplayId(2));
   EXPECT_THAT(delegate()->modified()[1], DisplayOrigin("1920,0"));
 }
 
 }  // namespace display