Switch to standard integer types in ash/.

ash/display/window_tree_host_manager.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/window_tree_host_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 
@@ skipping 57 matching lines @@
 #endif
 
 namespace ash {
 namespace {
 
 // Primary display stored in global object as it can be
 // accessed after Shell is deleted. A separate display instance is created
 // during the shutdown instead of always keeping two display instances
 // (one here and another one in display_manager) in sync, which is error prone.
 // This is initialized in the constructor, and then in CreatePrimaryHost().
-int64 primary_display_id = -1;
+int64_t primary_display_id = -1;
 
 // Specifies how long the display change should have been disabled
 // after each display change operations.
 // |kCycleDisplayThrottleTimeoutMs| is set to be longer to avoid
 // changing the settings while the system is still configurating
 // displays. It will be overriden by |kAfterDisplayChangeThrottleTimeoutMs|
 // when the display change happens, so the actual timeout is much shorter.
-const int64 kAfterDisplayChangeThrottleTimeoutMs = 500;
-const int64 kCycleDisplayThrottleTimeoutMs = 4000;
-const int64 kSwapDisplayThrottleTimeoutMs = 500;
+const int64_t kAfterDisplayChangeThrottleTimeoutMs = 500;
+const int64_t kCycleDisplayThrottleTimeoutMs = 4000;
+const int64_t kSwapDisplayThrottleTimeoutMs = 500;
 
 #if defined(USE_OZONE) && defined(OS_CHROMEOS)
 // Add 20% more cursor motion on non-integrated displays.
 const float kCursorMultiplierForExternalDisplays = 1.2f;
 #endif
 
 DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
@@ skipping 144 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FocusActivationStore);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayChangeLimiter
 
 WindowTreeHostManager::DisplayChangeLimiter::DisplayChangeLimiter()
     : throttle_timeout_(base::Time::Now()) {}
 
 void WindowTreeHostManager::DisplayChangeLimiter::SetThrottleTimeout(
-    int64 throttle_ms) {
+    int64_t throttle_ms) {
   throttle_timeout_ =
       base::Time::Now() + base::TimeDelta::FromMilliseconds(throttle_ms);
 }
 
 bool WindowTreeHostManager::DisplayChangeLimiter::IsThrottled() const {
   return base::Time::Now() < throttle_timeout_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHostManager
@@ skipping 26 matching lines @@
 
   // Unset the display manager's delegate here because
   // DisplayManager outlives WindowTreeHostManager.
   Shell::GetInstance()->display_manager()->set_delegate(nullptr);
 
   cursor_window_controller_.reset();
   mirror_window_controller_.reset();
 
   Shell::GetScreen()->RemoveObserver(this);
 
-  int64 primary_id = Shell::GetScreen()->GetPrimaryDisplay().id();
+  int64_t primary_id = Shell::GetScreen()->GetPrimaryDisplay().id();
 
   // Delete non primary root window controllers first, then
   // delete the primary root window controller.
   aura::Window::Windows root_windows =
       WindowTreeHostManager::GetAllRootWindows();
   std::vector<RootWindowController*> to_delete;
   RootWindowController* primary_rwc = nullptr;
   for (aura::Window::Windows::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     RootWindowController* rwc = GetRootWindowController(*iter);
@@ skipping 35 matching lines @@
 
 void WindowTreeHostManager::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowTreeHostManager::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 // static
-int64 WindowTreeHostManager::GetPrimaryDisplayId() {
+int64_t WindowTreeHostManager::GetPrimaryDisplayId() {
   CHECK_NE(gfx::Display::kInvalidDisplayID, primary_display_id);
   return primary_display_id;
 }
 
 aura::Window* WindowTreeHostManager::GetPrimaryRootWindow() {
   return GetRootWindowForDisplayId(primary_display_id);
 }
 
-aura::Window* WindowTreeHostManager::GetRootWindowForDisplayId(int64 id) {
+aura::Window* WindowTreeHostManager::GetRootWindowForDisplayId(int64_t id) {
   AshWindowTreeHost* host = GetAshWindowTreeHostForDisplayId(id);
   CHECK(host);
   return GetWindow(host);
 }
 
 AshWindowTreeHost* WindowTreeHostManager::GetAshWindowTreeHostForDisplayId(
-    int64 display_id) {
+    int64_t display_id) {
   CHECK_EQ(1u, window_tree_hosts_.count(display_id)) << "display id = "
                                                      << display_id;
   return window_tree_hosts_[display_id];
 }
 
 void WindowTreeHostManager::CloseChildWindows() {
   for (WindowTreeHostMap::const_iterator it = window_tree_hosts_.begin();
        it != window_tree_hosts_.end(); ++it) {
     aura::Window* root_window = GetWindow(it->second);
     RootWindowController* controller = GetRootWindowController(root_window);
@@ skipping 12 matching lines @@
   aura::Window::Windows windows;
   for (WindowTreeHostMap::const_iterator it = window_tree_hosts_.begin();
        it != window_tree_hosts_.end(); ++it) {
     DCHECK(it->second);
     if (GetRootWindowController(GetWindow(it->second)))
       windows.push_back(GetWindow(it->second));
   }
   return windows;
 }
 
-gfx::Insets WindowTreeHostManager::GetOverscanInsets(int64 display_id) const {
+gfx::Insets WindowTreeHostManager::GetOverscanInsets(int64_t display_id) const {
   return GetDisplayManager()->GetOverscanInsets(display_id);
 }
 
 void WindowTreeHostManager::SetOverscanInsets(
-    int64 display_id,
+    int64_t display_id,
     const gfx::Insets& insets_in_dip) {
   GetDisplayManager()->SetOverscanInsets(display_id, insets_in_dip);
 }
 
 std::vector<RootWindowController*>
 WindowTreeHostManager::GetAllRootWindowControllers() {
   std::vector<RootWindowController*> controllers;
   for (WindowTreeHostMap::const_iterator it = window_tree_hosts_.begin();
        it != window_tree_hosts_.end(); ++it) {
     RootWindowController* controller =
@@ skipping 41 matching lines @@
                      weak_ptr_factory_.GetWeakPtr()));
     } else {
       SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
     }
 #else
     SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
 #endif
   }
 }
 
-void WindowTreeHostManager::SetPrimaryDisplayId(int64 id) {
+void WindowTreeHostManager::SetPrimaryDisplayId(int64_t id) {
   DCHECK_NE(gfx::Display::kInvalidDisplayID, id);
   if (id == gfx::Display::kInvalidDisplayID || primary_display_id == id)
     return;
 
   const gfx::Display& display = GetDisplayManager()->GetDisplayForId(id);
   if (display.is_valid())
     SetPrimaryDisplay(display);
 }
 
 void WindowTreeHostManager::SetPrimaryDisplay(
@@ skipping 57 matching lines @@
   GetDisplayManager()->set_force_bounds_changed(false);
 }
 
 void WindowTreeHostManager::UpdateMouseLocationAfterDisplayChange() {
   // If the mouse is currently on a display in native location,
   // use the same native location. Otherwise find the display closest
   // to the current cursor location in screen coordinates.
 
   gfx::Point point_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
   gfx::Point target_location_in_native;
-  int64 closest_distance_squared = -1;
+  int64_t closest_distance_squared = -1;
   DisplayManager* display_manager = GetDisplayManager();
 
   aura::Window* dst_root_window = nullptr;
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const gfx::Display& display = display_manager->GetDisplayAt(i);
     const DisplayInfo display_info =
         display_manager->GetDisplayInfo(display.id());
     aura::Window* root_window = GetRootWindowForDisplayId(display.id());
     if (display_info.bounds_in_native().Contains(
             cursor_location_in_native_coords_for_restore_)) {
       dst_root_window = root_window;
       target_location_in_native = cursor_location_in_native_coords_for_restore_;
       break;
     }
     gfx::Point center = display.bounds().CenterPoint();
     // Use the distance squared from the center of the dislay. This is not
     // exactly "closest" display, but good enough to pick one
     // appropriate (and there are at most two displays).
     // We don't care about actual distance, only relative to other displays, so
     // using the LengthSquared() is cheaper than Length().
 
-    int64 distance_squared = (center - point_in_screen).LengthSquared();
+    int64_t distance_squared = (center - point_in_screen).LengthSquared();
     if (closest_distance_squared < 0 ||
         closest_distance_squared > distance_squared) {
       aura::Window* root_window = GetRootWindowForDisplayId(display.id());
       ::wm::ConvertPointFromScreen(root_window, &center);
       root_window->GetHost()->ConvertPointToNativeScreen(&center);
       dst_root_window = root_window;
       target_location_in_native = center;
       closest_distance_squared = distance_squared;
     }
   }
 
   gfx::Point target_location_in_root = target_location_in_native;
   dst_root_window->GetHost()->ConvertPointFromNativeScreen(
       &target_location_in_root);
 
 #if defined(USE_OZONE)
   gfx::Point target_location_in_screen = target_location_in_root;
   ::wm::ConvertPointToScreen(dst_root_window, &target_location_in_screen);
   const gfx::Display& target_display =
       display_manager->FindDisplayContainingPoint(target_location_in_screen);
   // If the original location isn't on any of new display, let ozone move
   // the cursor.
   if (!target_display.is_valid())
     return;
-  int64 target_display_id = target_display.id();
+  int64_t target_display_id = target_display.id();
 
   // Do not move the cursor if the cursor's location did not change. This avoids
   // moving (and showing) the cursor:
   // - At startup.
   // - When the device is rotated in maximized mode.
   // |cursor_display_id_for_restore_| is checked to ensure that the cursor is
   // moved when the cursor's native position does not change but the display
   // that it is on has changed. This occurs when swapping the primary display.
   if (target_location_in_native !=
           cursor_location_in_native_coords_for_restore_ ||
@@ skipping 15 matching lines @@
   }
 #else
   dst_root_window->MoveCursorTo(target_location_in_root);
 #endif
 }
 
 bool WindowTreeHostManager::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const aura::Window* root_window = window->GetRootWindow();
-  int64 id = GetRootWindowSettings(root_window)->display_id;
+  int64_t id = GetRootWindowSettings(root_window)->display_id;
   // if id is |kInvaildDisplayID|, it's being deleted.
   DCHECK(id != gfx::Display::kInvalidDisplayID);
   return GetDisplayManager()->UpdateWorkAreaOfDisplay(id, insets);
 }
 
 void WindowTreeHostManager::OnDisplayAdded(const gfx::Display& display) {
 #if defined(OS_CHROMEOS)
   // If we're switching from/to offscreen WTH, we need to
   // create new WTH for primary display instead of reusing.
   if (primary_tree_host_for_replace_ &&
@@ skipping 27 matching lines @@
         ash::Shell::GetInstance()->GetPrimarySystemTray();
     if (old_tray->GetWidget()->IsVisible()) {
       new_tray->SetVisible(true);
       new_tray->GetWidget()->Show();
     }
 
     DeleteHost(to_delete);
 #ifndef NDEBUG
     auto iter = std::find_if(
         window_tree_hosts_.begin(), window_tree_hosts_.end(),
-        [to_delete](const std::pair<int64, AshWindowTreeHost*>& pair) {
+        [to_delete](const std::pair<int64_t, AshWindowTreeHost*>& pair) {
           return pair.second == to_delete;
         });
     DCHECK(iter == window_tree_hosts_.end());
 #endif
     // the host has already been removed from the window_tree_host_.
   } else
 #endif
       // TODO(oshima): It should be possible to consolidate logic for
       // unified and non unified, but I'm keeping them separated to minimize
       // the risk in M44. I'll consolidate this in M45.
@@ skipping 149 matching lines @@
 
   DisplayManager* display_manager = GetDisplayManager();
   DisplayLayoutStore* layout_store = display_manager->layout_store();
   if (display_manager->num_connected_displays() > 1) {
     DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
     DisplayLayout layout = layout_store->GetRegisteredDisplayLayout(pair);
     layout_store->UpdateMultiDisplayState(
         pair, display_manager->IsInMirrorMode(), layout.default_unified);
 
     if (Shell::GetScreen()->GetNumDisplays() > 1) {
-      int64 primary_id = layout.primary_id;
+      int64_t primary_id = layout.primary_id;
       SetPrimaryDisplayId(primary_id == gfx::Display::kInvalidDisplayID
                               ? pair.first
                               : primary_id);
       // Update the primary_id in case the above call is
       // ignored. Happens when a) default layout's primary id
       // doesn't exist, or b) the primary_id has already been
       // set to the same and didn't update it.
       layout_store->UpdatePrimaryDisplayId(
           pair, Shell::GetScreen()->GetPrimaryDisplay().id());
     }
@@ skipping 65 matching lines @@
       ->display_configurator_animation()
       ->StartFadeInAnimation();
 #endif
 }
 
 void WindowTreeHostManager::SetMirrorModeAfterAnimation(bool mirror) {
   GetDisplayManager()->SetMirrorMode(mirror);
 }
 
 }  // namespace ash