Update ui/display to use primitive types as defined in stdint.h

ui/display/chromeos/output_configurator.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 "ui/display/chromeos/output_configurator.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "ui/display/chromeos/display_mode.h"
 #include "ui/display/chromeos/display_snapshot.h"
 #include "ui/display/chromeos/x11/native_display_delegate_x11.h"
 #include "ui/display/chromeos/x11/touchscreen_delegate_x11.h"
 
 namespace ui {
 
 namespace {
 
 typedef std::vector<const DisplayMode*> DisplayModeList;
 
 // The delay to perform configuration after RRNotify.  See the comment
 // in |Dispatch()|.
-const int64 kConfigureDelayMs = 500;
+const int kConfigureDelayMs = 500;
 
 // Returns a string describing |state|.
 std::string DisplayPowerStateToString(chromeos::DisplayPowerState state) {
   switch (state) {
     case chromeos::DISPLAY_POWER_ALL_ON:
       return "ALL_ON";
     case chromeos::DISPLAY_POWER_ALL_OFF:
       return "ALL_OFF";
     case chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON:
       return "INTERNAL_OFF_EXTERNAL_ON";
@@ skipping 153 matching lines @@
 
   if (!native_display_delegate_) {
     native_display_delegate_.reset(new NativeDisplayDelegateX11());
     native_display_delegate_->AddObserver(this);
   }
 
   if (!touchscreen_delegate_)
     touchscreen_delegate_.reset(new TouchscreenDelegateX11());
 }
 
-void OutputConfigurator::ForceInitialConfigure(uint32 background_color_argb) {
+void OutputConfigurator::ForceInitialConfigure(uint32_t background_color_argb) {
   if (!configure_display_)
     return;
 
   native_display_delegate_->GrabServer();
   native_display_delegate_->Initialize();
 
   UpdateCachedOutputs();
   if (cached_outputs_.size() > 1 && background_color_argb)
     native_display_delegate_->SetBackgroundColor(background_color_argb);
   const OutputState new_state = ChooseOutputState(power_state_);
@@ skipping 67 matching lines @@
          ++it2) {
       protections[it2->first] |= it2->second;
     }
   }
 
   ApplyProtections(protections);
 }
 
 bool OutputConfigurator::QueryOutputProtectionStatus(
     OutputProtectionClientId client_id,
-    int64 display_id,
+    int64_t display_id,
     uint32_t* link_mask,
     uint32_t* protection_mask) {
   if (!configure_display_)
     return false;
 
   uint32_t enabled = 0;
   uint32_t unfulfilled = 0;
   *link_mask = 0;
   for (DisplayStateList::const_iterator it = cached_outputs_.begin();
        it != cached_outputs_.end();
@@ skipping 36 matching lines @@
       requested_mask = it->second[display_id];
     *protection_mask = enabled & ~unfulfilled & requested_mask;
   } else {
     *protection_mask = 0;
   }
   return true;
 }
 
 bool OutputConfigurator::EnableOutputProtection(
     OutputProtectionClientId client_id,
-    int64 display_id,
+    int64_t display_id,
     uint32_t desired_method_mask) {
   if (!configure_display_)
     return false;
 
   DisplayProtections protections;
   for (ProtectionRequests::const_iterator it =
            client_protection_requests_.begin();
        it != client_protection_requests_.end();
        ++it) {
     for (DisplayProtections::const_iterator it2 = it->second.begin();
@@ skipping 18 matching lines @@
     }
   } else {
     client_protection_requests_[client_id][display_id] = desired_method_mask;
   }
 
   return true;
 }
 
 std::vector<ui::ColorCalibrationProfile>
 OutputConfigurator::GetAvailableColorCalibrationProfiles(
-    int64 display_id) {
+    int64_t display_id) {
   for (size_t i = 0; i < cached_outputs_.size(); ++i) {
     if (cached_outputs_[i].display &&
         cached_outputs_[i].display->display_id() == display_id) {
       return native_display_delegate_->GetAvailableColorCalibrationProfiles(
           *cached_outputs_[i].display);
     }
   }
 
   return std::vector<ui::ColorCalibrationProfile>();
 }
 
 bool OutputConfigurator::SetColorCalibrationProfile(
-    int64 display_id,
+    int64_t display_id,
     ui::ColorCalibrationProfile new_profile) {
   for (size_t i = 0; i < cached_outputs_.size(); ++i) {
     if (cached_outputs_[i].display &&
         cached_outputs_[i].display->display_id() == display_id) {
       return native_display_delegate_->SetColorCalibrationProfile(
           *cached_outputs_[i].display, new_profile);
     }
   }
 
   return false;
@@ skipping 501 matching lines @@
     case 2: {
       if (num_on_outputs == 1) {
         // If only one output is currently turned on, return the "single"
         // state so that its native mode will be used.
         return OUTPUT_STATE_SINGLE;
       } else {
         if (!state_controller_)
           return OUTPUT_STATE_DUAL_EXTENDED;
         // With either both outputs on or both outputs off, use one of the
         // dual modes.
-        std::vector<int64> display_ids;
+        std::vector<int64_t> display_ids;
         for (size_t i = 0; i < cached_outputs_.size(); ++i) {
           // If display id isn't available, switch to extended mode.
           if (!cached_outputs_[i].display->has_proper_display_id())
             return OUTPUT_STATE_DUAL_EXTENDED;
           display_ids.push_back(cached_outputs_[i].display->display_id());
         }
         return state_controller_->GetStateForDisplayIds(display_ids);
       }
     }
     default:
@@ skipping 94 matching lines @@
   float width_ratio = static_cast<float>(mirror_mode_info->size().width()) /
                       static_cast<float>(native_mode_info->size().width());
   float height_ratio = static_cast<float>(mirror_mode_info->size().height()) /
                        static_cast<float>(native_mode_info->size().height());
 
   area_ratio = width_ratio * height_ratio;
   return area_ratio;
 }
 
 }  // namespace ui