MD Settings: Display: Add unified desktop control and modify api

chrome/browser/extensions/display_info_provider_chromeos_unittest.cc

 // Copyright 2014 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 "extensions/browser/api/system_display/display_info_provider.h"
 
 #include <stdint.h>
 
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/display/screen_orientation_controller_chromeos.h"
@@ skipping 66 matching lines @@
         "%d,%d,%d,%d", insets.top, insets.left, insets.bottom, insets.right);
   }
 
   std::string SystemInfoDisplayBoundsToString(
       const api::system_display::Bounds& bounds) const {
     // Order to match gfx::Rect::ToString().
     return base::StringPrintf(
         "%d,%d %dx%d", bounds.left, bounds.top, bounds.width, bounds.height);
   }
 
+  DisplayUnitInfoList GetAllDisplaysInfo() {
+    return DisplayInfoProvider::Get()->GetAllDisplaysInfo(
+        false /* single unified */);
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(DisplayInfoProviderChromeosTest);
 };
 
 TEST_F(DisplayInfoProviderChromeosTest, GetBasic) {
   UpdateDisplay("500x600,400x520");
-  DisplayUnitInfoList result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  DisplayUnitInfoList result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
 
   int64_t display_id;
   ASSERT_TRUE(base::StringToInt64(result[0].id, &display_id))
       << "Display id must be convertable to integer: " << result[0].id;
 
   ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
   EXPECT_EQ("0,0 500x600", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[0].overscan));
@@ skipping 20 matching lines @@
   EXPECT_EQ(96, result[1].dpi_y);
   EXPECT_TRUE(result[1].mirroring_source_id.empty());
   EXPECT_TRUE(result[1].is_enabled);
 }
 
 TEST_F(DisplayInfoProviderChromeosTest, GetWithUnifiedDesktop) {
   UpdateDisplay("500x600,400x520");
 
   // Check initial state.
   EXPECT_FALSE(GetDisplayManager()->IsInUnifiedMode());
-  DisplayUnitInfoList result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  DisplayUnitInfoList result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
 
   int64_t display_id;
   ASSERT_TRUE(base::StringToInt64(result[0].id, &display_id))
       << "Display id must be convertable to integer: " << result[0].id;
 
   ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
   EXPECT_EQ("0,0 500x600", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[0].overscan));
   EXPECT_EQ(0, result[0].rotation);
   EXPECT_TRUE(result[0].is_primary);
+  EXPECT_FALSE(result[0].is_unified);
   EXPECT_EQ(96, result[0].dpi_x);
   EXPECT_EQ(96, result[0].dpi_y);
   EXPECT_TRUE(result[0].mirroring_source_id.empty());
   EXPECT_TRUE(result[0].is_enabled);
 
   ASSERT_TRUE(base::StringToInt64(result[1].id, &display_id))
       << "Display id must be convertable to integer: " << result[0].id;
 
   ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
   EXPECT_EQ(GetDisplayManager()->GetDisplayNameForId(display_id),
             result[1].name);
 
   // Initial multipple display configuration.
   EXPECT_EQ("500,0 400x520", SystemInfoDisplayBoundsToString(result[1].bounds));
   EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[1].overscan));
   EXPECT_EQ(0, result[1].rotation);
   EXPECT_FALSE(result[1].is_primary);
+  EXPECT_FALSE(result[0].is_unified);
   EXPECT_EQ(96, result[1].dpi_x);
   EXPECT_EQ(96, result[1].dpi_y);
   EXPECT_TRUE(result[1].mirroring_source_id.empty());
   EXPECT_TRUE(result[1].is_enabled);
 
   // Enable unified.
   GetDisplayManager()->SetUnifiedDesktopEnabled(true);
   EXPECT_TRUE(GetDisplayManager()->IsInUnifiedMode());
 
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
 
   ASSERT_TRUE(base::StringToInt64(result[0].id, &display_id))
       << "Display id must be convertable to integer: " << result[0].id;
 
   EXPECT_EQ("0,0 500x600", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[0].overscan));
   EXPECT_EQ(0, result[0].rotation);
   EXPECT_TRUE(result[0].is_primary);
+  EXPECT_TRUE(result[0].is_unified);
   EXPECT_EQ(96, result[0].dpi_x);
   EXPECT_EQ(96, result[0].dpi_y);
   EXPECT_TRUE(result[0].mirroring_source_id.empty());
   EXPECT_TRUE(result[0].is_enabled);
 
   ASSERT_TRUE(base::StringToInt64(result[1].id, &display_id))
       << "Display id must be convertable to integer: " << result[0].id;
 
   EXPECT_EQ(GetDisplayManager()->GetDisplayNameForId(display_id),
             result[1].name);
 
   // After enabling unified the second display is scaled to meet the height for
   // the first. Which also affects the DPI below.
   EXPECT_EQ("500,0 461x600", SystemInfoDisplayBoundsToString(result[1].bounds));
   EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[1].overscan));
   EXPECT_EQ(0, result[1].rotation);
   EXPECT_FALSE(result[1].is_primary);
