[Athena] Fix switching activities by swiping from the right bezel

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/screen/public/screen_manager.h"
 #include "athena/util/container_priorities.h"
@@ skipping 158 matching lines @@
   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;
 }
 
+void WindowManagerImpl::ToggleSplitView() {
+  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 (split_view_controller_->CanActivateSplitViewMode()) {
+    FOR_EACH_OBSERVER(WindowManagerObserver,
+                      observers_,
+                      OnSplitViewModeEnter());
+    split_view_controller_->ActivateSplitMode(NULL, NULL, NULL);
+  }
+}
+
 void WindowManagerImpl::ToggleOverview() {
   if (IsOverviewModeActive()) {
     SetInOverview(false);
 
     // Activate the window which was active prior to entering overview.
     const aura::Window::Windows windows =
         window_list_provider_->GetWindowList();
     if (!windows.empty()) {
       aura::Window* window = windows.back();
       // Show the window in case the exit overview animation has finished and
@@ skipping 45 matching lines @@
 
 void WindowManagerImpl::AddObserver(WindowManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WindowManagerImpl::ToggleSplitViewForTest() {
-  ToggleSplitview();
+  ToggleSplitView();
 }
 
 WindowListProvider* WindowManagerImpl::GetWindowListProvider() {
   return window_list_provider_.get();
 }
 
 void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
   SetInOverview(false);
 
   // Show the window in case the exit overview animation has finished and
@@ skipping 28 matching lines @@
                                                     gfx::Transform())));
     window->SetTransform(transform);
   }
 }
 
 void WindowManagerImpl::OnSelectSplitViewWindow(aura::Window* left,
                                                 aura::Window* right,
                                                 aura::Window* to_activate) {
   SetInOverview(false);
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeEnter());
-  split_view_controller_->ActivateSplitMode(left, right);
-  wm::ActivateWindow(to_activate);
+  split_view_controller_->ActivateSplitMode(left, right, to_activate);
 }
 
 void WindowManagerImpl::OnWindowDestroying(aura::Window* window) {
   if (window == container_)
     container_.reset();
 }
 
 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();
+      ToggleSplitView();
       break;
   }
   return true;
 }
 
-void WindowManagerImpl::ToggleSplitview() {
-  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 (split_view_controller_->CanActivateSplitViewMode()) {
-    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;
   aura::Window* behind = NULL;
   if (iter != windows.rend())
     behind = *iter++;
 
@@ skipping 30 matching lines @@
     next_window->SetTransform(transform);
   }
 }
 
 void WindowManagerImpl::OnTitleDragCompleted(aura::Window* window) {
   aura::Window* next_window = GetWindowBehind(window);
   if (!next_window)
     return;
   if (split_view_controller_->IsSplitViewModeActive()) {
     split_view_controller_->ReplaceWindow(window, next_window);
-    wm::ActivateWindow(next_window);
   } else {
     ui::ScopedLayerAnimationSettings
         settings(next_window->layer()->GetAnimator());
     settings.AddObserver(new ui::ClosureAnimationObserver(
         base::Bind(&SetWindowState,
                    base::Unretained(next_window),
                    window->bounds(),
                    gfx::Transform())));
 
     gfx::Transform transform;
@@ skipping 30 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena