Cleanup: IWYU for base/gtest_prod_util.h.

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 260 matching lines @@
       : size_(size),
         min_(min),
         max_(max) {
     // Grow the min/max bounds to include the starting size.
     if (is_underflowing())
       min_ = size_;
     if (is_overflowing())
       max_ = size_;
   }
 
-  bool is_at_capacity(bool shrinking) {
+  bool is_at_capacity(bool shrinking) const {
     return size_ == (shrinking ? min_ : max_);
   }
 
   int size() const {
     return size_;
   }
 
   bool has_min() const {
     return min_ != 0;
   }
@@ skipping 331 matching lines @@
     if (total_initial_size_ >= available_size)
       grow_attached_by = available_size - total_initial_size_;
   } else {
     // If we're shrinking, we grow the attached so the total size remains
     // constant.
     grow_attached_by = -delta;
   }
 
   int leftover_pixels = 0;
   while (grow_attached_by != 0) {
-    int leftovers = GrowFairly(grow_attached_by, window_sizes);
+    int leftovers = GrowFairly(grow_attached_by, &window_sizes);
     if (leftovers == grow_attached_by) {
       leftover_pixels = leftovers;
       break;
     }
     grow_attached_by = leftovers;
   }
 
   for (size_t i = 0; i < window_sizes.size(); ++i)
     sizes->push_back(window_sizes[i].size());
 
   return leftover_pixels;
 }
 
-int WorkspaceWindowResizer::GrowFairly(
-    int pixels,
-    std::vector<WindowSize>& sizes) const {
+int WorkspaceWindowResizer::GrowFairly(int pixels,
+                                       std::vector<WindowSize>* sizes) const {
   bool shrinking = pixels < 0;
   std::vector<WindowSize*> nonfull_windows;
-  for (size_t i = 0; i < sizes.size(); ++i) {
-    if (!sizes[i].is_at_capacity(shrinking))
-      nonfull_windows.push_back(&sizes[i]);
+  for (size_t i = 0; i < sizes->size(); ++i) {
+    WindowSize& current_window_size = (*sizes)[i];
+    if (!current_window_size.is_at_capacity(shrinking))
+      nonfull_windows.push_back(&current_window_size);
   }
   std::vector<float> ratios;
   CalculateGrowthRatios(nonfull_windows, &ratios);
 
   int remaining_pixels = pixels;
   bool add_leftover_pixels_to_last = true;
   for (size_t i = 0; i < nonfull_windows.size(); ++i) {
     int grow_by = pixels * ratios[i];
     // Put any leftover pixels into the last window.
     if (i == nonfull_windows.size() - 1 && add_leftover_pixels_to_last)
@@ skipping 390 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