Switch to standard integer types in ash/.

ash/display/display_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/display_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <string>
@@ skipping 83 matching lines @@
 
 void SetInternalDisplayModeList(DisplayInfo* info) {
   DisplayMode native_mode;
   native_mode.size = info->bounds_in_native().size();
   native_mode.device_scale_factor = info->device_scale_factor();
   native_mode.ui_scale = 1.0f;
   info->SetDisplayModes(CreateInternalDisplayModeList(native_mode));
 }
 
 void MaybeInitInternalDisplay(DisplayInfo* info) {
-  int64 id = info->id();
+  int64_t id = info->id();
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshUseFirstDisplayAsInternal)) {
     gfx::Display::SetInternalDisplayId(id);
     SetInternalDisplayModeList(info);
   }
 }
 
 gfx::Size GetMaxNativeSize(const DisplayInfo& info) {
   gfx::Size size;
   for (auto& mode : info.display_modes()) {
     if (mode.size.GetArea() > size.GetArea())
       size = mode.size;
   }
   return size;
 }
 
 }  // namespace
 
 using std::string;
 using std::vector;
 
 // static
-int64 DisplayManager::kUnifiedDisplayId = -10;
+int64_t DisplayManager::kUnifiedDisplayId = -10;
 
 DisplayManager::DisplayManager()
     : delegate_(NULL),
       screen_(new ScreenAsh),
       layout_store_(new DisplayLayoutStore),
       first_display_id_(gfx::Display::kInvalidDisplayID),
       num_connected_displays_(0),
       force_bounds_changed_(false),
       change_display_upon_host_resize_(false),
       multi_display_mode_(EXTENDED),
@@ skipping 139 matching lines @@
     // on the secondary.
     screen_->NotifyMetricsChanged(
         ScreenUtil::GetSecondaryDisplay(),
         gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS |
             gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
     if (delegate_)
       delegate_->PostDisplayConfigurationChange();
   }
 }
 