+  EXPECT_TRUE(result[1].is_unified);
   EXPECT_FLOAT_EQ(111, round(result[1].dpi_x));
   EXPECT_FLOAT_EQ(111, round(result[1].dpi_y));
   EXPECT_TRUE(result[1].mirroring_source_id.empty());
   EXPECT_TRUE(result[1].is_enabled);
 
   // Disable unified and check that once again it matches initial situation.
   GetDisplayManager()->SetUnifiedDesktopEnabled(false);
   EXPECT_FALSE(GetDisplayManager()->IsInUnifiedMode());
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
 
+  ASSERT_TRUE(base::StringToInt64(result[0].id, &display_id))
+      << "Display id must be convertable to integer: " << result[0].id;
+
+  ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
+  EXPECT_EQ("0,0 500x600", SystemInfoDisplayBoundsToString(result[0].bounds));
+  EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[0].overscan));
+  EXPECT_EQ(0, result[0].rotation);
+  EXPECT_TRUE(result[0].is_primary);
+  EXPECT_FALSE(result[0].is_unified);
+  EXPECT_EQ(96, result[0].dpi_x);
+  EXPECT_EQ(96, result[0].dpi_y);
+  EXPECT_TRUE(result[0].mirroring_source_id.empty());
+  EXPECT_TRUE(result[0].is_enabled);
+
+  ASSERT_TRUE(base::StringToInt64(result[1].id, &display_id))
+      << "Display id must be convertable to integer: " << result[0].id;
+
+  ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
+  EXPECT_EQ(GetDisplayManager()->GetDisplayNameForId(display_id),
+            result[1].name);
+  EXPECT_EQ("500,0 400x520", SystemInfoDisplayBoundsToString(result[1].bounds));
+  EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[1].overscan));
+  EXPECT_EQ(0, result[1].rotation);
+  EXPECT_FALSE(result[1].is_primary);
+  EXPECT_FALSE(result[1].is_unified);
+  EXPECT_EQ(96, result[1].dpi_x);
+  EXPECT_EQ(96, result[1].dpi_y);
+  EXPECT_TRUE(result[1].mirroring_source_id.empty());
+  EXPECT_TRUE(result[1].is_enabled);
+}
+
+TEST_F(DisplayInfoProviderChromeosTest, GetWithUnifiedDesktopForSettings) {
+  UpdateDisplay("500x600,400x520");
+
+  // Check initial state.
+  EXPECT_FALSE(GetDisplayManager()->IsInUnifiedMode());
+  DisplayUnitInfoList result =
+      DisplayInfoProvider::Get()->GetAllDisplaysInfo(true /* single unifed */);
+
+  ASSERT_EQ(2u, result.size());
+
+  int64_t display_id;
+  ASSERT_TRUE(base::StringToInt64(result[0].id, &display_id))
+      << "Display id must be convertable to integer: " << result[0].id;
+
+  ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
+  EXPECT_EQ("0,0 500x600", SystemInfoDisplayBoundsToString(result[0].bounds));
+  EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[0].overscan));
+  EXPECT_EQ(0, result[0].rotation);
+  EXPECT_TRUE(result[0].is_primary);
+  EXPECT_FALSE(result[0].is_unified);
+  EXPECT_EQ(96, result[0].dpi_x);
+  EXPECT_EQ(96, result[0].dpi_y);
+  EXPECT_TRUE(result[0].mirroring_source_id.empty());
+  EXPECT_TRUE(result[0].is_enabled);
+
+  ASSERT_TRUE(base::StringToInt64(result[1].id, &display_id))
+      << "Display id must be convertable to integer: " << result[0].id;
+
+  ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
+  EXPECT_EQ(GetDisplayManager()->GetDisplayNameForId(display_id),
+            result[1].name);
+
+  // Initial multipple display configuration.
+  EXPECT_EQ("500,0 400x520", SystemInfoDisplayBoundsToString(result[1].bounds));
+  EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[1].overscan));
+  EXPECT_EQ(0, result[1].rotation);
+  EXPECT_FALSE(result[1].is_primary);
+  EXPECT_FALSE(result[0].is_unified);
+  EXPECT_EQ(96, result[1].dpi_x);
+  EXPECT_EQ(96, result[1].dpi_y);
+  EXPECT_TRUE(result[1].mirroring_source_id.empty());
+  EXPECT_TRUE(result[1].is_enabled);
+
+  // Enable unified.
+  GetDisplayManager()->SetUnifiedDesktopEnabled(true);
+  EXPECT_TRUE(GetDisplayManager()->IsInUnifiedMode());
+
+  // For settings, GetAllDisplaysInfo will return a single unified display. The
+  // second display will be scaled to match the height of the first, so the
+  // height will be 600 and the new width will be 500 + [400 * 600/520 = 461] =
+  // 961.
+  result = GetAllDisplaysInfo();
+  ASSERT_EQ(1u, result.size());
+  ASSERT_TRUE(base::StringToInt64(result[0].id, &display_id))
+      << "Display id must be convertable to integer: " << result[0].id;
+
+  EXPECT_EQ("0,0 961x600", SystemInfoDisplayBoundsToString(result[0].bounds));
+  EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[0].overscan));
+  EXPECT_EQ(0, result[0].rotation);
+  EXPECT_TRUE(result[0].is_primary);
+  EXPECT_TRUE(result[0].is_unified);
+  EXPECT_EQ(96, result[0].dpi_x);
+  EXPECT_EQ(96, result[0].dpi_y);
+  EXPECT_TRUE(result[0].mirroring_source_id.empty());
+  EXPECT_TRUE(result[0].is_enabled);
+
+  // Disable unified and check that once again it matches initial situation.
+  GetDisplayManager()->SetUnifiedDesktopEnabled(false);
+  EXPECT_FALSE(GetDisplayManager()->IsInUnifiedMode());
+  result = GetAllDisplaysInfo();
+
+  ASSERT_EQ(2u, result.size());
+
   ASSERT_TRUE(base::StringToInt64(result[0].id, &display_id))
       << "Display id must be convertable to integer: " << result[0].id;
 
   ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
   EXPECT_EQ("0,0 500x600", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[0].overscan));
   EXPECT_EQ(0, result[0].rotation);
   EXPECT_TRUE(result[0].is_primary);
+  EXPECT_FALSE(result[0].is_unified);
   EXPECT_EQ(96, result[0].dpi_x);
   EXPECT_EQ(96, result[0].dpi_y);
   EXPECT_TRUE(result[0].mirroring_source_id.empty());
   EXPECT_TRUE(result[0].is_enabled);
 
   ASSERT_TRUE(base::StringToInt64(result[1].id, &display_id))
       << "Display id must be convertable to integer: " << result[0].id;
 
   ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
   EXPECT_EQ(GetDisplayManager()->GetDisplayNameForId(display_id),
             result[1].name);
   EXPECT_EQ("500,0 400x520", SystemInfoDisplayBoundsToString(result[1].bounds));
   EXPECT_EQ("0,0,0,0", SystemInfoDisplayInsetsToString(result[1].overscan));
   EXPECT_EQ(0, result[1].rotation);
   EXPECT_FALSE(result[1].is_primary);
+  EXPECT_FALSE(result[1].is_unified);
   EXPECT_EQ(96, result[1].dpi_x);
   EXPECT_EQ(96, result[1].dpi_y);
   EXPECT_TRUE(result[1].mirroring_source_id.empty());
   EXPECT_TRUE(result[1].is_enabled);
 }
 
 TEST_F(DisplayInfoProviderChromeosTest, GetRotation) {
   UpdateDisplay("500x600/r");
-  DisplayUnitInfoList result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  DisplayUnitInfoList result = GetAllDisplaysInfo();
 
   ASSERT_EQ(1u, result.size());
 
   int64_t display_id;
   ASSERT_TRUE(base::StringToInt64(result[0].id, &display_id))
       << "Display id must be convertable to integer: " << result[0].id;
 
   ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
   EXPECT_EQ("0,0 600x500", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ(90, result[0].rotation);
 
   GetDisplayManager()->SetDisplayRotation(
       display_id, display::Display::ROTATE_270,
       display::Display::ROTATION_SOURCE_ACTIVE);
 
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(1u, result.size());
 
   EXPECT_EQ(base::Int64ToString(display_id), result[0].id);
   EXPECT_EQ("0,0 600x500", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ(270, result[0].rotation);
 
   GetDisplayManager()->SetDisplayRotation(
       display_id, display::Display::ROTATE_180,
       display::Display::ROTATION_SOURCE_ACTIVE);
 
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(1u, result.size());
 
   EXPECT_EQ(base::Int64ToString(display_id), result[0].id);
   EXPECT_EQ("0,0 500x600", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ(180, result[0].rotation);
 
   GetDisplayManager()->SetDisplayRotation(
       display_id, display::Display::ROTATE_0,
       display::Display::ROTATION_SOURCE_ACTIVE);
 
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(1u, result.size());
 
   EXPECT_EQ(base::Int64ToString(display_id), result[0].id);
   EXPECT_EQ("0,0 500x600", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ(0, result[0].rotation);
 }
 
 TEST_F(DisplayInfoProviderChromeosTest, GetDPI) {
   UpdateDisplay("500x600,400x520*2");
   DisplayUnitInfoList result;
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
 
   EXPECT_EQ("0,0 500x600", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ(96, result[0].dpi_x);
   EXPECT_EQ(96, result[0].dpi_y);
 
   EXPECT_EQ("500,0 200x260", SystemInfoDisplayBoundsToString(result[1].bounds));
   // DPI should be 96 (native dpi) * 200 (display) / 400 (native) when ui scale
   // is 2.
   EXPECT_EQ(96 / 2, result[1].dpi_x);
   EXPECT_EQ(96 / 2, result[1].dpi_y);
 
   SwapPrimaryDisplay();
 
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
 
   EXPECT_EQ("-500,0 500x600",
             SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ(96, result[0].dpi_x);
   EXPECT_EQ(96, result[0].dpi_y);
 
   EXPECT_EQ("0,0 200x260", SystemInfoDisplayBoundsToString(result[1].bounds));
   EXPECT_EQ(96 / 2, result[1].dpi_x);
   EXPECT_EQ(96 / 2, result[1].dpi_y);
 }
 
 TEST_F(DisplayInfoProviderChromeosTest, GetVisibleArea) {
   UpdateDisplay("640x720*2/o, 400x520/o");
   DisplayUnitInfoList result;
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
 
   int64_t display_id;
   ASSERT_TRUE(base::StringToInt64(result[1].id, &display_id))
       << "Display id must be convertable to integer: " << result[1].id;
   ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
 
   // Default overscan is 5%.
   EXPECT_EQ("304,0 380x494", SystemInfoDisplayBoundsToString(result[1].bounds));
   EXPECT_EQ("13,10,13,10", SystemInfoDisplayInsetsToString(result[1].overscan));
 
   GetDisplayManager()->SetOverscanInsets(display_id,
                                          gfx::Insets(20, 30, 50, 60));
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
 
   EXPECT_EQ(base::Int64ToString(display_id), result[1].id);
   EXPECT_EQ("304,0 310x450", SystemInfoDisplayBoundsToString(result[1].bounds));
   EXPECT_EQ("20,30,50,60", SystemInfoDisplayInsetsToString(result[1].overscan));
 
   // Set insets for the primary screen. Note that it has 2x scale.
   ASSERT_TRUE(base::StringToInt64(result[0].id, &display_id))
       << "Display id must be convertable to integer: " << result[0].id;
   ASSERT_TRUE(DisplayExists(display_id)) << display_id << " not found";
 
   EXPECT_EQ("0,0 304x342", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ("9,8,9,8", SystemInfoDisplayInsetsToString(result[0].overscan));
 
   GetDisplayManager()->SetOverscanInsets(display_id,
                                          gfx::Insets(10, 20, 30, 40));
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
 
   EXPECT_EQ(base::Int64ToString(display_id), result[0].id);
   EXPECT_EQ("0,0 260x320", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ("10,20,30,40", SystemInfoDisplayInsetsToString(result[0].overscan));
 }
 
 TEST_F(DisplayInfoProviderChromeosTest, GetMirroring) {
   UpdateDisplay("600x600, 400x520/o");
   DisplayUnitInfoList result;
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
 
   int64_t display_id_primary;
   ASSERT_TRUE(base::StringToInt64(result[0].id, &display_id_primary))
       << "Display id must be convertable to integer: " << result[0].id;
   ASSERT_TRUE(DisplayExists(display_id_primary)) << display_id_primary
                                                  << " not found";
 
   int64_t display_id_secondary;
   ASSERT_TRUE(base::StringToInt64(result[1].id, &display_id_secondary))
       << "Display id must be convertable to integer: " << result[1].id;
   ASSERT_TRUE(DisplayExists(display_id_secondary)) << display_id_secondary
                                                    << " not found";
 
   ASSERT_FALSE(GetDisplayManager()->IsInMirrorMode());
   EXPECT_TRUE(result[0].mirroring_source_id.empty());
   EXPECT_TRUE(result[1].mirroring_source_id.empty());
 
   GetDisplayManager()->SetMirrorMode(true);
   ASSERT_TRUE(GetDisplayManager()->IsInMirrorMode());
 
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ(base::Int64ToString(display_id_primary), result[0].id);
   EXPECT_EQ(base::Int64ToString(display_id_secondary),
             result[0].mirroring_source_id);
 
   GetDisplayManager()->SetMirrorMode(false);
   ASSERT_FALSE(GetDisplayManager()->IsInMirrorMode());
 
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
   EXPECT_EQ(base::Int64ToString(display_id_primary), result[0].id);
   EXPECT_TRUE(result[0].mirroring_source_id.empty());
   EXPECT_EQ(base::Int64ToString(display_id_secondary), result[1].id);
   EXPECT_TRUE(result[1].mirroring_source_id.empty());
 }
 
 TEST_F(DisplayInfoProviderChromeosTest, GetBounds) {
   UpdateDisplay("600x600, 400x520");
   GetDisplayManager()->SetLayoutForCurrentDisplays(
       display::test::CreateDisplayLayout(display_manager(),
                                          display::DisplayPlacement::LEFT, -40));
 
-  DisplayUnitInfoList result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  DisplayUnitInfoList result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
   EXPECT_EQ("0,0 600x600", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ("-400,-40 400x520",
             SystemInfoDisplayBoundsToString(result[1].bounds));
 
   GetDisplayManager()->SetLayoutForCurrentDisplays(
       display::test::CreateDisplayLayout(display_manager(),
                                          display::DisplayPlacement::TOP, 40));
 
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
 
   ASSERT_EQ(2u, result.size());
   EXPECT_EQ("0,0 600x600", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ("40,-520 400x520",
             SystemInfoDisplayBoundsToString(result[1].bounds));
 
   GetDisplayManager()->SetLayoutForCurrentDisplays(
       display::test::CreateDisplayLayout(
           display_manager(), display::DisplayPlacement::BOTTOM, 80));
 
-  result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  result = GetAllDisplaysInfo();
   ASSERT_EQ(2u, result.size());
   EXPECT_EQ("0,0 600x600", SystemInfoDisplayBoundsToString(result[0].bounds));
   EXPECT_EQ("80,600 400x520",
             SystemInfoDisplayBoundsToString(result[1].bounds));
 }
 
 TEST_F(DisplayInfoProviderChromeosTest, Layout) {
   UpdateDisplay("500x400,500x400,500x400");
 
-  DisplayUnitInfoList displays =
-      DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  DisplayUnitInfoList displays = GetAllDisplaysInfo();
   std::string primary_id = displays[0].id;
   ASSERT_EQ(3u, displays.size());
 
   DisplayLayoutList layout = DisplayInfoProvider::Get()->GetDisplayLayout();
 
   ASSERT_EQ(2u, layout.size());
 
   // Confirm layout.
   EXPECT_EQ(displays[1].id, layout[0].id);
   EXPECT_EQ(primary_id, layout[0].parent_id);
@@ skipping 681 matching lines @@
   CallSetDisplayUnitInfo(
       base::Int64ToString(internal_display_id), info, &success, &error);
 
   ASSERT_FALSE(success);
   EXPECT_EQ("Overscan changes not allowed for the internal monitor.", error);
 }
 
 TEST_F(DisplayInfoProviderChromeosTest, DisplayMode) {
   UpdateDisplay("1200x600,600x1000");
 
-  DisplayUnitInfoList result = DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  DisplayUnitInfoList result = GetAllDisplaysInfo();
   ASSERT_GE(result.size(), 1u);
   const api::system_display::DisplayUnitInfo& primary_info = result[0];
   // Ensure that we have two modes for the primary display so that we can
   // test chaning modes.
   ASSERT_GE(primary_info.modes.size(), 2u);
 
   // Get the currently active mode and one other mode to switch to.
   int64_t id;
   base::StringToInt64(primary_info.id, &id);
   scoped_refptr<display::ManagedDisplayMode> active_mode =
@@ skipping 281 matching lines @@
   EXPECT_EQ(pairs.pair1.touch_point.y, data.point_pairs[0].second.y());
   EXPECT_EQ(pairs.pair2.touch_point.y, data.point_pairs[1].second.y());
   EXPECT_EQ(pairs.pair3.touch_point.y, data.point_pairs[2].second.y());
   EXPECT_EQ(pairs.pair4.touch_point.y, data.point_pairs[3].second.y());
 
   EXPECT_EQ(bounds.width, data.bounds.width());
   EXPECT_EQ(bounds.height, data.bounds.height());
 }
 }  // namespace
 }  // namespace extensions