Minor style cleanup in DockedWindowLayoutManager

ash/wm/dock/docked_window_layout_manager.cc

 // Copyright (c) 2013 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/dock/docked_window_layout_manager.h"
 
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_layout_manager.h"
@@ skipping 278 matching lines @@
     if (delegate->GetMaximumSize().height() != 0)
       maximum_height = delegate->GetMaximumSize().height();
   }
   if (minimum_height)
     target_height = std::max(target_height, minimum_height);
   if (maximum_height)
     target_height = std::min(target_height, maximum_height);
   return target_height;
 }
 
+}  // namespace
+
+struct DockedWindowLayoutManager::WindowWithHeight {
+  explicit WindowWithHeight(aura::Window* window)
+      : window(window), height(window->bounds().height()) {}
+  aura::Window* window;
+  int height;
+};
+
 // A functor used to sort the windows in order of their minimum height.
-struct CompareMinimumHeight {
-  bool operator()(WindowWithHeight win1, WindowWithHeight win2) {
-    return GetWindowHeightCloseTo(win1.window(), 0) <
-        GetWindowHeightCloseTo(win2.window(), 0);
+struct DockedWindowLayoutManager::CompareMinimumHeight {
+  bool operator()(const WindowWithHeight& win1, const WindowWithHeight& win2) {
+    return GetWindowHeightCloseTo(win1.window, 0) <
+           GetWindowHeightCloseTo(win2.window, 0);
   }
 };
 
 // A functor used to sort the windows in order of their center Y position.
 // |delta| is a pre-calculated distance from the bottom of one window to the top
 // of the next. Its value can be positive (gap) or negative (overlap).
 // Half of |delta| is used as a transition point at which windows could ideally
 // swap positions.
-struct CompareWindowPos {
+struct DockedWindowLayoutManager::CompareWindowPos {
   CompareWindowPos(aura::Window* dragged_window,
                    aura::Window* docked_container,
                    float delta)
       : dragged_window_(dragged_window),
         docked_container_(docked_container),
         delta_(delta / 2) {}
 
-  bool operator()(WindowWithHeight window_with_height1,
-                  WindowWithHeight window_with_height2) {
+  bool operator()(const WindowWithHeight& window_with_height1,
+                  const WindowWithHeight& window_with_height2) {
     // Use target coordinates since animations may be active when windows are
     // reordered.
-    aura::Window* win1(window_with_height1.window());
-    aura::Window* win2(window_with_height2.window());
+    aura::Window* win1(window_with_height1.window);
+    aura::Window* win2(window_with_height2.window);
     gfx::Rect win1_bounds = ScreenUtil::ConvertRectToScreen(
         docked_container_, win1->GetTargetBounds());
     gfx::Rect win2_bounds = ScreenUtil::ConvertRectToScreen(
         docked_container_, win2->GetTargetBounds());
-    win1_bounds.set_height(window_with_height1.height_);
-    win2_bounds.set_height(window_with_height2.height_);
+    win1_bounds.set_height(window_with_height1.height);
+    win2_bounds.set_height(window_with_height2.height);
     // If one of the windows is the |dragged_window_| attempt to make an
     // earlier swap between the windows than just based on their centers.
     // This is possible if the dragged window is at least as tall as the other
     // window.
     if (win1 == dragged_window_)
       return compare_two_windows(win1_bounds, win2_bounds);
     if (win2 == dragged_window_)
       return !compare_two_windows(win2_bounds, win1_bounds);
     // Otherwise just compare the centers.
     return win1_bounds.CenterPoint().y() < win2_bounds.CenterPoint().y();
@@ skipping 21 matching lines @@
     // In this case just compare the centers.
     return bounds1.CenterPoint().y() < bounds2.CenterPoint().y();
   }
 
  private:
   aura::Window* dragged_window_;
   aura::Window* docked_container_;
   float delta_;
 };
 
-}  // namespace
-
 ////////////////////////////////////////////////////////////////////////////////
 // A class that observes shelf for bounds changes.
 class DockedWindowLayoutManager::ShelfWindowObserver : public WindowObserver {
  public:
   explicit ShelfWindowObserver(
       DockedWindowLayoutManager* docked_layout_manager)
       : docked_layout_manager_(docked_layout_manager) {
     DCHECK(docked_layout_manager_->shelf()->shelf_widget());
     docked_layout_manager_->shelf()->shelf_widget()->GetNativeView()
         ->AddObserver(this);
@@ skipping 755 matching lines @@
   std::sort(visible_windows->begin(), visible_windows->end(),
             CompareMinimumHeight());
   // Distribute the free space among the docked windows. Since the windows are
   // sorted (tall windows first) we can now assume that any window which
   // required more space than the current window will have already been
   // accounted for previously in this loop, so we can safely give that window
   // its proportional share of the remaining space.
   for (std::vector<WindowWithHeight>::reverse_iterator iter =
            visible_windows->rbegin();
       iter != visible_windows->rend(); ++iter) {
-    iter->height_ = GetWindowHeightCloseTo(
-        iter->window(),
+    iter->height = GetWindowHeightCloseTo(
+        iter->window,
         (available_room + gap_height) / remaining_windows - gap_height);
-    available_room -= (iter->height_ + gap_height);
+    available_room -= (iter->height + gap_height);
     remaining_windows--;
   }
   return available_room + gap_height;
 }
 
 int DockedWindowLayoutManager::CalculateIdealWidth(
     const std::vector<WindowWithHeight>& visible_windows) {
   int smallest_max_width = kMaxDockWidth;
   int largest_min_width = kMinDockWidth;
   // Ideal width of the docked area is as close to kIdealWidth as possible
   // while still respecting the minimum and maximum width restrictions on the
   // individual docked windows as well as the width that was possibly set by a
   // user (which needs to be preserved when dragging and rearranging windows).
   for (std::vector<WindowWithHeight>::const_iterator iter =
            visible_windows.begin();
        iter != visible_windows.end(); ++iter) {
-    const aura::Window* window = iter->window();
+    const aura::Window* window = iter->window;
     int min_window_width = window->bounds().width();
     int max_window_width = min_window_width;
     if (!wm::GetWindowState(window)->bounds_changed_by_user()) {
       min_window_width = GetWindowWidthCloseTo(window, kMinDockWidth);
       max_window_width = GetWindowWidthCloseTo(window, kMaxDockWidth);
     }
     largest_min_width = std::max(largest_min_width, min_window_width);
     smallest_max_width = std::min(smallest_max_width, max_window_width);
   }
   int ideal_width = std::max(largest_min_width,
@@ skipping 15 matching lines @@
   const float delta = static_cast<float>(available_room) /
       ((available_room > 0 || num_windows <= 1) ?
           num_windows + 1 : num_windows - 1);
   float y_pos = work_area.y() + ((delta > 0) ? delta : 0);
 
   // Docked area is shown only if there is at least one non-dragged visible
   // docked window.
   int new_width = ideal_docked_width;
   if (visible_windows->empty() ||
       (visible_windows->size() == 1 &&
-          (*visible_windows)[0].window() == dragged_window_)) {
+       (*visible_windows)[0].window == dragged_window_)) {
     new_width = 0;
   }
   UpdateDockedWidth(new_width);
   // Sort windows by their center positions and fan out overlapping
   // windows.
   std::sort(visible_windows->begin(), visible_windows->end(),
             CompareWindowPos(is_dragged_from_dock_ ? dragged_window_ : nullptr,
                              dock_container_, delta));
   for (std::vector<WindowWithHeight>::iterator iter = visible_windows->begin();
        iter != visible_windows->end(); ++iter) {
-    aura::Window* window = iter->window();
+    aura::Window* window = iter->window;
     gfx::Rect bounds = ScreenUtil::ConvertRectToScreen(
         dock_container_, window->GetTargetBounds());
     // A window is extended or shrunk to be as close as possible to the ideal
     // docked area width. Windows that were resized by a user are kept at their
     // existing size.
     // This also enforces the min / max restrictions on the docked area width.
     bounds.set_width(GetWindowWidthCloseTo(
         window,
         wm::GetWindowState(window)->bounds_changed_by_user() ?
             bounds.width() : ideal_docked_width));
     DCHECK_LE(bounds.width(), ideal_docked_width);
 
     DockedAlignment alignment = alignment_;
     if (alignment == DOCKED_ALIGNMENT_NONE && window == dragged_window_)
       alignment = GetEdgeNearestWindow(window);
 
     // Fan out windows evenly distributing the overlap or remaining free space.
-    bounds.set_height(iter->height_);
+    bounds.set_height(iter->height);
     bounds.set_y(std::max(work_area.y(),
                           std::min(work_area.bottom() - bounds.height(),
                                    static_cast<int>(y_pos + 0.5))));
     y_pos += bounds.height() + delta + kMinDockGap;
 
     // All docked windows other than the one currently dragged remain stuck
     // to the screen edge (flush with the edge or centered in the dock area).
     switch (alignment) {
       case DOCKED_ALIGNMENT_LEFT:
         bounds.set_x(dock_bounds.x() +
@@ skipping 119 matching lines @@
 
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 }  // namespace ash