Add FakeDisplaySnapshot builder and related changes.

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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/chromeos/display_configurator.h"
-#include "ui/display/chromeos/display_snapshot_virtual.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 = 36029742295586049;
+const int64_t kDefaultDisplayId = 1;
 
 // Holds info about the display state we want to test.
 struct DisplayState {
   int64_t id;
   gfx::Rect bounds;
 };
 
 // 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;
 }
 
 MATCHER_P(DisplayOrigin, origin_string, "") {
   *result_listener << "has origin " << arg.bounds.origin().ToString();
   return arg.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) {
-  auto snapshot = base::MakeUnique<DisplaySnapshotVirtual>(id, size);
-  snapshot->set_current_mode(snapshot->modes()[0].get());
-  return snapshot;
+  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_; }
@@ skipping 86 matching lines @@
   DisplaySnapshot* GetSnapshotById(int64_t id) {
     for (auto& snapshot : snapshots_) {
       if (snapshot->display_id() == id)
         return snapshot.get();
     }
     return nullptr;
   }
 
   // testing::Test:
   void SetUp() override {
+    base::CommandLine::ForCurrentProcess()->AppendSwitchNative(
+        switches::kScreenConfig, "none");
+
     testing::Test::SetUp();
     ui::OzonePlatform::InitializeForUI();
     platform_screen_ = base::MakeUnique<PlatformScreenOzone>();
     platform_screen_->Init(&delegate_);
 
+    // Have all tests start with a 1024x768 display by default.
+    AddDisplay(kDefaultDisplayId, gfx::Size(1024, 768));
+    TriggerOnDisplayModeChanged();
+
     // Double check the expected display exists and clear counters.
     ASSERT_THAT(delegate()->added(), SizeIs(1));
     ASSERT_THAT(delegate_.added()[0], DisplayId(kDefaultDisplayId));
     ASSERT_THAT(delegate_.added()[0], DisplayOrigin("0,0"));
     ASSERT_THAT(delegate_.added()[0], DisplaySize("1024x768"));
     delegate_.Reset();
-
-    // Make the initial list of snapshots match what exists.
-    AddDisplay(kDefaultDisplayId);
   }
 
   void TearDown() override {
     snapshots_.clear();
     delegate_.Reset();
     platform_screen_.reset();
   }
 
   TestPlatformScreenDelegate delegate_;
   std::unique_ptr<PlatformScreenOzone> platform_screen_;
@@ skipping 119 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