Change overview mode to so that docked panel windows are not grouped together.

ash/wm/overview/window_grid.cc

 // Copyright 2014 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/overview/window_grid.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 56 matching lines @@
 }
 
 // A comparator for locating a given target window.
 struct WindowSelectorItemComparator
     : public std::unary_function<WindowSelectorItem*, bool> {
   explicit WindowSelectorItemComparator(const aura::Window* target_window)
       : target(target_window) {
   }
 
   bool operator()(WindowSelectorItem* window) const {
-    return window->HasSelectableWindow(target);
+    return window->GetWindow() == target;
   }
 
   const aura::Window* target;
-};
-
-// A comparator for locating a WindowSelectorItem given a targeted window.
-struct WindowSelectorItemTargetComparator
-    : public std::unary_function<WindowSelectorItem*, bool> {
-  explicit WindowSelectorItemTargetComparator(const aura::Window* target_window)
-      : target(target_window) {
-  }
-
-  bool operator()(WindowSelectorItem* window) const {
-    return window->Contains(target);
-  }
-
-  const aura::Window* target;
 };
 
 // Conceptually the window overview is a table or grid of cells having this
 // fixed aspect ratio. The number of columns is determined by maximizing the
 // area of them based on the number of window_list.
 const float kCardAspectRatio = 4.0f / 3.0f;
 
 // The minimum number of cards along the major axis (i.e. horizontally on a
 // landscape orientation).
 const int kMinCardsMajor = 3;
@@ skipping 29 matching lines @@
   return vector;
 }
 
 }  // namespace
 
 WindowGrid::WindowGrid(aura::Window* root_window,
                        const std::vector<aura::Window*>& windows,
                        WindowSelector* window_selector)
     : root_window_(root_window),
       window_selector_(window_selector) {
-  WindowSelectorItem* panels_item = nullptr;
-
-  std::set<aura::Window*> panels_item_windows;
-  aura::Window* panels_parent = nullptr;
 
   for (aura::Window::Windows::const_iterator iter = windows.begin();
        iter != windows.end(); ++iter) {
     if ((*iter)->GetRootWindow() != root_window)
       continue;
     (*iter)->AddObserver(this);
     observed_windows_.insert(*iter);
 
-    if ((*iter)->type() == ui::wm::WINDOW_TYPE_PANEL &&
-        wm::GetWindowState(*iter)->panel_attached()) {
-      // Attached panel windows are grouped into a single overview item per
-      // grid.
-      if (!panels_item) {
-        panels_item = new WindowSelectorItem(root_window_);
-        window_list_.push_back(panels_item);
-      }
-      DCHECK(panels_parent == nullptr || panels_parent == (*iter)->parent());
-      panels_parent = (*iter)->parent();
-      panels_item_windows.insert(*iter);
-    } else {
-      WindowSelectorItem* selector_item = new WindowSelectorItem(root_window_);
-      window_list_.push_back(selector_item);
-      selector_item->AddWindow(*iter);
-    }
-  }
-
-  if (panels_item) {
-    // Sort and add panel windows in reverse z order to the WindowSelectorItem
-    // so that the transparent overlays are in the proper order.
-
-    CHECK_GT(panels_item_windows.size(), 0u);
-
-    const Windows& children = panels_parent->children();
-    for (Windows::const_reverse_iterator iter = children.rbegin();
-        iter != children.rend(); ++iter) {
-      if (panels_item_windows.find(*iter) != panels_item_windows.end())
-        panels_item->AddWindow(*iter);
-    }
+    window_list_.push_back(new WindowSelectorItem(root_window_, *iter));
   }
 }
 
 WindowGrid::~WindowGrid() {
   for (std::set<aura::Window*>::iterator iter = observed_windows_.begin();
        iter != observed_windows_.end(); iter++) {
     (*iter)->RemoveObserver(this);
   }
 }
 
@@ skipping 44 matching lines @@
       num_rows * window_size.height()) / 2;
 
   for (size_t i = 0; i < window_list_.size(); ++i) {
     gfx::Transform transform;
     int column = i % num_columns_;
     int row = i / num_columns_;
     gfx::Rect target_bounds(window_size.width() * column + x_offset,
                             window_size.height() * row + y_offset,
                             window_size.width(),
                             window_size.height());
-    window_list_[i]->SetBounds(root_window_, target_bounds, animate ?
+    window_list_[i]->SetBounds(target_bounds, animate ?
         OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS :
         OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
   }
 
   // If we have less than |kMinCardsMajor| windows, adjust the column_ value to
   // reflect how many "real" columns we have.
   if (num_columns_ > window_list_.size())
     num_columns_ = window_list_.size();
 
   // If the selection widget is active, reposition it without any animation.
@@ skipping 65 matching lines @@
                       out_of_bounds, animate);
   return out_of_bounds;
 }
 
 WindowSelectorItem* WindowGrid::SelectedWindow() const {
   CHECK(selected_index_ < window_list_.size());
   return window_list_[selected_index_];
 }
 
 bool WindowGrid::Contains(const aura::Window* window) const {
-  return std::find_if(window_list_.begin(), window_list_.end(),
-                      WindowSelectorItemTargetComparator(window)) !=
-                          window_list_.end();
+  for (auto window_item : window_list_) {
+    if (window_item->Contains(window))
+      return true;
+  }
+  return false;
 }
 
 void WindowGrid::FilterItems(const base::string16& pattern) {
   base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents finder(pattern);
   for (ScopedVector<WindowSelectorItem>::iterator iter = window_list_.begin();
        iter != window_list_.end(); iter++) {
-    if (finder.Search((*iter)->SelectionWindow()->title(), nullptr, nullptr)) {
+    if (finder.Search((*iter)->GetWindow()->title(), nullptr, nullptr)) {
       (*iter)->SetDimmed(false);
     } else {
       (*iter)->SetDimmed(true);
       if (selection_widget_ && SelectedWindow() == *iter)
         selection_widget_.reset();
     }
   }
 }
 
 void WindowGrid::OnWindowDestroying(aura::Window* window) {
   window->RemoveObserver(this);
   observed_windows_.erase(window);
   ScopedVector<WindowSelectorItem>::iterator iter =
       std::find_if(window_list_.begin(), window_list_.end(),
                    WindowSelectorItemComparator(window));
 
   DCHECK(iter != window_list_.end());
 
-  (*iter)->RemoveWindow(window);
-
-  // If there are still windows in this selector entry then the overview is
-  // still active and the active selection remains the same.
-  if (!(*iter)->empty())
-    return;
+  (*iter)->OnWindowDestroyed();

[jonross, 2015/01/15 13:37:47]

Remove this.

Instead WindowSelectorItem should have three possible shutdown scenarios:
  - Window closed, no animation.
  - Window activate, an animation to restore the window
  - Selection has ended, animation to the previous state.

For this:
  - WindowSelectorItem's deconstructor should no longer trigger an animation by
default
  - WindowSelectorItem::RestoreWindowOnExit should continue to set a default
transform/opacity
  - WindowSelectorItem needs the current deconstructor's animation to be moved
to a separate method. WindowSelector::CancelSelection can then notify each
WindowSelectorItem to perform this.

[bruthig, 2015/01/15 18:27:25]

Done.

 
   size_t removed_index = iter - window_list_.begin();
   window_list_.erase(iter);
 
   if (empty()) {
     // If the grid is now empty, notify the window selector so that it erases us
     // from its grid list.
     window_selector_->OnGridEmpty(this);
     return;
   }
 
   // If selecting, update the selection index.
   if (selection_widget_) {
     bool send_focus_alert = selected_index_ == removed_index;
     if (selected_index_ >= removed_index && selected_index_ != 0)
       selected_index_--;
     if (send_focus_alert)
       SelectedWindow()->SendFocusAlert();
   }
 
   PositionWindows(true);
 }
 
 void WindowGrid::OnWindowBoundsChanged(aura::Window* window,
                                        const gfx::Rect& old_bounds,
                                        const gfx::Rect& new_bounds) {
   ScopedVector<WindowSelectorItem>::const_iterator iter =
       std::find_if(window_list_.begin(), window_list_.end(),
-                   WindowSelectorItemTargetComparator(window));
+                   WindowSelectorItemComparator(window));
   DCHECK(iter != window_list_.end());
 
   // Immediately finish any active bounds animation.
   window->layer()->GetAnimator()->StopAnimatingProperty(
       ui::LayerAnimationElement::BOUNDS);
 
   // Recompute the transform for the window.
   (*iter)->RecomputeWindowTransforms();
 }
 
@@ skipping 89 matching lines @@
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     selection_widget_->SetBounds(SelectedWindow()->target_bounds());
     selection_widget_->SetOpacity(kWindowOverviewSelectorOpacity);
     return;
   }
   selection_widget_->SetBounds(SelectedWindow()->target_bounds());
   selection_widget_->SetOpacity(kWindowOverviewSelectorOpacity);
 }
 
 }  // namespace ash