Switch to standard integer types in ash/.

ash/wm/workspace/workspace_window_resizer.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/wm/workspace/workspace_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
@@ skipping 206 matching lines @@
         w = src.right() - x;
       } else if (edge.secondary_edge == SECONDARY_MAGNETISM_EDGE_TRAILING) {
         w += attach_origin.x() - src.x();
       }
       break;
   }
   return gfx::Rect(x, y, w, h);
 }
 
 // Converts a window component edge to the magnetic edge to snap to.
-uint32 WindowComponentToMagneticEdge(int window_component) {
+uint32_t WindowComponentToMagneticEdge(int window_component) {
   switch (window_component) {
     case HTTOPLEFT:
       return MAGNETISM_EDGE_LEFT | MAGNETISM_EDGE_TOP;
     case HTTOPRIGHT:
       return MAGNETISM_EDGE_TOP | MAGNETISM_EDGE_RIGHT;
     case HTBOTTOMLEFT:
       return MAGNETISM_EDGE_LEFT | MAGNETISM_EDGE_BOTTOM;
     case HTBOTTOMRIGHT:
       return MAGNETISM_EDGE_RIGHT | MAGNETISM_EDGE_BOTTOM;
     case HTTOP:
@@ skipping 472 matching lines @@
         magnetism_window_->GetBoundsInScreen(),
         magnetism_edge_);
     aura::client::GetScreenPositionClient(GetTarget()->GetRootWindow())->
         ConvertPointFromScreen(GetTarget()->parent(), &point);
     bounds->set_origin(point);
   }
 }
 
 void WorkspaceWindowResizer::MagneticallySnapResizeToOtherWindows(
     gfx::Rect* bounds) {
-  const uint32 edges = WindowComponentToMagneticEdge(
-      details().window_component);
+  const uint32_t edges =
+      WindowComponentToMagneticEdge(details().window_component);
   if (UpdateMagnetismWindow(*bounds, edges)) {
     *bounds = ScreenUtil::ConvertRectFromScreen(
         GetTarget()->parent(),
         BoundsForMagneticResizeAttach(
             ScreenUtil::ConvertRectToScreen(GetTarget()->parent(), *bounds),
             magnetism_window_->GetBoundsInScreen(),
             magnetism_edge_));
   }
 }
 
 bool WorkspaceWindowResizer::UpdateMagnetismWindow(const gfx::Rect& bounds,
-                                                   uint32 edges) {
+                                                   uint32_t edges) {
   // |bounds| are in coordinates of original window's parent.
   gfx::Rect bounds_in_screen =
       ScreenUtil::ConvertRectToScreen(GetTarget()->parent(), bounds);
   MagnetismMatcher matcher(bounds_in_screen, edges);
 
   // If we snapped to a window then check it first. That way we don't bounce
   // around when close to multiple edges.
   if (magnetism_window_) {
     if (window_tracker_.Contains(magnetism_window_) &&
         matcher.ShouldAttach(magnetism_window_->GetBoundsInScreen(),
@@ skipping 114 matching lines @@
     bounds->set_y(bottom_edge - bounds->height());
     updated = true;
   }
   return updated;
 }
 
 void WorkspaceWindowResizer::StickToWorkAreaOnResize(
     const gfx::Rect& work_area,
     int sticky_size,
     gfx::Rect* bounds) const {
-  const uint32 edges = WindowComponentToMagneticEdge(
-      details().window_component);
+  const uint32_t edges =
+      WindowComponentToMagneticEdge(details().window_component);
   const int left_edge = work_area.x();
   const int right_edge = work_area.right();
   const int top_edge = work_area.y();
   const int bottom_edge = work_area.bottom();
   if (edges & MAGNETISM_EDGE_TOP &&
       ShouldStickToEdge(bounds->y() - top_edge, sticky_size)) {
     bounds->set_height(bounds->bottom() - top_edge);
     bounds->set_y(top_edge);
   }
   if (edges & MAGNETISM_EDGE_LEFT &&
@@ skipping 175 matching lines @@
          snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED);
   gfx::Rect snapped_bounds = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
       GetTarget());
   if (snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED)
     snapped_bounds.set_x(snapped_bounds.right() - bounds_in_parent.width());
   snapped_bounds.set_width(bounds_in_parent.width());
   return bounds_in_parent == snapped_bounds;
 }
 
 }  // namespace ash