Switch to standard integer types in ash/.

ash/display/display_manager_unittest.cc

 // Copyright (c) 2012 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/display_manager.h"
 
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_layout_store.h"
@@ skipping 23 matching lines @@
 
 namespace ash {
 
 using std::vector;
 using std::string;
 
 using base::StringPrintf;
 
 namespace {
 
-std::string ToDisplayName(int64 id) {
+std::string ToDisplayName(int64_t id) {
   return "x-" + base::Int64ToString(id);
 }
 
 }  // namespace
 
 class DisplayManagerTest : public test::AshTestBase,
                            public gfx::DisplayObserver,
                            public aura::WindowObserver {
  public:
   DisplayManagerTest()
@@ skipping 39 matching lines @@
   }
 
   const DisplayInfo& GetDisplayInfo(const gfx::Display& display) {
     return display_manager()->GetDisplayInfo(display.id());
   }
 
   const DisplayInfo& GetDisplayInfoAt(int index) {
     return GetDisplayInfo(display_manager()->GetDisplayAt(index));
   }
 
-  const gfx::Display& GetDisplayForId(int64 id) {
+  const gfx::Display& GetDisplayForId(int64_t id) {
     return display_manager()->GetDisplayForId(id);
   }
 
-  const DisplayInfo& GetDisplayInfoForId(int64 id) {
+  const DisplayInfo& GetDisplayInfoForId(int64_t id) {
     return GetDisplayInfo(display_manager()->GetDisplayForId(id));
   }
 
   // aura::DisplayObserver overrides:
   void OnDisplayMetricsChanged(const gfx::Display& display,
                                uint32_t changed_metrics) override {
     changed_.push_back(display);
     changed_metrics_ |= changed_metrics;
   }
   void OnDisplayAdded(const gfx::Display& new_display) override {
@@ skipping 285 matching lines @@
             GetDisplayInfo(ScreenUtil::GetSecondaryDisplay()).
             bounds_in_native().ToString());
   EXPECT_EQ("0,501 400x400",
             GetDisplayInfo(Shell::GetScreen()->GetPrimaryDisplay()).
             bounds_in_native().ToString());
   EXPECT_EQ("0,0 188x190",
             Shell::GetScreen()->GetPrimaryDisplay().bounds().ToString());
 
   // Make sure just moving the overscan area should property notify observers.
   UpdateDisplay("0+0-500x500");
-  int64 primary_id = Shell::GetScreen()->GetPrimaryDisplay().id();
+  int64_t primary_id = Shell::GetScreen()->GetPrimaryDisplay().id();
   display_manager()->SetOverscanInsets(primary_id, gfx::Insets(0, 0, 20, 20));
   EXPECT_EQ("0,0 480x480",
             Shell::GetScreen()->GetPrimaryDisplay().bounds().ToString());
   reset();
   display_manager()->SetOverscanInsets(primary_id, gfx::Insets(10, 10, 10, 10));
   EXPECT_TRUE(changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(
       changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   EXPECT_EQ("0,0 480x480",
             Shell::GetScreen()->GetPrimaryDisplay().bounds().ToString());
   reset();
   display_manager()->SetOverscanInsets(primary_id, gfx::Insets(0, 0, 0, 0));
   EXPECT_TRUE(changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(
       changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   EXPECT_EQ("0,0 500x500",
             Shell::GetScreen()->GetPrimaryDisplay().bounds().ToString());
 }
 
 TEST_F(DisplayManagerTest, ZeroOverscanInsets) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Make sure the display change events is emitted for overscan inset changes.
   UpdateDisplay("0+0-500x500,0+501-400x400");
   ASSERT_EQ(2u, display_manager()->GetNumDisplays());
-  int64 display2_id = display_manager()->GetDisplayAt(1).id();
+  int64_t display2_id = display_manager()->GetDisplayAt(1).id();
 
   reset();
   display_manager()->SetOverscanInsets(display2_id, gfx::Insets(0, 0, 0, 0));
   EXPECT_EQ(0u, changed().size());
 
   reset();
   display_manager()->SetOverscanInsets(display2_id, gfx::Insets(1, 0, 0, 0));
   EXPECT_EQ(1u, changed().size());
   EXPECT_EQ(display2_id, changed()[0].id());
 
@@ skipping 14 matching lines @@
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
   EXPECT_EQ("1 0 0", GetCountSummary());
 
   UpdateDisplay("1000x600*2");
   EXPECT_EQ(2, host->compositor()->device_scale_factor());
   EXPECT_EQ("2 0 0", GetCountSummary());
   EXPECT_EQ("500x300",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 }
 
-DisplayInfo CreateDisplayInfo(int64 id, const gfx::Rect& bounds) {
+DisplayInfo CreateDisplayInfo(int64_t id, const gfx::Rect& bounds) {
   DisplayInfo info(id, ToDisplayName(id), false);
   info.SetBounds(bounds);
   return info;
 }
 
 TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
-  const int64 internal_display_id =
+  const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
   const int external_id = 10;
   const int mirror_id = 11;
-  const int64 invalid_id = gfx::Display::kInvalidDisplayID;
+  const int64_t invalid_id = gfx::Display::kInvalidDisplayID;
   const DisplayInfo internal_display_info =
       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
   const DisplayInfo external_display_info =
       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
   const DisplayInfo mirroring_display_info =
       CreateDisplayInfo(mirror_id, gfx::Rect(0, 0, 500, 500));
 
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
   std::string default_bounds =
@@ skipping 146 matching lines @@
 }
 
 // Make sure crash does not happen if add and remove happens at the same time.
 // See: crbug.com/414394
 TEST_F(DisplayManagerTest, DisplayAddRemoveAtTheSameTime) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("100+0-500x500,0+501-400x400");
 
-  const int64 primary_id = WindowTreeHostManager::GetPrimaryDisplayId();
-  const int64 secondary_id = ScreenUtil::GetSecondaryDisplay().id();
+  const int64_t primary_id = WindowTreeHostManager::GetPrimaryDisplayId();
+  const int64_t secondary_id = ScreenUtil::GetSecondaryDisplay().id();
 
   DisplayInfo primary_info = display_manager()->GetDisplayInfo(primary_id);
   DisplayInfo secondary_info = display_manager()->GetDisplayInfo(secondary_id);
 
   // An id which is different from primary and secondary.
-  const int64 third_id = secondary_id + 1;
+  const int64_t third_id = secondary_id + 1;
 
   DisplayInfo third_info =
       CreateDisplayInfo(third_id, gfx::Rect(0, 0, 600, 600));
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(third_info);
   display_info_list.push_back(secondary_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   // Secondary seconary_id becomes the primary as it has smaller output index.
@@ skipping 29 matching lines @@
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(10).bounds_in_native().ToString());
   EXPECT_EQ("100x100", ash::Shell::GetPrimaryRootWindow()->GetHost()->
       GetBounds().size().ToString());
 }
 
 TEST_F(DisplayManagerTest, NativeDisplaysChangedAfterPrimaryChange) {
   if (!SupportsMultipleDisplays())
     return;
 
-  const int64 internal_display_id =
+  const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
   const DisplayInfo native_display_info =
       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
   const DisplayInfo secondary_display_info =
       CreateDisplayInfo(10, gfx::Rect(1, 1, 100, 100));
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
   display_info_list.push_back(secondary_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
@@ skipping 179 matching lines @@
   UpdateDisplay("200x200/u");
   EXPECT_EQ("1 0 0", GetCountSummary());
   reset();
 
   UpdateDisplay("200x200/l");
   EXPECT_EQ("1 0 0", GetCountSummary());
 
   // Having the internal display deactivated should restore user rotation. Newly
   // set rotations should be applied.
   UpdateDisplay("200x200, 200x200");
-  const int64 internal_display_id =
+  const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
 
   display_manager()->SetDisplayRotation(internal_display_id,
                                         gfx::Display::ROTATE_90,
                                         gfx::Display::ROTATION_SOURCE_USER);
   display_manager()->SetDisplayRotation(internal_display_id,
                                         gfx::Display::ROTATE_0,
                                         gfx::Display::ROTATION_SOURCE_ACTIVE);
 
   const DisplayInfo info = GetDisplayInfoForId(internal_display_id);
@@ skipping 15 matching lines @@
   const DisplayInfo post_rotation_info =
       display_manager()->display_info_[internal_display_id];
   EXPECT_NE(info.GetActiveRotation(), post_rotation_info.GetActiveRotation());
   EXPECT_EQ(gfx::Display::ROTATE_180, post_rotation_info.GetActiveRotation());
 }
 
 TEST_F(DisplayManagerTest, UIScale) {
   test::ScopedDisable125DSFForUIScaling disable;
 
   UpdateDisplay("1280x800");
-  int64 display_id = Shell::GetScreen()->GetPrimaryDisplay().id();
+  int64_t display_id = Shell::GetScreen()->GetPrimaryDisplay().id();
   SetDisplayUIScale(display_id, 1.125f);
   EXPECT_EQ(1.0, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.75f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.625f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 
   test::ScopedSetInternalDisplayId set_internal(display_id);
@@ skipping 129 matching lines @@
   EXPECT_TRUE(expected_mode.IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.5f);
   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).configured_ui_scale());
   expected_mode.ui_scale = 0.5f;
   EXPECT_TRUE(expected_mode.IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 }
 
 TEST_F(DisplayManagerTest, Use125DSFForUIScaling) {
-  int64 display_id = Shell::GetScreen()->GetPrimaryDisplay().id();
+  int64_t display_id = Shell::GetScreen()->GetPrimaryDisplay().id();
   test::ScopedSetInternalDisplayId set_internal(display_id);
 
   UpdateDisplay("1920x1080*1.25");
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 
   SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
   EXPECT_EQ("1536x864", GetDisplayForId(display_id).size().ToString());
@@ skipping 13 matching lines @@
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   display_manager->SetUnifiedDesktopEnabled(true);
 
   UpdateDisplay("200x200, 400x400");
 
-  int64 unified_id = Shell::GetScreen()->GetPrimaryDisplay().id();
+  int64_t unified_id = Shell::GetScreen()->GetPrimaryDisplay().id();
   DisplayInfo info = display_manager->GetDisplayInfo(unified_id);
   ASSERT_EQ(2u, info.display_modes().size());
   EXPECT_EQ("400x200", info.display_modes()[0].size.ToString());
   EXPECT_TRUE(info.display_modes()[0].native);
   EXPECT_EQ("800x400", info.display_modes()[1].size.ToString());
   EXPECT_FALSE(info.display_modes()[1].native);
   EXPECT_EQ("400x200",
             Shell::GetScreen()->GetPrimaryDisplay().size().ToString());
   DisplayMode active_mode =
       display_manager->GetActiveModeForDisplayId(unified_id);
@@ skipping 646 matching lines @@
   EXPECT_EQ("0,0 250x453", docked->bounds().ToString());
   UpdateDisplay("300x300");
   // Make sure the window is still docked.
   EXPECT_TRUE(wm::GetWindowState(docked.get())->IsDocked());
   EXPECT_EQ("0,0 250x253", docked->bounds().ToString());
 }
 
 TEST_F(DisplayManagerTest, DockMode) {
   if (!SupportsMultipleDisplays())
     return;
-  const int64 internal_id = 1;
-  const int64 external_id = 2;
+  const int64_t internal_id = 1;
+  const int64_t external_id = 2;
 
   const DisplayInfo internal_display_info =
       CreateDisplayInfo(internal_id, gfx::Rect(0, 0, 500, 500));
   const DisplayInfo external_display_info =
       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
   std::vector<DisplayInfo> display_info_list;
 
   // software mirroring.
   display_info_list.push_back(internal_display_info);
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
-  const int64 internal_display_id =
+  const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
   EXPECT_EQ(internal_id, internal_display_id);
 
   display_info_list.clear();
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->active_display_list().size());
 
   EXPECT_TRUE(display_manager()->IsActiveDisplayId(external_id));
   EXPECT_FALSE(display_manager()->IsActiveDisplayId(internal_id));
@@ skipping 175 matching lines @@
 
   EXPECT_EQ(gfx::Display::ROTATE_90,
             info.GetRotation(gfx::Display::ROTATION_SOURCE_USER));
   EXPECT_EQ(gfx::Display::ROTATE_90,
             info.GetRotation(gfx::Display::ROTATION_SOURCE_ACTIVE));
 }
 
 #endif  // OS_CHROMEOS
 
 }  // namespace ash