Adding functions to the window_list_provider for accessing the activities window list

athena/wm/window_manager_impl.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 "athena/wm/window_manager_impl.h"
 
 #include <algorithm>
 
 #include "athena/common/container_priorities.h"
 #include "athena/screen/public/screen_manager.h"
@@ skipping 50 matching lines @@
 };
 
 AthenaContainerLayoutManager::AthenaContainerLayoutManager() {
 }
 
 AthenaContainerLayoutManager::~AthenaContainerLayoutManager() {
 }
 
 void AthenaContainerLayoutManager::OnWindowResized() {
   // Resize all the existing windows.
-  aura::Window::Windows list = instance->window_list_provider_->GetWindowList();
+  aura::Window::Windows list =
+      instance->window_list_provider_->GetCurrentWindowList();
   const gfx::Size work_area =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
   bool is_splitview = instance->split_view_controller_->IsSplitViewModeActive();
   gfx::Size split_size;
   if (is_splitview) {
     CHECK(instance->split_view_controller_->left_window());
     split_size =
         instance->split_view_controller_->left_window()->bounds().size();
   }
 
   for (aura::Window::Windows::const_iterator iter = list.begin();
        iter != list.end();
        ++iter) {
     aura::Window* window = *iter;
     if (is_splitview) {
       if (window == instance->split_view_controller_->left_window())
         window->SetBounds(gfx::Rect(split_size));
       else if (window == instance->split_view_controller_->right_window())
         window->SetBounds(
             gfx::Rect(gfx::Point(split_size.width(), 0), split_size));
       else
         window->SetBounds(gfx::Rect(work_area));
     } else {
       window->SetBounds(gfx::Rect(work_area));
     }
   }
 }
 
 void AthenaContainerLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
-  aura::Window::Windows list = instance->window_list_provider_->GetWindowList();
+  aura::Window::Windows list =
+      instance->window_list_provider_->GetCurrentWindowList();
   if (std::find(list.begin(), list.end(), child) == list.end())
     return;
   if (instance->split_view_controller_->IsSplitViewModeActive()) {
     instance->split_view_controller_->ReplaceWindow(
         instance->split_view_controller_->left_window(), child);
   } else {
     gfx::Size size =
         gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
     child->SetBounds(gfx::Rect(size));
   }
@@ skipping 65 matching lines @@
 void WindowManagerImpl::SetInOverview(bool active) {
   bool in_overview = !!overview_;
   if (active == in_overview)
     return;
 
   bezel_controller_->set_left_right_delegate(
       active ? NULL : split_view_controller_.get());
   if (active) {
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeEnter());
 
-    // Re-stack all windows in the order defined by window_list_provider_.
-    aura::Window::Windows window_list = window_list_provider_->GetWindowList();
-    aura::Window::Windows::iterator it;
-    for (it = window_list.begin(); it != window_list.end(); ++it)
-      container_->StackChildAtTop(*it);
+    // Note: The window_list_provider_ resembles the exact window list of the
+    // container, so no re-stacking is required before showing the OverviewMode.
     overview_ = WindowOverviewMode::Create(
         container_.get(), window_list_provider_.get(),
         split_view_controller_.get(), this);
   } else {
     overview_.reset();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeExit());
   }
 }
 
 void WindowManagerImpl::InstallAccelerators() {
@@ skipping 12 matching lines @@
 }
 
 void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WindowManagerImpl::ToggleSplitViewForTest() {
   ToggleSplitview();
 }
 
+WindowListProvider* WindowManagerImpl::GetWindowListProvider() {
+  return window_list_provider_.get();
+}
+
 void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
   if (split_view_controller_->IsSplitViewModeActive()) {
     split_view_controller_->DeactivateSplitMode();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeExit());
   }
   wm::ActivateWindow(window);
   SetInOverview(false);
   // If |window| does not have the size of the work-area, then make sure it is
   // resized.
   const gfx::Size work_area =
@@ skipping 58 matching lines @@
 void WindowManagerImpl::ToggleSplitview() {
   // TODO(oshima): Figure out what to do.
   if (IsOverviewModeActive())
     return;
 
   if (split_view_controller_->IsSplitViewModeActive()) {
     split_view_controller_->DeactivateSplitMode();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeExit());
     // Relayout so that windows are maximzied.
     container_->layout_manager()->OnWindowResized();
-  } else if (window_list_provider_->GetWindowList().size() > 1) {
+  } else if (window_list_provider_->GetCurrentWindowList().size() > 1) {
     FOR_EACH_OBSERVER(WindowManagerObserver,
                       observers_,
                       OnSplitViewModeEnter());
     split_view_controller_->ActivateSplitMode(NULL, NULL);
   }
 }
 
 aura::Window* WindowManagerImpl::GetWindowBehind(aura::Window* window) {
-  const aura::Window::Windows& windows = window_list_provider_->GetWindowList();
+  const aura::Window::Windows& windows =
+      window_list_provider_->GetCurrentWindowList();
   aura::Window::Windows::const_reverse_iterator iter =
       std::find(windows.rbegin(), windows.rend(), window);
   CHECK(iter != windows.rend());
   ++iter;
   aura::Window* behind = NULL;
   if (iter != windows.rend())
     behind = *iter++;
 
   if (split_view_controller_->IsSplitViewModeActive()) {
     aura::Window* left = split_view_controller_->left_window();
@@ skipping 79 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena