athena: A simpler implementation of WindowListProvider.

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/public/window_manager.h"
 
 #include <algorithm>
 
 #include "athena/common/container_priorities.h"
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/public/screen_manager.h"
 #include "athena/wm/bezel_controller.h"
-#include "athena/wm/mru_window_tracker.h"
 #include "athena/wm/public/window_manager_observer.h"
 #include "athena/wm/split_view_controller.h"
 #include "athena/wm/title_drag_controller.h"
+#include "athena/wm/window_list_provider_impl.h"
 #include "athena/wm/window_overview_mode.h"
 #include "base/logging.h"
 #include "base/observer_list.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/core/wm_state.h"
 #include "ui/wm/public/activation_client.h"
 #include "ui/wm/public/window_types.h"
@@ skipping 45 matching lines @@
   virtual bool OnAcceleratorFired(int command_id,
                                   const ui::Accelerator& accelerator) OVERRIDE;
 
   // TitleDragControllerDelegate:
   virtual aura::Window* GetWindowBehind(aura::Window* window) OVERRIDE;
   virtual void OnTitleDragStarted(aura::Window* window) OVERRIDE;
   virtual void OnTitleDragCompleted(aura::Window* window) OVERRIDE;
   virtual void OnTitleDragCanceled(aura::Window* window) OVERRIDE;
 
   scoped_ptr<aura::Window> container_;
-  scoped_ptr<MruWindowTracker> mru_window_tracker_;
+  scoped_ptr<WindowListProvider> window_list_provider_;
   scoped_ptr<WindowOverviewMode> overview_;
   scoped_ptr<BezelController> bezel_controller_;
   scoped_ptr<SplitViewController> split_view_controller_;
   scoped_ptr<wm::WMState> wm_state_;
   scoped_ptr<TitleDragController> title_drag_controller_;
   scoped_ptr<wm::ShadowController> shadow_controller_;
   ObserverList<WindowManagerObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerImpl);
 };
@@ skipping 18 matching lines @@
 };
 
 class WindowManagerImpl* instance = NULL;
 
 WindowManagerImpl::WindowManagerImpl() {
   ScreenManager::ContainerParams params("DefaultContainer", CP_DEFAULT);
   params.can_activate_children = true;
   container_.reset(ScreenManager::Get()->CreateDefaultContainer(params));
   container_->SetLayoutManager(new AthenaContainerLayoutManager);
   container_->AddObserver(this);
-  mru_window_tracker_.reset(new MruWindowTracker(container_.get()));
+  window_list_provider_.reset(new WindowListProviderImpl(container_.get()));
   bezel_controller_.reset(new BezelController(container_.get()));
-  split_view_controller_.reset(new SplitViewController(
-      container_.get(), mru_window_tracker_.get(), this));
+  split_view_controller_.reset(
+      new SplitViewController(container_.get(), window_list_provider_.get()));
   bezel_controller_->set_left_right_delegate(split_view_controller_.get());
   container_->AddPreTargetHandler(bezel_controller_.get());
   title_drag_controller_.reset(new TitleDragController(container_.get(), this));
   wm_state_.reset(new wm::WMState());
   aura::client::ActivationClient* activation_client =
       aura::client::GetActivationClient(container_->GetRootWindow());
   shadow_controller_.reset(new wm::ShadowController(activation_client));
   instance = this;
   InstallAccelerators();
 }
 
 WindowManagerImpl::~WindowManagerImpl() {
   overview_.reset();
   split_view_controller_.reset();
-  mru_window_tracker_.reset();
+  window_list_provider_.reset();
   if (container_) {
     container_->RemoveObserver(this);
     container_->RemovePreTargetHandler(bezel_controller_.get());
   }
   // |title_drag_controller_| needs to be reset before |container_|.
   title_drag_controller_.reset();
   container_.reset();
   instance = NULL;
 }
 
@@ skipping 16 matching lines @@
 
 bool WindowManagerImpl::IsOverviewModeActive() {
   return overview_;
 }
 
 void WindowManagerImpl::SetInOverview(bool active) {
   bool in_overview = !!overview_;
   if (active == in_overview)
     return;
 
+  split_view_controller_->DeactivateSplitMode();

[mfomitchev, 2014/08/15 18:30:51]

Can we only do it when active == true? Doing it every time for active == false
is a waste and might interfere with entering split view from overview.

[sadrul, 2014/08/15 18:44:18]

Done.

+  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 mru_window_tracker_.
-    aura::Window::Windows window_list = mru_window_tracker_->GetWindowList();
+    // 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);
-    overview_ = WindowOverviewMode::Create(container_.get(),
-                                           mru_window_tracker_.get(),
-                                           this);
+    overview_ = WindowOverviewMode::Create(
+        container_.get(), window_list_provider_.get(), this);
   } else {
+    CHECK(!split_view_controller_->IsSplitViewModeActive());
     overview_.reset();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                       OnOverviewModeExit());
   }
 }
 
 void WindowManagerImpl::InstallAccelerators() {
   const AcceleratorData accelerator_data[] = {
       {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_NONE, CMD_TOGGLE_OVERVIEW,
        AF_NONE},
   };
   AcceleratorManager::Get()->RegisterAccelerators(
       accelerator_data, arraysize(accelerator_data), this);
 }
 
 void WindowManagerImpl::AddObserver(WindowManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
-  mru_window_tracker_->MoveToFront(window);
   wm::ActivateWindow(window);
   SetInOverview(false);
 }
 
 void WindowManagerImpl::OnSplitViewMode(aura::Window* left,
                                         aura::Window* right) {
   SetInOverview(false);
   split_view_controller_->ActivateSplitMode(left, right);
 }
 
@@ skipping 94 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena