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

ash/wm/overview/window_selector.cc

 // Copyright 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/overview/window_selector.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 74 matching lines @@
 };
 
 // A comparator for locating a selectable window 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);
+    return window->GetWindow() == target;
   }
 
   const aura::Window* target;
 };
 
 // A comparator for locating a selector item for a given root.
 struct WindowSelectorItemForRoot
     : public std::unary_function<WindowSelectorItem*, bool> {
   explicit WindowSelectorItemForRoot(const aura::Window* root)
       : root_window(root) {
@@ skipping 104 matching lines @@
   textfield->RequestFocus();
 
   return widget;
 }
 
 }  // namespace
 
 const int WindowSelector::kTextFilterBottomEdge =
     kTextFilterDistanceFromTop + kTextFilterHeight;
 
-WindowSelector::WindowSelector(const WindowList& windows,
-                               WindowSelectorDelegate* delegate)
+WindowSelector::WindowSelector(WindowSelectorDelegate* delegate)
     : delegate_(delegate),
       restore_focus_window_(aura::client::GetFocusClient(
           Shell::GetPrimaryRootWindow())->GetFocusedWindow()),
       ignore_activations_(false),
       selected_grid_index_(0),
       overview_start_time_(base::Time::Now()),
       num_key_presses_(0),
       num_items_(0),
       showing_selection_widget_(false),
       text_filter_string_length_(0),
-      num_times_textfield_cleared_(0) {
+      num_times_textfield_cleared_(0),
+      restoring_minimized_windows_(false) {
   DCHECK(delegate_);
-  Shell* shell = Shell::GetInstance();
-  shell->OnOverviewModeStarting();
+}
 
+WindowSelector::~WindowSelector() {
+  RemoveAllObservers();
+}
+
+// NOTE: The work done in Init() is not done in the constructor because it may
+// cause other, unrelated classes, (ie PanelLayoutManager) to make indirect
+// calls to restoring_minimized_windows() on a partially constructed object.
+void WindowSelector::Init(const WindowList& windows) {
   if (restore_focus_window_)
     restore_focus_window_->AddObserver(this);
 
   const aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (aura::Window::Windows::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); iter++) {
     // Observed switchable containers for newly created windows on all root
     // windows.
     for (size_t i = 0; i < kSwitchableWindowContainerIdsLength; ++i) {
       aura::Window* container = Shell::GetContainer(*iter,
           kSwitchableWindowContainerIds[i]);
       container->AddObserver(this);
       observed_windows_.insert(container);
     }
 
     // Hide the callout widgets for panels. It is safe to call this for
     // root windows that don't contain any panel windows.
     static_cast<PanelLayoutManager*>(
         Shell::GetContainer(*iter, kShellWindowId_PanelContainer)
             ->layout_manager())->SetShowCalloutWidgets(false);
 
     scoped_ptr<WindowGrid> grid(new WindowGrid(*iter, windows, this));
     if (grid->empty())
       continue;
     num_items_ += grid->size();
     grid_list_.push_back(grid.release());
   }
 
-  // Do not call PrepareForOverview until all items are added to window_list_ as
-  // we don't want to cause any window updates until all windows in overview
-  // are observed. See http://crbug.com/384495.
-  for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
-       iter != grid_list_.end(); ++iter) {
-    (*iter)->PrepareForOverview();
-    (*iter)->PositionWindows(true);
+  {
+    // The calls to WindowGrid::PrepareForOverview() and CreateTextFilter(...)
+    // requires some LayoutManagers (ie PanelLayoutManager) to perform layouts
+    // so that windows are correctly visible and properly animated in overview
+    // mode. Otherwise these layouts should be suppressed during overview mode
+    // so they don't conflict with overview mode animations. The
+    // |restoring_minimized_windows_| flag enables the PanelLayoutManager to
+    // make this decision.
+    base::AutoReset<bool> auto_restoring_minimized_windows(
+        &restoring_minimized_windows_, true);
+
+    // Do not call PrepareForOverview until all items are added to window_list_
+    // as we don't want to cause any window updates until all windows in
+    // overview are observed. See http://crbug.com/384495.
+    for (auto window_grid : grid_list_) {
+      window_grid->PrepareForOverview();
+      window_grid->PositionWindows(true);
+    }
+
+    text_filter_widget_.reset(
+        CreateTextFilter(this, Shell::GetPrimaryRootWindow()));
   }
 
   DCHECK(!grid_list_.empty());
   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.Items", num_items_);
 
-  text_filter_widget_.reset(
-      CreateTextFilter(this, Shell::GetPrimaryRootWindow()));
+  Shell* shell = Shell::GetInstance();
 
   shell->activation_client()->AddObserver(this);
 
   shell->GetScreen()->AddObserver(this);
   shell->metrics()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW);
   HideAndTrackNonOverviewWindows();
   // Send an a11y alert.
   shell->accessibility_delegate()->TriggerAccessibilityAlert(
       ui::A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
 
   UpdateShelfVisibility();
 }
 
-WindowSelector::~WindowSelector() {
-  Shell* shell = Shell::GetInstance();
-
+// NOTE: The work done in Shutdown() is not done in the destructor because it
+// may cause other, unrelated classes, (ie PanelLayoutManager) to make indirect
+// calls to restoring_minimized_windows() on a partially destructed object.
+void WindowSelector::Shutdown() {
   ResetFocusRestoreWindow(true);
-  for (std::set<aura::Window*>::iterator iter = observed_windows_.begin();
-       iter != observed_windows_.end(); ++iter) {
-    (*iter)->RemoveObserver(this);
-  }
-  shell->activation_client()->RemoveObserver(this);
+  RemoveAllObservers();
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (aura::Window::Windows::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); iter++) {
     // Un-hide the callout widgets for panels. It is safe to call this for
     // root_windows that don't contain any panel windows.
     static_cast<PanelLayoutManager*>(
         Shell::GetContainer(*iter, kShellWindowId_PanelContainer)
             ->layout_manager())->SetShowCalloutWidgets(true);
   }
 
   const aura::WindowTracker::Windows hidden_windows(hidden_windows_.windows());
   for (aura::WindowTracker::Windows::const_iterator iter =
        hidden_windows.begin(); iter != hidden_windows.end(); ++iter) {
     ScopedOverviewAnimationSettings animation_settings(
         OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS,
         *iter);
     (*iter)->layer()->SetOpacity(1);
     (*iter)->Show();
   }
 
-  shell->GetScreen()->RemoveObserver(this);
-
   size_t remaining_items = 0;
-  for (ScopedVector<WindowGrid>::iterator iter = grid_list_.begin();
-      iter != grid_list_.end(); iter++) {
-    remaining_items += (*iter)->size();
+  for (auto window_grid : grid_list_) {
+    for (auto window_selector_item : window_grid->window_list())
+      window_selector_item->RestoreWindow();
+    remaining_items += window_grid->size();
   }
 
   DCHECK(num_items_ >= remaining_items);
   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.OverviewClosedItems",
                            num_items_ - remaining_items);
   UMA_HISTOGRAM_MEDIUM_TIMES("Ash.WindowSelector.TimeInOverview",
                              base::Time::Now() - overview_start_time_);
 
   // Record metrics related to text filtering.
   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.TextFilteringStringLength",
                            text_filter_string_length_);
   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.TextFilteringTextfieldCleared",
                            num_times_textfield_cleared_);
   if (text_filter_string_length_) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "Ash.WindowSelector.TimeInOverviewWithTextFiltering",
         base::Time::Now() - overview_start_time_);
     UMA_HISTOGRAM_COUNTS_100(
         "Ash.WindowSelector.ItemsWhenTextFilteringUsed",
         remaining_items);
   }
 
-  // TODO(flackr): Change this to OnOverviewModeEnded and move it to when
-  // everything is done.
-  shell->OnOverviewModeEnding();
-
   // Clearing the window list resets the ignored_by_shelf flag on the windows.
   grid_list_.clear();
   UpdateShelfVisibility();
 }
 
+void WindowSelector::RemoveAllObservers() {
+  Shell* shell = Shell::GetInstance();
+  for (std::set<aura::Window*>::iterator iter = observed_windows_.begin();

[jonross, 2015/01/16 20:10:20]

for(auto)

[bruthig, 2015/01/16 20:22:46]

Done.

+       iter != observed_windows_.end(); ++iter) {
+    (*iter)->RemoveObserver(this);
+  }
+  shell->activation_client()->RemoveObserver(this);
+  shell->GetScreen()->RemoveObserver(this);
+  if (restore_focus_window_)
+    restore_focus_window_->RemoveObserver(this);
+}
+
 void WindowSelector::CancelSelection() {
   delegate_->OnSelectionEnded();
 }
 
 void WindowSelector::OnGridEmpty(WindowGrid* grid) {
   ScopedVector<WindowGrid>::iterator iter =
       std::find(grid_list_.begin(), grid_list_.end(), grid);
   DCHECK(iter != grid_list_.end());
   grid_list_.erase(iter);
   // TODO(flackr): Use the previous index for more than two displays.
@@ skipping 33 matching lines @@
       if (!grid_list_[selected_grid_index_]->is_selecting())
         return false;
       UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.ArrowKeyPresses",
                                num_key_presses_);
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Ash.WindowSelector.KeyPressesOverItemsRatio",
           (num_key_presses_ * 100) / num_items_, 1, 300, 30);
       Shell::GetInstance()->metrics()->RecordUserMetricsAction(
           UMA_WINDOW_OVERVIEW_ENTER_KEY);
       wm::GetWindowState(grid_list_[selected_grid_index_]->
-                         SelectedWindow()->SelectionWindow())->Activate();
+                         SelectedWindow()->GetWindow())->Activate();
       break;
     default:
       // Not a key we are interested in, allow the textfield to handle it.
       return false;
   }
   return true;
 }
 
 void WindowSelector::OnDisplayAdded(const gfx::Display& display) {
 }
@@ skipping 44 matching lines @@
                    RootWindowGridComparator(gained_active->GetRootWindow()));
   if (grid == grid_list_.end())
     return;
   const std::vector<WindowSelectorItem*> windows = (*grid)->window_list();
 
   ScopedVector<WindowSelectorItem>::const_iterator iter = std::find_if(
       windows.begin(), windows.end(),
       WindowSelectorItemTargetComparator(gained_active));
 
   if (iter != windows.end())
-    (*iter)->RestoreWindowOnExit(gained_active);
+    (*iter)->ShowWindowOnExit();
 
   // Don't restore focus on exit if a window was just activated.
   ResetFocusRestoreWindow(false);
   CancelSelection();
 }
 
 void WindowSelector::OnAttemptToReactivateWindow(aura::Window* request_active,
                                                  aura::Window* actual_active) {
   OnWindowActivated(request_active, actual_active);
 }
@@ skipping 107 matching lines @@
   for (size_t i = 0;
       i <= grid_list_.size() &&
       grid_list_[selected_grid_index_]->Move(direction, animate); i++) {
     // TODO(flackr): If there are more than two monitors, move between grids
     // in the requested direction.
     selected_grid_index_ = (selected_grid_index_ + 1) % grid_list_.size();
   }
 }
 
 }  // namespace ash