Switch Next Window Key functionality

ash/wm/window_cycle_controller.cc

 // Copyright (c) 2012 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/window_cycle_controller.h"
 
 #include <algorithm>
 
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
@@ skipping 131 matching lines @@
       Step(direction);
     }
   } else {
     // This is a simple, single-step window cycle.
     StartCycling();
     Step(direction);
     StopCycling();
   }
 }
 
+void WindowCycleController::HandleLinearCycleWindow() {
+  if (!CanCycle() || IsCycling())
+    return;
+
+  // Use the reversed list of windows to prevent a 2-cycle of the most recent
+  // windows occurring.
+  WindowCycleList cycle_list(BuildWindowList(NULL,true));
+  cycle_list.Step(WindowCycleList::FORWARD);
+}
+
 void WindowCycleController::AltKeyReleased() {
   StopCycling();
 }
 
 // static
 std::vector<aura::Window*> WindowCycleController::BuildWindowList(
-    const std::list<aura::Window*>* mru_windows) {
+    const std::list<aura::Window*>* mru_windows,
+    bool top_most_at_end) {
   WindowCycleList::WindowList windows;
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
 
   aura::RootWindow* active_root = Shell::GetActiveRootWindow();
   for (Shell::RootWindowList::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     if (*iter == active_root)
       continue;
     for (size_t i = 0; i < arraysize(kContainerIds); ++i)
       AddCycleWindows(*iter, kContainerIds[i], &windows);
@@ skipping 22 matching lines @@
       WindowCycleList::WindowList::iterator window =
           std::find(windows.begin(), windows.end(), *ix);
       if (window != windows.end()) {
         windows.erase(window);
         windows.push_back(*ix);
       }
     }
   }
 
   // Window cycling expects the topmost window at the front of the list.
-  std::reverse(windows.begin(), windows.end());
+  if (!top_most_at_end)
+    std::reverse(windows.begin(), windows.end());
 
   return windows;
 }
 
 void WindowCycleController::OnRootWindowAdded(aura::RootWindow* root_window) {
   for (size_t i = 0; i < arraysize(kContainerIds); ++i) {
     aura::Window* container =
         Shell::GetContainer(root_window, kContainerIds[i]);
     container->AddObserver(this);
   }
 
   aura::Window* default_container =
       Shell::GetContainer(root_window,
                           internal::kShellWindowId_DefaultContainer);
   for (size_t i = 0; i < default_container->children().size(); ++i) {
     aura::Window* workspace_window = default_container->children()[i];
     DCHECK_EQ(internal::kShellWindowId_WorkspaceContainer,
               workspace_window->id());
     workspace_window->AddObserver(this);
   }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WindowCycleController, private:
 
 void WindowCycleController::StartCycling() {
-  windows_.reset(new WindowCycleList(BuildWindowList(&mru_windows_)));
+  windows_.reset(new WindowCycleList(BuildWindowList(&mru_windows_, false)));
 }
 
 void WindowCycleController::Step(Direction direction) {
   DCHECK(windows_.get());
   windows_->Step(direction == FORWARD ? WindowCycleList::FORWARD :
                  WindowCycleList::BACKWARD);
 }
 
 void WindowCycleController::StopCycling() {
   windows_.reset();
@@ skipping 44 matching lines @@
   mru_windows_.remove(window);
   if (window->id() == internal::kShellWindowId_WorkspaceContainer)
     window->RemoveObserver(this);
 }
 
 void WindowCycleController::OnWindowDestroying(aura::Window* window) {
   window->RemoveObserver(this);
 }
 
 }  // namespace ash