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

ui/display/chromeos/output_configurator.h

 // 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.
 
 #ifndef UI_DISPLAY_CHROMEOS_OUTPUT_CONFIGURATOR_H_
 #define UI_DISPLAY_CHROMEOS_OUTPUT_CONFIGURATOR_H_
 
+#include <stdint.h>
+
 #include <map>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/event_types.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/timer/timer.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/display/chromeos/native_display_observer.h"
 #include "ui/display/display_constants.h"
 #include "ui/display/display_export.h"
 
 namespace gfx {
@@ skipping 58 matching lines @@
   };
 
   // Interface for classes that make decisions about which output state
   // should be used.
   class StateController {
    public:
     virtual ~StateController() {}
 
     // Called when displays are detected.
     virtual OutputState GetStateForDisplayIds(
-        const std::vector<int64>& display_ids) const = 0;
+        const std::vector<int64_t>& display_ids) const = 0;
 
     // Queries the resolution (|size|) in pixels to select output mode for the
     // given display id.
-    virtual bool GetResolutionForDisplayId(int64 display_id,
+    virtual bool GetResolutionForDisplayId(int64_t display_id,
                                            gfx::Size* size) const = 0;
   };
 
   // Interface for classes that implement software based mirroring.
   class SoftwareMirroringController {
    public:
     virtual ~SoftwareMirroringController() {}
 
     // Called when the hardware mirroring failed.
     virtual void SetSoftwareMirroring(bool enabled) = 0;
@@ skipping 86 matching lines @@
   void SetInitialDisplayPower(chromeos::DisplayPowerState power_state);
 
   // Initialization, must be called right after constructor.
   // |is_panel_fitting_enabled| indicates hardware panel fitting support.
   void Init(bool is_panel_fitting_enabled);
 
   // Does initial configuration of displays during startup.
   // If |background_color_argb| is non zero and there are multiple displays,
   // OutputConfigurator sets the background color of X's RootWindow to this
   // color.
-  void ForceInitialConfigure(uint32 background_color_argb);
+  void ForceInitialConfigure(uint32_t background_color_argb);
 
   // Stop handling display configuration events/requests.
   void PrepareForExit();
 
   // Called when powerd notifies us that some set of displays should be turned
   // on or off.  This requires enabling or disabling the CRTC associated with
   // the display(s) in question so that the low power state is engaged.
   // |flags| contains bitwise-or-ed kSetDisplayPower* values.
   bool SetDisplayPower(chromeos::DisplayPowerState power_state, int flags);
 
@@ skipping 27 matching lines @@
 
   // Unregisters the client.
   void UnregisterOutputProtectionClient(OutputProtectionClientId client_id);
 
   // Queries link status and protection status.
   // |link_mask| is the type of connected output links, which is a bitmask of
   // OutputType values. |protection_mask| is the desired protection methods,
   // which is a bitmask of the OutputProtectionMethod values.
   // Returns true on success.
   bool QueryOutputProtectionStatus(OutputProtectionClientId client_id,
-                                   int64 display_id,
+                                   int64_t display_id,
                                    uint32_t* link_mask,
                                    uint32_t* protection_mask);
 
   // Requests the desired protection methods.
   // |protection_mask| is the desired protection methods, which is a bitmask
   // of the OutputProtectionMethod values.
   // Returns true when the protection request has been made.
   bool EnableOutputProtection(OutputProtectionClientId client_id,
-                              int64 display_id,
+                              int64_t display_id,
                               uint32_t desired_protection_mask);
 
   // Checks the available color profiles for |display_id| and fills the result
   // into |profiles|.
   std::vector<ui::ColorCalibrationProfile> GetAvailableColorCalibrationProfiles(
-      int64 display_id);
+      int64_t display_id);
 
   // Updates the color calibration to |new_profile|.
   bool SetColorCalibrationProfile(
-      int64 display_id,
+      int64_t display_id,
       ui::ColorCalibrationProfile new_profile);
 
  private:
   // Mapping a display_id to a protection request bitmask.
-  typedef std::map<int64, uint32_t> DisplayProtections;
+  typedef std::map<int64_t, uint32_t> DisplayProtections;
   // Mapping a client to its protection request.
   typedef std::map<OutputProtectionClientId, DisplayProtections>
       ProtectionRequests;
 
   // Updates |cached_outputs_| to contain currently-connected outputs. Calls
   // |delegate_->GetOutputs()| and then does additional work, like finding the
   // mirror mode and setting user-preferred modes. Note that the server must be
   // grabbed via |delegate_->GrabServer()| first.
   void UpdateCachedOutputs();
 
@@ skipping 105 matching lines @@
 
   // Output protection requests of each client.
   ProtectionRequests client_protection_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(OutputConfigurator);
 };
 
 }  // namespace ui
 
 #endif  // UI_DISPLAY_CHROMEOS_OUTPUT_CONFIGURATOR_H_