Read compositor VSync information from platform, when possible

ash/display/resolution_notification_controller_unittest.cc

 // Copyright 2013 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 "ash/display/resolution_notification_controller.h"
 
 #include "ash/display/display_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
@@ skipping 139 matching lines @@
   int accept_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ResolutionNotificationControllerTest);
 };
 
 // Basic behaviors and verifies it doesn't cause crashes.
 TEST_F(ResolutionNotificationControllerTest, Basic) {
   if (!SupportsMultipleDisplays())
     return;
 
-  UpdateDisplay("300x300#300x300|200x200,250x250#250x250|200x200");
+  UpdateDisplay("300x300#300x300%57|200x200%58,250x250#250x250%59|200x200%60");
   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
   ash::internal::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   ASSERT_EQ(0, accept_count());
   EXPECT_FALSE(IsNotificationVisible());
 
   // Changes the resolution and apply the result.
   SetDisplayResolutionAndNotify(
       ScreenUtil::GetSecondaryDisplay(), gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
   EXPECT_FALSE(controller()->DoesNotificationTimeout());
   EXPECT_EQ(ExpectedNotificationMessage(id2, gfx::Size(200, 200)),
             GetNotificationMessage());
-  gfx::Size resolution;
-  EXPECT_TRUE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
-  EXPECT_EQ("200x200", resolution.ToString());
+  DisplayMode mode;
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
+  EXPECT_EQ("200x200", mode.size.ToString());
+  EXPECT_EQ(60.0, mode.refresh_rate);
 
   // Click the revert button, which reverts to the best resolution.
   ClickOnNotificationButton(0);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(0, accept_count());
-  EXPECT_FALSE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
+  EXPECT_EQ("250x250", mode.size.ToString());
+  EXPECT_EQ(59.0, mode.refresh_rate);
 }
 
 TEST_F(ResolutionNotificationControllerTest, ClickMeansAccept) {
   if (!SupportsMultipleDisplays())
     return;
 
-  UpdateDisplay("300x300#300x300|200x200,250x250#250x250|200x200");
+  UpdateDisplay("300x300#300x300%57|200x200%58,250x250#250x250%59|200x200%60");
   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
   ash::internal::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   ASSERT_EQ(0, accept_count());
   EXPECT_FALSE(IsNotificationVisible());
 
   // Changes the resolution and apply the result.
   SetDisplayResolutionAndNotify(
       ScreenUtil::GetSecondaryDisplay(), gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
   EXPECT_FALSE(controller()->DoesNotificationTimeout());
-  gfx::Size resolution;
-  EXPECT_TRUE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
-  EXPECT_EQ("200x200", resolution.ToString());
+  DisplayMode mode;
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
+  EXPECT_EQ("200x200", mode.size.ToString());
+  EXPECT_EQ(60.0, mode.refresh_rate);
 
   // Click the revert button, which reverts the resolution.
   ClickOnNotification();
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(1, accept_count());
-  EXPECT_TRUE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
-  EXPECT_EQ("200x200", resolution.ToString());
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
+  EXPECT_EQ("200x200", mode.size.ToString());
+  EXPECT_EQ(60.0, mode.refresh_rate);
 }
 
 TEST_F(ResolutionNotificationControllerTest, AcceptButton) {
   if (!SupportsMultipleDisplays())
     return;
 
   ash::internal::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
 
-  UpdateDisplay("300x300#300x300|200x200");
+  UpdateDisplay("300x300#300x300%59|200x200%60");
   const gfx::Display& display = ash::Shell::GetScreen()->GetPrimaryDisplay();
   SetDisplayResolutionAndNotify(display, gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
 
   // If there's a single display only, it will have timeout and the first button
   // becomes accept.
   EXPECT_TRUE(controller()->DoesNotificationTimeout());
   ClickOnNotificationButton(0);
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(1, accept_count());
-  gfx::Size resolution;
-  EXPECT_TRUE(display_manager->GetSelectedResolutionForDisplayId(
-      display.id(), &resolution));
-  EXPECT_EQ("200x200", resolution.ToString());
+  DisplayMode mode;
+  EXPECT_TRUE(
+      display_manager->GetSelectedModeForDisplayId(display.id(), &mode));
+  EXPECT_EQ("200x200", mode.size.ToString());
+  EXPECT_EQ(60.0f, mode.refresh_rate);
 
   // In that case the second button is revert.
-  UpdateDisplay("300x300#300x300|200x200");
+  UpdateDisplay("300x300#300x300%59|200x200%60");
   SetDisplayResolutionAndNotify(display, gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
 
   EXPECT_TRUE(controller()->DoesNotificationTimeout());
   ClickOnNotificationButton(1);
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(1, accept_count());
-  EXPECT_FALSE(display_manager->GetSelectedResolutionForDisplayId(
-      display.id(), &resolution));
+  EXPECT_TRUE(
+      display_manager->GetSelectedModeForDisplayId(display.id(), &mode));
+  EXPECT_EQ("300x300", mode.size.ToString());
+  EXPECT_EQ(59.0f, mode.refresh_rate);
 }
 
 TEST_F(ResolutionNotificationControllerTest, Close) {
   if (!SupportsMultipleDisplays())
     return;
 
-  UpdateDisplay("100x100,150x150#150x150|200x200");
+  UpdateDisplay("100x100,150x150#150x150%59|200x200%60");
   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
   ash::internal::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   ASSERT_EQ(0, accept_count());
   EXPECT_FALSE(IsNotificationVisible());
 
   // Changes the resolution and apply the result.
   SetDisplayResolutionAndNotify(
       ScreenUtil::GetSecondaryDisplay(), gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
   EXPECT_FALSE(controller()->DoesNotificationTimeout());
-  gfx::Size resolution;
-  EXPECT_TRUE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
-  EXPECT_EQ("200x200", resolution.ToString());
+  DisplayMode mode;
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
+  EXPECT_EQ("200x200", mode.size.ToString());
+  EXPECT_EQ(60.0f, mode.refresh_rate);
 
   // Close the notification (imitates clicking [x] button). Also verifies if
   // this does not cause a crash.  See crbug.com/271784
   CloseNotification();
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(1, accept_count());
 }
 
 TEST_F(ResolutionNotificationControllerTest, Timeout) {
   if (!SupportsMultipleDisplays())
     return;
 
-  UpdateDisplay("300x300#300x300|200x200");
+  UpdateDisplay("300x300#300x300%59|200x200%60");
   const gfx::Display& display = ash::Shell::GetScreen()->GetPrimaryDisplay();
   SetDisplayResolutionAndNotify(display, gfx::Size(200, 200));
 
   for (int i = 0; i < ResolutionNotificationController::kTimeoutInSec; ++i) {
     EXPECT_TRUE(IsNotificationVisible()) << "notification is closed after "
                                          << i << "-th timer tick";
     TickTimer();
     RunAllPendingInMessageLoop();
   }
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(0, accept_count());
-  gfx::Size resolution;
   ash::internal::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
-  EXPECT_FALSE(display_manager->GetSelectedResolutionForDisplayId(
-      display.id(), &resolution));
+  DisplayMode mode;
+  EXPECT_TRUE(
+      display_manager->GetSelectedModeForDisplayId(display.id(), &mode));
+  EXPECT_EQ("300x300", mode.size.ToString());
+  EXPECT_EQ(59.0f, mode.refresh_rate);
 }
 
 TEST_F(ResolutionNotificationControllerTest, DisplayDisconnected) {
   if (!SupportsMultipleDisplays())
     return;
 
-  UpdateDisplay("300x300#300x300|200x200,200x200#250x250|200x200|100x100");
+  UpdateDisplay("300x300#300x300%56|200x200%57,"
+                "200x200#250x250%58|200x200%59|100x100%60");
   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
   ash::internal::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   SetDisplayResolutionAndNotify(
       ScreenUtil::GetSecondaryDisplay(), gfx::Size(100, 100));
   ASSERT_TRUE(IsNotificationVisible());
 
   // Disconnects the secondary display and verifies it doesn't cause crashes.
-  UpdateDisplay("300x300#300x300|200x200");
+  UpdateDisplay("300x300#300x300%56|200x200%57");
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(0, accept_count());
+  DisplayMode mode;
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
   gfx::Size resolution;
-  EXPECT_TRUE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
-  EXPECT_EQ("200x200", resolution.ToString());
+  EXPECT_EQ("200x200", mode.size.ToString());
+  EXPECT_EQ(59.0f, mode.refresh_rate);
 }
 
 TEST_F(ResolutionNotificationControllerTest, MultipleResolutionChange) {
   if (!SupportsMultipleDisplays())
     return;
 
-  UpdateDisplay("300x300#300x300|200x200,250x250#250x250|200x200");
+  UpdateDisplay("300x300#300x300%56|200x200%57,"
+                "250x250#250x250%58|200x200%59");
   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
   ash::internal::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
 
   SetDisplayResolutionAndNotify(
       ScreenUtil::GetSecondaryDisplay(), gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
   EXPECT_FALSE(controller()->DoesNotificationTimeout());
-  gfx::Size resolution;
-  EXPECT_TRUE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
-  EXPECT_EQ("200x200", resolution.ToString());
+  DisplayMode mode;
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
+  EXPECT_EQ("200x200", mode.size.ToString());
+  EXPECT_EQ(59.0f, mode.refresh_rate);
 
   // Invokes SetDisplayResolutionAndNotify during the previous notification is
   // visible.
   SetDisplayResolutionAndNotify(
       ScreenUtil::GetSecondaryDisplay(), gfx::Size(250, 250));
-  EXPECT_FALSE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
+  EXPECT_EQ("250x250", mode.size.ToString());
+  EXPECT_EQ(58.0f, mode.refresh_rate);
 
   // Then, click the revert button. Although |old_resolution| for the second
   // SetDisplayResolutionAndNotify is 200x200, it should revert to the original
-  // size 150x150.
+  // size 250x250.
   ClickOnNotificationButton(0);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(0, accept_count());
-  EXPECT_FALSE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
+  EXPECT_EQ("250x250", mode.size.ToString());
+  EXPECT_EQ(58.0f, mode.refresh_rate);
 }
 
 TEST_F(ResolutionNotificationControllerTest, Fallback) {
   if (!SupportsMultipleDisplays())
     return;
 
-  UpdateDisplay("300x300#300x300|200x200,250x250#250x250|220x220|200x200");
+  UpdateDisplay("300x300#300x300%56|200x200%57,"
+                "250x250#250x250%58|220x220%59|200x200%60");
   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
   ash::internal::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   ASSERT_EQ(0, accept_count());
   EXPECT_FALSE(IsNotificationVisible());
 
   // Changes the resolution and apply the result.
   SetDisplayResolutionAndNotifyWithResolution(
       ScreenUtil::GetSecondaryDisplay(),
       gfx::Size(220, 220),
       gfx::Size(200, 200));
   EXPECT_TRUE(IsNotificationVisible());
   EXPECT_FALSE(controller()->DoesNotificationTimeout());
   EXPECT_EQ(
       ExpectedFallbackNotificationMessage(
           id2, gfx::Size(220, 220), gfx::Size(200, 200)),
       GetNotificationMessage());
-  gfx::Size resolution;
-  EXPECT_TRUE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
-  EXPECT_EQ("200x200", resolution.ToString());
+  DisplayMode mode;
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
+  EXPECT_EQ("200x200", mode.size.ToString());
+  EXPECT_EQ(60.0f, mode.refresh_rate);
 
   // Click the revert button, which reverts to the best resolution.
   ClickOnNotificationButton(0);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsNotificationVisible());
   EXPECT_EQ(0, accept_count());
-  EXPECT_FALSE(
-      display_manager->GetSelectedResolutionForDisplayId(id2, &resolution));
+  EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
+  EXPECT_EQ("250x250", mode.size.ToString());
+  EXPECT_EQ(58.0f, mode.refresh_rate);
 }
 
 }  // namespace internal
 }  // namespace ash