Decoupling visibility states from webcontent, adding visibility management in ResourceManager

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 199 matching lines @@
 }
 
 void WindowManagerImpl::AddObserver(WindowManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
+void WindowManagerImpl::ToggleSplitViewForTest() {
+  ToggleSplitview();
+}
+
 void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
-  if (split_view_controller_->IsSplitViewModeActive())
+  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 =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
   if (window->GetTargetBounds().size() != work_area) {
     const gfx::Rect& window_bounds = window->bounds();
     const gfx::Rect desired_bounds(work_area);
     gfx::Transform transform;
@@ skipping 10 matching lines @@
                                                     base::Unretained(window),
                                                     desired_bounds,
                                                     gfx::Transform())));
     window->SetTransform(transform);
   }
 }
 
 void WindowManagerImpl::OnSplitViewMode(aura::Window* left,
                                         aura::Window* right) {
   SetInOverview(false);
+  FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeEnter());
   split_view_controller_->ActivateSplitMode(left, right);
 }
 
 void WindowManagerImpl::OnWindowAdded(aura::Window* new_window) {
   // TODO(oshima): Creating a new window should updates the ovewview mode
   // instead of exitting.
   if (new_window->type() == ui::wm::WINDOW_TYPE_NORMAL)
     SetInOverview(false);
 }
 
 void WindowManagerImpl::OnWindowDestroying(aura::Window* window) {
   if (window == container_)
     container_.reset();
 }
 
-void WindowManagerImpl::OnWindowStackingChanged(aura::Window* window) {
-  // TODO(skuhne): Use |window_list_provider_->IsValidWindow(window)| instead.
-  if (window->type() == ui::wm::WINDOW_TYPE_NORMAL) {
-    FOR_EACH_OBSERVER(WindowManagerObserver,
-                      observers_,
-                      OnActivityOrderHasChanged());
-  }
-}
-
 bool WindowManagerImpl::IsCommandEnabled(int command_id) const {
   return true;
 }
 
 bool WindowManagerImpl::OnAcceleratorFired(int command_id,
                                            const ui::Accelerator& accelerator) {
   switch (command_id) {
     case CMD_TOGGLE_OVERVIEW:
       ToggleOverview();
       break;
     case CMD_TOGGLE_SPLIT_VIEW:
       ToggleSplitview();
       break;
   }
   return true;
 }
 
 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) {
+    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();
   aura::Window::Windows::const_reverse_iterator iter =
       std::find(windows.rbegin(), windows.rend(), window);
   CHECK(iter != windows.rend());
   ++iter;
@@ skipping 85 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena