athena: Add some tests for the existing wm functionalities.

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 "athena/wm/window_manager_impl.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/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"
 
 namespace athena {
 namespace {
 
-class WindowManagerImpl : public WindowManager,
-                          public WindowOverviewModeDelegate,
-                          public aura::WindowObserver,
-                          public AcceleratorHandler,
-                          public TitleDragControllerDelegate {
- public:
-  WindowManagerImpl();
-  virtual ~WindowManagerImpl();
-
-  void Layout();
-
-  // WindowManager:
-  virtual void ToggleOverview() OVERRIDE;
-
-  virtual bool IsOverviewModeActive() OVERRIDE;
-
- private:
-  enum Command {
-    CMD_TOGGLE_OVERVIEW,
-  };
-
-  // Sets whether overview mode is active.
-  void SetInOverview(bool active);
-
-  void InstallAccelerators();
-
-  // WindowManager:
-  virtual void AddObserver(WindowManagerObserver* observer) OVERRIDE;
-  virtual void RemoveObserver(WindowManagerObserver* observer) OVERRIDE;
-
-  // WindowOverviewModeDelegate:
-  virtual void OnSelectWindow(aura::Window* window) OVERRIDE;
-  virtual void OnSplitViewMode(aura::Window* left,
-                               aura::Window* right) OVERRIDE;
-
-  // aura::WindowObserver
-  virtual void OnWindowAdded(aura::Window* new_window) OVERRIDE;
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
-
-  // AcceleratorHandler:
-  virtual bool IsCommandEnabled(int command_id) const OVERRIDE;
-  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<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);
-};
+class WindowManagerImpl* instance = NULL;
 
 class AthenaContainerLayoutManager : public aura::LayoutManager {
  public:
   AthenaContainerLayoutManager();
   virtual ~AthenaContainerLayoutManager();
 
  private:
   // aura::LayoutManager:
   virtual void OnWindowResized() OVERRIDE;
   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE;
   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE;
   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE;
   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
                                               bool visible) OVERRIDE;
   virtual void SetChildBounds(aura::Window* child,
                               const gfx::Rect& requested_bounds) OVERRIDE;
 
   DISALLOW_COPY_AND_ASSIGN(AthenaContainerLayoutManager);
 };
 
-class WindowManagerImpl* instance = NULL;
+AthenaContainerLayoutManager::AthenaContainerLayoutManager() {
+}
+
+AthenaContainerLayoutManager::~AthenaContainerLayoutManager() {
+}
+
+void AthenaContainerLayoutManager::OnWindowResized() {
+  instance->Layout();
+}
+
+void AthenaContainerLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
+  instance->Layout();
+}
+
+void AthenaContainerLayoutManager::OnWillRemoveWindowFromLayout(
+    aura::Window* child) {
+}
+
+void AthenaContainerLayoutManager::OnWindowRemovedFromLayout(
+    aura::Window* child) {
+  instance->Layout();
+}
+
+void AthenaContainerLayoutManager::OnChildWindowVisibilityChanged(
+    aura::Window* child,
+    bool visible) {
+  instance->Layout();
+}
+
+void AthenaContainerLayoutManager::SetChildBounds(
+    aura::Window* child,
+    const gfx::Rect& requested_bounds) {
+  if (!requested_bounds.IsEmpty())
+    SetChildBoundsDirect(child, requested_bounds);
+}
+
+}  // namespace
 
 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);
   window_list_provider_.reset(new WindowListProviderImpl(container_.get()));
   bezel_controller_.reset(new BezelController(container_.get()));
   split_view_controller_.reset(
@@ skipping 170 matching lines @@
   wm::ActivateWindow(next_window);
 }
 
 void WindowManagerImpl::OnTitleDragCanceled(aura::Window* window) {
   aura::Window* next_window = GetWindowBehind(window);
   if (!next_window)
     return;
   next_window->SetTransform(gfx::Transform());
 }
 
-AthenaContainerLayoutManager::AthenaContainerLayoutManager() {
-}
-
-AthenaContainerLayoutManager::~AthenaContainerLayoutManager() {
-}
-
-void AthenaContainerLayoutManager::OnWindowResized() {
-  instance->Layout();
-}
-
-void AthenaContainerLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
-  instance->Layout();
-}
-
-void AthenaContainerLayoutManager::OnWillRemoveWindowFromLayout(
-    aura::Window* child) {
-}
-
-void AthenaContainerLayoutManager::OnWindowRemovedFromLayout(
-    aura::Window* child) {
-  instance->Layout();
-}
-
-void AthenaContainerLayoutManager::OnChildWindowVisibilityChanged(
-    aura::Window* child,
-    bool visible) {
-  instance->Layout();
-}
-
-void AthenaContainerLayoutManager::SetChildBounds(
-    aura::Window* child,
-    const gfx::Rect& requested_bounds) {
-  if (!requested_bounds.IsEmpty())
-    SetChildBoundsDirect(child, requested_bounds);
-}
-
-}  // namespace
-
 // static
 WindowManager* WindowManager::Create() {
   DCHECK(!instance);
   new WindowManagerImpl;
   DCHECK(instance);
   return instance;
 }
 
 // static
 void WindowManager::Shutdown() {
   DCHECK(instance);
   delete instance;
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena