mus: Fix activation cycle direction.

components/mus/ws/focus_controller.cc

 // Copyright 2015 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 "components/mus/ws/focus_controller.h"
 
 #include "base/macros.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "components/mus/ws/focus_controller_delegate.h"
 #include "components/mus/ws/focus_controller_observer.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_drawn_tracker.h"
 
 namespace mus {
 namespace ws {
 
 namespace {
 
-ServerWindow* GetDeepestFirstDescendant(ServerWindow* window) {
+ServerWindow* GetDeepestLastDescendant(ServerWindow* window) {
   while (!window->children().empty())
-    window = window->children()[0];
+    window = window->children().back();
   return window;
 }
 
 // This can be used to iterate over each node in a rooted tree for the purpose
 // of shifting focus/activation.
 class WindowTreeIterator {
  public:
   explicit WindowTreeIterator(ServerWindow* root) : root_(root) {}
   ~WindowTreeIterator() {}
 
   ServerWindow* GetNext(ServerWindow* window) const {
     if (window == root_ || window == nullptr)
-      return GetDeepestFirstDescendant(root_);
+      return GetDeepestLastDescendant(root_);
 
     // Return the next sibling.
     ServerWindow* parent = window->parent();
     if (parent) {
       const ServerWindow::Windows& siblings = parent->children();
-      ServerWindow::Windows::const_iterator iter =
-          std::find(siblings.begin(), siblings.end(), window);
-      DCHECK(iter != siblings.end());
+      ServerWindow::Windows::const_reverse_iterator iter =
+          std::find(siblings.rbegin(), siblings.rend(), window);
+      DCHECK(iter != siblings.rend());
       ++iter;
-      if (iter != siblings.end())
-        return GetDeepestFirstDescendant(*iter);
+      if (iter != siblings.rend())
+        return GetDeepestLastDescendant(*iter);
     }
 
     // All children and siblings have been explored. Next is the parent.
     return parent;
   }
 
  private:
   ServerWindow* root_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeIterator);
 };
 
 }  // namespace
 
 FocusController::FocusController(FocusControllerDelegate* delegate,
                                  ServerWindow* root)
     : delegate_(delegate),
       root_(root),
       focused_window_(nullptr),
-      active_window_(nullptr) {
+      active_window_(nullptr),
+      activation_reason_(ActivationChangeReason::UNKNONW) {
   DCHECK(delegate_);
   DCHECK(root_);
 }
 
-FocusController::~FocusController() {}
+FocusController::~FocusController() {
+  ClearCycleWindows();
+}
 
 void FocusController::SetFocusedWindow(ServerWindow* window) {
   if (GetFocusedWindow() == window)
     return;
 
   SetFocusedWindowImpl(FocusControllerChangeSource::EXPLICIT, window);
 }
 
 ServerWindow* FocusController::GetFocusedWindow() {
   return focused_window_;
 }
 
 void FocusController::ActivateNextWindow() {
   WindowTreeIterator iter(root_);
   ServerWindow* activate = active_window_;
-  do {
+  while (true) {
     activate = iter.GetNext(activate);
-  } while (activate != active_window_ && !CanBeActivated(activate));
-  SetActiveWindow(activate);
+    if (activation_reason_ == ActivationChangeReason::CYCLE) {
+      if (activate == active_window_) {
+        // We have cycled over all the activatable windows. Remove the oldest
+        // window that was cycled.
+        if (!cycle_windows_.empty()) {
+          cycle_windows_.front()->RemoveObserver(this);
+          cycle_windows_.erase(cycle_windows_.begin());
+          continue;
+        }
+      } else if (std::find(cycle_windows_.begin(), cycle_windows_.end(),

[sky, 2016/01/06 21:02:39]

FYI: you can use ContainsValue(cycle_windows_, activate) if you prefer (recently
added to stl_util.h).

+                           activate) != cycle_windows_.end()) {
+        // We are cycling between activated windows, and this window has already
+        // been through the cycle. So skip over it.
+        continue;
+      }
+    }
+    if (activate == active_window_ || CanBeActivated(activate))
+      break;
+  }
+  SetActiveWindow(activate, ActivationChangeReason::CYCLE);
 
   if (active_window_) {
     // Do not shift focus if the focused window already lives in the active
     // window.
     if (focused_window_ && active_window_->Contains(focused_window_))
       return;
     // Focus the first focusable window in the tree.
     WindowTreeIterator iter(active_window_);
     ServerWindow* focus = nullptr;
     do {
       focus = iter.GetNext(focus);
     } while (focus != active_window_ && !CanBeFocused(focus));
     SetFocusedWindow(focus);
   } else {
     SetFocusedWindow(nullptr);
   }
 }
 
 void FocusController::AddObserver(FocusControllerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void FocusController::RemoveObserver(FocusControllerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void FocusController::SetActiveWindow(ServerWindow* window) {
+void FocusController::SetActiveWindow(ServerWindow* window,
+                                      ActivationChangeReason reason) {
   DCHECK(!window || CanBeActivated(window));
   if (active_window_ == window)
     return;
+  if (reason != ActivationChangeReason::CYCLE) {
+    ClearCycleWindows();
+  } else if (activation_reason_ != ActivationChangeReason::CYCLE) {
+    DCHECK(cycle_windows_.empty());
+    if (active_window_) {
+      active_window_->AddObserver(this);
+      cycle_windows_.push_back(active_window_);
+    }
+  }
+
   ServerWindow* old_active = active_window_;
   active_window_ = window;
-  if (old_active != active_window_) {
-    FOR_EACH_OBSERVER(FocusControllerObserver, observers_,
-                      OnActivationChanged(old_active, active_window_));
+  activation_reason_ = reason;
+  FOR_EACH_OBSERVER(FocusControllerObserver, observers_,
+                    OnActivationChanged(old_active, active_window_));
+  if (active_window_ && activation_reason_ == ActivationChangeReason::CYCLE) {
+    active_window_->AddObserver(this);

[sky, 2016/01/06 21:02:39]

nit: add an AddWindowToCycleWindows (or something similarly named) and use it on
147-148 as well.

+    cycle_windows_.push_back(active_window_);
   }
 }
 
 bool FocusController::CanBeFocused(ServerWindow* window) const {
   // All ancestors of |window| must be drawn, and be focusable.
   for (ServerWindow* w = window; w; w = w->parent()) {
     if (!w->IsDrawn())
       return false;
     if (!w->can_focus())
       return false;
@@ skipping 45 matching lines @@
     ServerWindow* window) {
   if (window && !CanBeFocused(window))
     return;
   ServerWindow* old_focused = GetFocusedWindow();
 
   DCHECK(!window || window->IsDrawn());
 
   // Activate the closest activatable ancestor window.
   // TODO(sad): The window to activate doesn't necessarily have to be a direct
   // ancestor (e.g. could be a transient parent).
-  SetActiveWindow(GetActivatableAncestorOf(window));
+  SetActiveWindow(GetActivatableAncestorOf(window),
+                  ActivationChangeReason::FOCUS);
 
   FOR_EACH_OBSERVER(FocusControllerObserver, observers_,
                     OnFocusChanged(change_source, old_focused, window));
 
   focused_window_ = window;
   // We can currently use only a single ServerWindowDrawnTracker since focused
   // window is expected to be a direct descendant of the active window.
   if (focused_window_ && active_window_) {
     DCHECK(active_window_->Contains(focused_window_));
   }
   ServerWindow* track_window = focused_window_;
   if (!track_window)
     track_window = active_window_;
   if (track_window)
     drawn_tracker_.reset(new ServerWindowDrawnTracker(track_window, this));
   else
     drawn_tracker_.reset();
 }
 
+void FocusController::ClearCycleWindows() {
+  while (!cycle_windows_.empty()) {
+    cycle_windows_.front()->RemoveObserver(this);
+    cycle_windows_.erase(cycle_windows_.begin());
+  }
+}
+
 void FocusController::OnDrawnStateWillChange(ServerWindow* ancestor,
                                              ServerWindow* window,
                                              bool is_drawn) {
   DCHECK(!is_drawn);
   DCHECK(root_->Contains(window));
   drawn_tracker_.reset();
 
   auto will_be_hidden = [ancestor, window](ServerWindow* w) {
     return w != ancestor && ancestor->Contains(w) && w->Contains(window);
   };
 
   // If |window| is |active_window_|, then activate the next activatable window
   // that does not belong to the subtree which is getting hidden.
   if (window == active_window_) {
     WindowTreeIterator iter(root_);
     ServerWindow* activate = active_window_;
     do {
       activate = iter.GetNext(activate);
     } while (activate != active_window_ &&
              (will_be_hidden(activate) || !CanBeActivated(activate)));
     if (activate == window)
       activate = nullptr;
-    SetActiveWindow(activate);
+    SetActiveWindow(activate, ActivationChangeReason::DRAWN_STATE_CHANGED);
 
     // Now make sure focus is in the active window.
     ServerWindow* focus = nullptr;
     if (active_window_) {
       WindowTreeIterator iter(active_window_);
       focus = nullptr;
       do {
         focus = iter.GetNext(focus);
       } while (focus != active_window_ &&
                (will_be_hidden(focus) || !CanBeFocused(focus)));
@@ skipping 16 matching lines @@
     focus = nullptr;
   SetFocusedWindowImpl(FocusControllerChangeSource::DRAWN_STATE_CHANGED, focus);
 }
 
 void FocusController::OnDrawnStateChanged(ServerWindow* ancestor,
                                           ServerWindow* window,
                                           bool is_drawn) {
   DCHECK(false);
 }
 
+void FocusController::OnWillDestroyWindow(ServerWindow* window) {
+  cycle_windows_.erase(
+      std::find(cycle_windows_.begin(), cycle_windows_.end(), window));

[sky, 2016/01/06 21:02:39]

also remove the observer here too.

+}
+
 }  // namespace ws
 }  // namespace mus