Ignores programmatic bounds changes for docked windows

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 192 matching lines @@
 };
 
 namespace {
 
 // Returns true if a window is a popup or a transient child.
 bool IsPopupOrTransient(const aura::Window* window) {
   return (window->type() == ui::wm::WINDOW_TYPE_POPUP ||
           ::wm::GetTransientParent(window));
 }
 
-// Certain windows (minimized, hidden or popups) do not matter to docking.
-bool IsUsedByLayout(const aura::Window* window) {
+// Certain windows (minimized, hidden or popups) are ignored by layout logic.
+bool IsIgnoredForDocking(const aura::Window* window) {

[oshima, 2015/06/05 23:08:36]

This is still confusing to me.

If this is to indicate that the window is docked, why not IsDocked?


Here is my interpretation is:

// Certain windows (minimized, hidden or popups) are ignored by dock layout
logic.
  |
  V
"minimized, hidden or popup windows aren't docked" ->

NotDocked() : minimized || !visible || popup
(IsIgnoredByDockLayout describes impl)
   |
  flip the condition
   V
IsDocked : visible && !minimized && !popup
IsUsedByDockLayout 

[varkha, 2015/06/07 02:53:24]

Done. You are right, haven't noticed that I had reversed the name. Could have
been "IsNotIgnoredByDockLayout" but "IsWindowDocked" seems better. I tried to
avoid name clash with WindowState::IsDocked.

   return (window->IsVisible() &&
           !wm::GetWindowState(window)->IsMinimized() &&
           !IsPopupOrTransient(window));
 }
 
 void UndockWindow(aura::Window* window) {
   gfx::Rect previous_bounds = window->bounds();
   aura::Window* old_parent = window->parent();
   aura::client::ParentWindowWithContext(window, window, gfx::Rect());
   if (window->parent() != old_parent)
@@ skipping 247 matching lines @@
 
   // Resize all windows that are flush with the dock edge together if one of
   // them gets resized.
   if (dragged_window_->bounds().width() == docked_width_ &&
       (dragged_state->drag_details()->bounds_change &
           WindowResizer::kBoundsChange_Resizes) &&
       (dragged_state->drag_details()->size_change_direction &
           WindowResizer::kBoundsChangeDirection_Horizontal)) {
     for (size_t i = 0; i < dock_container_->children().size(); ++i) {
       aura::Window* window1(dock_container_->children()[i]);
-      if (IsUsedByLayout(window1) &&
-          window1 != dragged_window_ &&
+      if (IsIgnoredForDocking(window1) && window1 != dragged_window_ &&
           window1->bounds().width() == docked_width_) {
         wm::GetWindowState(window1)->set_bounds_changed_by_user(false);
       }
     }
   }
 }
 
 void DockedWindowLayoutManager::DockDraggedWindow(aura::Window* window) {
   DCHECK(!IsPopupOrTransient(window));
   OnDraggedWindowDocked(window);
@@ skipping 244 matching lines @@
     const gfx::Rect& requested_bounds) {
   // The minimum constraints have to be applied first by the layout manager.
   gfx::Rect actual_new_bounds(requested_bounds);
   if (child->delegate()) {
     const gfx::Size& min_size = child->delegate()->GetMinimumSize();
     actual_new_bounds.set_width(
         std::max(min_size.width(), actual_new_bounds.width()));
     actual_new_bounds.set_height(
         std::max(min_size.height(), actual_new_bounds.height()));
   }
+  if (IsIgnoredForDocking(child) && child != dragged_window_)
+    return;
   SnapToPixelLayoutManager::SetChildBounds(child, actual_new_bounds);
   if (IsPopupOrTransient(child))
     return;
   // Whenever one of our windows is moved or resized enforce layout.
   ShelfLayoutManager* shelf_layout =
       ShelfLayoutManager::ForShelf(dock_container_);
   if (shelf_layout)
     shelf_layout->UpdateVisibilityState();
 }
 
@@ skipping 171 matching lines @@
       Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
   int available_room = work_area.height();
   bool gap_needed = !!child;
   if (child)
     available_room -= GetWindowHeightCloseTo(child, 0);
   // 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))
+    if (window == child || !IsIgnoredForDocking(window))
       continue;
     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());
@@ skipping 56 matching lines @@
   last_action_time_ = time_now;
   int docked_all_count = 0;
   int docked_visible_count = 0;
   int docked_panels_count = 0;
   int large_windows_count = 0;
   for (size_t i = 0; i < dock_container_->children().size(); ++i) {
     const aura::Window* window(dock_container_->children()[i]);
     if (IsPopupOrTransient(window))
       continue;
     docked_all_count++;
-    if (!IsUsedByLayout(window))
+    if (!IsIgnoredForDocking(window))
       continue;
     docked_visible_count++;
     if (window->type() == ui::wm::WINDOW_TYPE_PANEL)
       docked_panels_count++;
     const wm::WindowState* window_state = wm::GetWindowState(window);
     if (window_state->HasRestoreBounds()) {
       const gfx::Rect restore_bounds = window_state->GetRestoreBoundsInScreen();
       if (restore_bounds.width() > kMaxDockWidth)
         large_windows_count++;
     }
@@ skipping 40 matching lines @@
   if (alignment_ == DOCKED_ALIGNMENT_NONE && !is_dragged_window_docked_)
     return;
   base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
   gfx::Rect dock_bounds = dock_container_->GetBoundsInScreen();
   aura::Window* active_window = NULL;
   std::vector<WindowWithHeight> visible_windows;
   for (size_t i = 0; i < dock_container_->children().size(); ++i) {
     aura::Window* window(dock_container_->children()[i]);
 
-    if (!IsUsedByLayout(window) || window == dragged_window_)
+    if (!IsIgnoredForDocking(window) || window == dragged_window_)
       continue;
 
     // If the shelf is currently hidden (full-screen mode), hide window until
     // full-screen mode is exited.
     if (in_fullscreen_) {
       // The call to Hide does not set the minimize property, so the window will
       // be restored when the shelf becomes visible again.
       window->Hide();
       continue;
     }
@@ skipping 219 matching lines @@
   // |`------'|
   // |`------'|
   //  `------'
   // Use the middle of each window to figure out how to stack the window.
   // This allows us to update the stacking when a window is being dragged around
   // by the titlebar.
   std::map<int, aura::Window*> window_ordering;
   for (aura::Window::Windows::const_iterator it =
            dock_container_->children().begin();
        it != dock_container_->children().end(); ++it) {
-    if (!IsUsedByLayout(*it) ||
+    if (!IsIgnoredForDocking(*it) ||
         ((*it) == dragged_window_ && !is_dragged_window_docked_)) {
       continue;
     }
     gfx::Rect bounds = (*it)->bounds();
     window_ordering.insert(std::make_pair(bounds.y() + bounds.height() / 2,
                                           *it));
   }
   int active_center_y = active_window->bounds().CenterPoint().y();
 
   aura::Window* previous_window = NULL;
@@ skipping 23 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