Eliminates gap at the top and bottom of docked area

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/ash_switches.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_constants.h"
@@ skipping 532 matching lines @@
       (!wm::GetWindowState(window)->CanResize() ||
        (window->delegate() &&
         window->delegate()->GetMinimumSize().width() != 0 &&
         window->delegate()->GetMinimumSize().width() > kMaxDockWidth))) {
     return false;
   }
   // If a window is tall and cannot be resized down to maximum height allowed
   // then it cannot be docked.
   const gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
-  if (GetWindowHeightCloseTo(window, work_area.height() - 2 * kMinDockGap) >
-      work_area.height() - 2 * kMinDockGap) {
+  if (GetWindowHeightCloseTo(window, work_area.height()) > work_area.height())
     return false;
-  }
   // Cannot dock on the other size from an existing dock.
   const DockedAlignment alignment = CalculateAlignment();
   if ((edge == SNAP_LEFT && alignment == DOCKED_ALIGNMENT_RIGHT) ||
       (edge == SNAP_RIGHT && alignment == DOCKED_ALIGNMENT_LEFT)) {
     return false;
   }
   // Do not allow docking on the same side as shelf.
   ShelfAlignment shelf_alignment = SHELF_ALIGNMENT_BOTTOM;
   if (shelf_)
     shelf_alignment = shelf_->alignment();
@@ skipping 244 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager private implementation:
 
 void DockedWindowLayoutManager::MaybeMinimizeChildrenExcept(
     aura::Window* child) {
   // Minimize any windows that don't fit without overlap.
   const gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
-  int available_room = work_area.height() - kMinDockGap;
+  int available_room = work_area.height();
+  bool gap_needed = !!child;
   if (child)
-    available_room -= (GetWindowHeightCloseTo(child, 0) + kMinDockGap);
+    available_room -= (GetWindowHeightCloseTo(child, 0));

[James Cook, 2014/01/06 21:06:53]

nit: Don't need parens around GetWindowHeight().

[varkha, 2014/01/06 21:14:05]

Done.

   // Use a copy of children array because a call to Minimize can change order.
   aura::Window::Windows children(dock_container_->children());
   aura::Window::Windows::const_reverse_iterator iter = children.rbegin();
   while (iter != children.rend()) {
     aura::Window* window(*iter++);
     if (window == child || !IsUsedByLayout(window))
       continue;
-    int room_needed = GetWindowHeightCloseTo(window, 0) + kMinDockGap;
+    int room_needed = GetWindowHeightCloseTo(window, 0) +
+        (gap_needed ? kMinDockGap : 0);
+    gap_needed = true;
     if (available_room > room_needed) {
       available_room -= room_needed;
     } else {
       // Slow down minimizing animations. Lock duration so that it is not
       // overridden by other ScopedLayerAnimationSettings down the stack.
       ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
       settings.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kMinimizeDurationMs));
       settings.LockTransitionDuration();
       wm::GetWindowState(window)->Minimize();
@@ skipping 159 matching lines @@
 
   // After the first Relayout allow the windows to change their order easier
   // since we know they are docked.
   is_dragged_from_dock_ = true;
   UpdateStacking(active_window);
 }
 
 int DockedWindowLayoutManager::CalculateWindowHeightsAndRemainingRoom(
     const gfx::Rect work_area,
     std::vector<WindowWithHeight>* visible_windows) {
-  int available_room = work_area.height() - kMinDockGap;
+  int available_room = work_area.height();
   int remaining_windows = visible_windows->size();
+  int gap_height = remaining_windows > 1 ? kMinDockGap : 0;
 
   // Sort windows by their minimum heights and calculate target heights.
   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(), available_room / remaining_windows - kMinDockGap);
-    available_room -= (iter->height_ + kMinDockGap);
+        iter->window(),
+        (available_room + gap_height) / remaining_windows - gap_height);
+    available_room -= (iter->height_ + gap_height);
     remaining_windows--;
   }
-  return available_room;
+  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).
@@ skipping 19 matching lines @@
 
 void DockedWindowLayoutManager::FanOutChildren(
     const gfx::Rect& work_area,
     int ideal_docked_width,
     int available_room,
     std::vector<WindowWithHeight>* visible_windows) {
   gfx::Rect dock_bounds = dock_container_->GetBoundsInScreen();
 
   // Calculate initial vertical offset and the gap or overlap between windows.
   const int num_windows = visible_windows->size();
-  const float delta = kMinDockGap + (float)available_room /
+  const float delta = (float)available_room /

[James Cook, 2014/01/06 21:06:53]

nit: static_cast<float>

[varkha, 2014/01/06 21:14:05]

Done.

       ((available_room > 0 || num_windows <= 1) ?
           num_windows + 1 : num_windows - 1);
-  float y_pos = work_area.y() + ((delta > 0) ? delta : kMinDockGap);
+  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_)) {
     new_width = 0;
   }
   UpdateDockedWidth(new_width);
@@ skipping 22 matching lines @@
       alignment = GetAlignmentOfWindow(window);
       if (alignment == DOCKED_ALIGNMENT_NONE)
         bounds.set_size(gfx::Size());
     }
 
     // Fan out windows evenly distributing the overlap or remaining free space.
     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;
+    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() +
                      (ideal_docked_width - bounds.width()) / 2);
         break;
       case DOCKED_ALIGNMENT_RIGHT:
         bounds.set_x(dock_bounds.right() -
@@ skipping 112 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 internal
 }  // namespace ash