-const gfx::Display& DisplayManager::GetDisplayForId(int64 id) const {
+const gfx::Display& DisplayManager::GetDisplayForId(int64_t id) const {
   gfx::Display* display =
       const_cast<DisplayManager*>(this)->FindDisplayForId(id);
   return display ? *display : GetInvalidDisplay();
 }
 
 const gfx::Display& DisplayManager::FindDisplayContainingPoint(
     const gfx::Point& point_in_screen) const {
   int index =
       FindDisplayIndexContainingPoint(active_display_list_, point_in_screen);
   return index < 0 ? GetInvalidDisplay() : active_display_list_[index];
 }
 
-bool DisplayManager::UpdateWorkAreaOfDisplay(int64 display_id,
+bool DisplayManager::UpdateWorkAreaOfDisplay(int64_t display_id,
                                              const gfx::Insets& insets) {
   gfx::Display* display = FindDisplayForId(display_id);
   DCHECK(display);
   gfx::Rect old_work_area = display->work_area();
   display->UpdateWorkAreaFromInsets(insets);
   return old_work_area != display->work_area();
 }
 
-void DisplayManager::SetOverscanInsets(int64 display_id,
+void DisplayManager::SetOverscanInsets(int64_t display_id,
                                        const gfx::Insets& insets_in_dip) {
   bool update = false;
   DisplayInfoList display_info_list;
   for (const auto& display : active_display_list_) {
     DisplayInfo info = GetDisplayInfo(display.id());
     if (info.id() == display_id) {
       if (insets_in_dip.IsEmpty()) {
         info.set_clear_overscan_insets(true);
       } else {
         info.set_clear_overscan_insets(false);
         info.SetOverscanInsets(insets_in_dip);
       }
       update = true;
     }
     display_info_list.push_back(info);
   }
   if (update) {
     AddMirrorDisplayInfoIfAny(&display_info_list);
     UpdateDisplays(display_info_list);
   } else {
     display_info_[display_id].SetOverscanInsets(insets_in_dip);
   }
 }
 
-void DisplayManager::SetDisplayRotation(int64 display_id,
+void DisplayManager::SetDisplayRotation(int64_t display_id,
                                         gfx::Display::Rotation rotation,
                                         gfx::Display::RotationSource source) {
   if (IsInUnifiedMode())
     return;
 
   DisplayInfoList display_info_list;
   bool is_active = false;
   for (const auto& display : active_display_list_) {
     DisplayInfo info = GetDisplayInfo(display.id());
     if (info.id() == display_id) {
       if (info.GetRotation(source) == rotation &&
           info.GetActiveRotation() == rotation) {
         return;
       }
       info.SetRotation(rotation, source);
       is_active = true;
     }
     display_info_list.push_back(info);
   }
   if (is_active) {
     AddMirrorDisplayInfoIfAny(&display_info_list);
     UpdateDisplays(display_info_list);
   } else if (display_info_.find(display_id) != display_info_.end()) {
     // Inactive displays can reactivate, ensure they have been updated.
     display_info_[display_id].SetRotation(rotation, source);
   }
 }
 
-bool DisplayManager::SetDisplayMode(int64 display_id,
+bool DisplayManager::SetDisplayMode(int64_t display_id,
                                     const DisplayMode& display_mode) {
   bool change_ui_scale = GetDisplayIdForUIScaling() == display_id;
 
   DisplayInfoList display_info_list;
   bool display_property_changed = false;
   bool resolution_changed = false;
   for (const auto& display : active_display_list_) {
     DisplayInfo info = GetDisplayInfo(display.id());
     if (info.id() == display_id) {
       auto iter = FindDisplayMode(info, display_mode);
@@ skipping 30 matching lines @@
     ReconfigureDisplays();
 #if defined(OS_CHROMEOS)
   } else if (resolution_changed && base::SysInfo::IsRunningOnChromeOS()) {
     Shell::GetInstance()->display_configurator()->OnConfigurationChanged();
 #endif
   }
   return resolution_changed || display_property_changed;
 }
 
 void DisplayManager::RegisterDisplayProperty(
-    int64 display_id,
+    int64_t display_id,
     gfx::Display::Rotation rotation,
     float ui_scale,
     const gfx::Insets* overscan_insets,
     const gfx::Size& resolution_in_pixels,
     float device_scale_factor,
     ui::ColorCalibrationProfile color_profile) {
   if (display_info_.find(display_id) == display_info_.end())
     display_info_[display_id] = DisplayInfo(display_id, std::string(), false);
 
   // Do not allow rotation in unified desktop mode.
@@ skipping 15 matching lines @@
   if (!resolution_in_pixels.IsEmpty()) {
     DCHECK(!gfx::Display::IsInternalDisplayId(display_id));
     // Default refresh rate, until OnNativeDisplaysChanged() updates us with the
     // actual display info, is 60 Hz.
     DisplayMode mode(resolution_in_pixels, 60.0f, false, false);
     mode.device_scale_factor = device_scale_factor;
     display_modes_[display_id] = mode;
   }
 }
 
-DisplayMode DisplayManager::GetActiveModeForDisplayId(int64 display_id) const {
+DisplayMode DisplayManager::GetActiveModeForDisplayId(
+    int64_t display_id) const {
   DisplayMode selected_mode;
   if (GetSelectedModeForDisplayId(display_id, &selected_mode))
     return selected_mode;
 
   // If 'selected' mode is empty, it should return the default mode. This means
   // the native mode for the external display. Unfortunately this is not true
   // for the internal display because restoring UI-scale doesn't register the
   // restored mode to |display_mode_|, so it needs to look up the mode whose
   // UI-scale value matches. See the TODO in RegisterDisplayProperty().
   const DisplayInfo& info = GetDisplayInfo(display_id);
@@ skipping 12 matching lines @@
 void DisplayManager::RegisterDisplayRotationProperties(bool rotation_lock,
     gfx::Display::Rotation rotation) {
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(false);
   registered_internal_display_rotation_lock_ = rotation_lock;
   registered_internal_display_rotation_ = rotation;
   if (delegate_)
     delegate_->PostDisplayConfigurationChange();
 }
 
-bool DisplayManager::GetSelectedModeForDisplayId(int64 id,
+bool DisplayManager::GetSelectedModeForDisplayId(int64_t id,
                                                  DisplayMode* mode_out) const {
-  std::map<int64, DisplayMode>::const_iterator iter = display_modes_.find(id);
+  std::map<int64_t, DisplayMode>::const_iterator iter = display_modes_.find(id);
   if (iter == display_modes_.end())
     return false;
   *mode_out = iter->second;
   return true;
 }
 
 bool DisplayManager::IsDisplayUIScalingEnabled() const {
   return GetDisplayIdForUIScaling() != gfx::Display::kInvalidDisplayID;
 }
 
-gfx::Insets DisplayManager::GetOverscanInsets(int64 display_id) const {
-  std::map<int64, DisplayInfo>::const_iterator it =
+gfx::Insets DisplayManager::GetOverscanInsets(int64_t display_id) const {
+  std::map<int64_t, DisplayInfo>::const_iterator it =
       display_info_.find(display_id);
   return (it != display_info_.end()) ?
       it->second.overscan_insets_in_dip() : gfx::Insets();
 }
 
 void DisplayManager::SetColorCalibrationProfile(
-    int64 display_id,
+    int64_t display_id,
     ui::ColorCalibrationProfile profile) {
 #if defined(OS_CHROMEOS)
   if (!display_info_[display_id].IsColorProfileAvailable(profile))
     return;
 
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(false);
   // Just sets color profile if it's not running on ChromeOS (like tests).
   if (!base::SysInfo::IsRunningOnChromeOS() ||
       Shell::GetInstance()->display_configurator()->SetColorCalibrationProfile(
@@ skipping 348 matching lines @@
     return active_display_list_[0];
   DisplayLayout layout = layout_store_->GetRegisteredDisplayLayout(
       GetCurrentDisplayIdPair());
   return GetDisplayForId(layout.primary_id);
 }
 
 size_t DisplayManager::GetNumDisplays() const {
   return active_display_list_.size();
 }
 
-bool DisplayManager::IsActiveDisplayId(int64 display_id) const {
+bool DisplayManager::IsActiveDisplayId(int64_t display_id) const {
   return std::find_if(active_display_list_.begin(), active_display_list_.end(),
                       [display_id](const gfx::Display& display) {
                         return display.id() == display_id;
                       }) != active_display_list_.end();
 }
 
 bool DisplayManager::IsInMirrorMode() const {
   return mirroring_display_id_ != gfx::Display::kInvalidDisplayID;
 }
 
 void DisplayManager::SetUnifiedDesktopEnabled(bool enable) {
   unified_desktop_enabled_ = enable;
   // There is no need to update the displays in mirror mode. Doing
   // this in hardware mirroring mode can cause crash because display
   // info in hardware mirroring comes from DisplayConfigurator.
   if (!IsInMirrorMode())
     ReconfigureDisplays();
 }
 
 bool DisplayManager::IsInUnifiedMode() const {
   return multi_display_mode_ == UNIFIED &&
          !software_mirroring_display_list_.empty();
 }
 
-const DisplayInfo& DisplayManager::GetDisplayInfo(int64 display_id) const {
+const DisplayInfo& DisplayManager::GetDisplayInfo(int64_t display_id) const {
   DCHECK_NE(gfx::Display::kInvalidDisplayID, display_id);
 
-  std::map<int64, DisplayInfo>::const_iterator iter =
+  std::map<int64_t, DisplayInfo>::const_iterator iter =
       display_info_.find(display_id);
   CHECK(iter != display_info_.end()) << display_id;
   return iter->second;
 }
 
 const gfx::Display DisplayManager::GetMirroringDisplayById(
-    int64 display_id) const {
+    int64_t display_id) const {
   auto iter = std::find_if(software_mirroring_display_list_.begin(),
                            software_mirroring_display_list_.end(),
                            [display_id](const gfx::Display& display) {
                              return display.id() == display_id;
                            });
   return iter == software_mirroring_display_list_.end() ? gfx::Display()
                                                         : *iter;
 }
 
-std::string DisplayManager::GetDisplayNameForId(int64 id) {
+std::string DisplayManager::GetDisplayNameForId(int64_t id) {
   if (id == gfx::Display::kInvalidDisplayID)
     return l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
 
-  std::map<int64, DisplayInfo>::const_iterator iter = display_info_.find(id);
+  std::map<int64_t, DisplayInfo>::const_iterator iter = display_info_.find(id);
   if (iter != display_info_.end() && !iter->second.name().empty())
     return iter->second.name();
 
   return base::StringPrintf("Display %d", static_cast<int>(id));
 }
 
-int64 DisplayManager::GetDisplayIdForUIScaling() const {
+int64_t DisplayManager::GetDisplayIdForUIScaling() const {
   // UI Scaling is effective on internal display.
   return gfx::Display::HasInternalDisplay() ? gfx::Display::InternalDisplayId()
                                             : gfx::Display::kInvalidDisplayID;
 }
 
 void DisplayManager::SetMirrorMode(bool mirror) {
 #if defined(OS_CHROMEOS)
   if (num_connected_displays() <= 1)
     return;
 
@@ skipping 91 matching lines @@
        (display_info_list.size() < 2 &&
         iter != software_mirroring_display_list_.end());
        ++iter) {
     display_info_list.push_back(GetDisplayInfo(iter->id()));
   }
   mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
   software_mirroring_display_list_.clear();
   UpdateDisplays(display_info_list);
 }
 
-bool DisplayManager::UpdateDisplayBounds(int64 display_id,
+bool DisplayManager::UpdateDisplayBounds(int64_t display_id,
                                          const gfx::Rect& new_bounds) {
   if (change_display_upon_host_resize_) {
     display_info_[display_id].SetBounds(new_bounds);
     // Don't notify observers if the mirrored window has changed.
     if (software_mirroring_enabled() && mirroring_display_id_ == display_id)
       return false;
     gfx::Display* display = FindDisplayForId(display_id);
     display->SetSize(display_info_[display_id].size_in_pixel());
     screen_->NotifyMetricsChanged(*display,
                                   gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
@@ skipping 55 matching lines @@
   if (display_info_list->size() == 2) {
     switch (multi_display_mode_) {
       case MIRRORING: {
         bool zero_is_source =
             first_display_id_ == (*display_info_list)[0].id() ||
             gfx::Display::IsInternalDisplayId((*display_info_list)[0].id());
         DCHECK_EQ(MIRRORING, multi_display_mode_);
         mirroring_display_id_ =
             (*display_info_list)[zero_is_source ? 1 : 0].id();
 
-        int64 display_id = mirroring_display_id_;
+        int64_t display_id = mirroring_display_id_;
         auto iter =
             std::find_if(display_info_list->begin(), display_info_list->end(),
                          [display_id](const DisplayInfo& info) {
                            return info.id() == display_id;
                          });
         DCHECK(iter != display_info_list->end());
 
         DisplayInfo info = *iter;
         info.SetOverscanInsets(gfx::Insets());
         InsertAndUpdateDisplayInfo(info);
@@ skipping 95 matching lines @@
         display_info_list->push_back(info);
         InsertAndUpdateDisplayInfo(info);
         break;
       }
       case EXTENDED:
         break;
     }
   }
 }
 
-gfx::Display* DisplayManager::FindDisplayForId(int64 id) {
+gfx::Display* DisplayManager::FindDisplayForId(int64_t id) {
   auto iter = std::find_if(
       active_display_list_.begin(), active_display_list_.end(),
       [id](const gfx::Display& display) { return display.id() == id; });
   if (iter != active_display_list_.end())
     return &(*iter);
   // TODO(oshima): This happens when a windows in unified desktop have
   // been moved to normal window. Fix this.
   if (id != kUnifiedDisplayId)
     DLOG(WARNING) << "Could not find display:" << id;
   return NULL;
 }
 
 void DisplayManager::AddMirrorDisplayInfoIfAny(
     std::vector<DisplayInfo>* display_info_list) {
   if (software_mirroring_enabled() && IsInMirrorMode())
     display_info_list->push_back(GetDisplayInfo(mirroring_display_id_));
 }
 
 void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info) {
-  std::map<int64, DisplayInfo>::iterator info =
+  std::map<int64_t, DisplayInfo>::iterator info =
       display_info_.find(new_info.id());
   if (info != display_info_.end()) {
     info->second.Copy(new_info);
   } else {
     display_info_[new_info.id()] = new_info;
     display_info_[new_info.id()].set_native(false);
   }
   display_info_[new_info.id()].UpdateDisplaySize();
   OnDisplayInfoUpdated(display_info_[new_info.id()]);
 }
 
 void DisplayManager::OnDisplayInfoUpdated(const DisplayInfo& display_info) {
 #if defined(OS_CHROMEOS)
   ui::ColorCalibrationProfile color_profile = display_info.color_profile();
   if (color_profile != ui::COLOR_PROFILE_STANDARD) {
     Shell::GetInstance()->display_configurator()->SetColorCalibrationProfile(
         display_info.id(), color_profile);
   }
 #endif
 }
 
-gfx::Display DisplayManager::CreateDisplayFromDisplayInfoById(int64 id) {
+gfx::Display DisplayManager::CreateDisplayFromDisplayInfoById(int64_t id) {
   DCHECK(display_info_.find(id) != display_info_.end()) << "id=" << id;
   const DisplayInfo& display_info = display_info_[id];
 
   gfx::Display new_display(display_info.id());
   gfx::Rect bounds_in_native(display_info.size_in_pixel());
   float device_scale_factor = display_info.GetEffectiveDeviceScaleFactor();
 
   // Simply set the origin to (0,0).  The primary display's origin is
   // always (0,0) and the bounds of non-primary display(s) will be updated
   // in |UpdateNonPrimaryDisplayBoundsForLayout| called in |UpdateDisplay|.
   new_display.SetScaleAndBounds(
       device_scale_factor, gfx::Rect(bounds_in_native.size()));
   new_display.set_rotation(display_info.GetActiveRotation());
   new_display.set_touch_support(display_info.touch_support());
   return new_display;
 }
 
 gfx::Display DisplayManager::CreateMirroringDisplayFromDisplayInfoById(
-    int64 id,
+    int64_t id,
     const gfx::Point& origin,
     float scale) {
   DCHECK(display_info_.find(id) != display_info_.end()) << "id=" << id;
   const DisplayInfo& display_info = display_info_[id];
 
   gfx::Display new_display(display_info.id());
   new_display.SetScaleAndBounds(
       1.0f, gfx::Rect(origin, gfx::ScaleToFlooredSize(
                                   display_info.size_in_pixel(), scale)));
   new_display.set_touch_support(display_info.touch_support());
@@ skipping 105 matching lines @@
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash