Do not create workspace for fullscreen.

ash/wm/workspace/workspace_manager.cc

 // Copyright (c) 2012 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 "ash/wm/workspace/workspace_manager.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "ash/root_window_controller.h"
@@ skipping 95 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LayoutManagerImpl);
 };
 
 // WorkspaceManager -----------------------------------------------------------
 
 WorkspaceManager::WorkspaceManager(Window* contents_window)
     : contents_window_(contents_window),
       active_workspace_(NULL),
       shelf_(NULL),
       in_move_(false),
-      clear_unminimizing_workspace_factory_(this),
-      unminimizing_workspace_(NULL),
       app_terminating_(false),
       creating_fade_(false) {
   // Clobber any existing event filter.
   contents_window->SetEventFilter(NULL);
   // |contents_window| takes ownership of LayoutManagerImpl.
   contents_window->SetLayoutManager(new LayoutManagerImpl(this));
-  active_workspace_ = CreateWorkspace(false);
+  active_workspace_ = new Workspace(this, contents_window_);
   workspaces_.push_back(active_workspace_);
   active_workspace_->window()->Show();
   Shell::GetInstance()->AddShellObserver(this);
 
   if (ash::WorkspaceCyclerConfiguration::IsCyclerEnabled())
     workspace_cycler_.reset(new WorkspaceCycler(this));
 }
 
 WorkspaceManager::~WorkspaceManager() {
   Shell::GetInstance()->RemoveShellObserver(this);
   // Release the windows, they'll be destroyed when |contents_window_| is
   // destroyed.
   std::for_each(workspaces_.begin(), workspaces_.end(),
                 std::mem_fun(&Workspace::ReleaseWindow));
   std::for_each(pending_workspaces_.begin(), pending_workspaces_.end(),
                 std::mem_fun(&Workspace::ReleaseWindow));
   std::for_each(to_delete_.begin(), to_delete_.end(),
                 std::mem_fun(&Workspace::ReleaseWindow));
   STLDeleteElements(&workspaces_);
   STLDeleteElements(&pending_workspaces_);
   STLDeleteElements(&to_delete_);
 }
 
-// static
-bool WorkspaceManager::WillRestoreToWorkspace(Window* window) {
-  return wm::IsWindowMinimized(window) &&
-      window->GetProperty(aura::client::kRestoreShowStateKey) ==
-      ui::SHOW_STATE_FULLSCREEN;
-}
-
 WorkspaceWindowState WorkspaceManager::GetWindowState() const {
   if (!shelf_)
     return WORKSPACE_WINDOW_STATE_DEFAULT;
 
-  const bool is_active_fullscreen = active_workspace_->is_fullscreen();
   const gfx::Rect shelf_bounds(shelf_->GetIdealBounds());
   const Window::Windows& windows(active_workspace_->window()->children());
   bool window_overlaps_launcher = false;
   bool has_maximized_window = false;
   for (Window::Windows::const_iterator i = windows.begin();
        i != windows.end(); ++i) {
     if (GetIgnoredByShelf(*i))
       continue;
     ui::Layer* layer = (*i)->layer();
     if (!layer->GetTargetVisibility() || layer->GetTargetOpacity() == 0.0f)
       continue;
     if (wm::IsWindowMaximized(*i)) {
       // An untracked window may still be fullscreen so we keep iterating when
       // we hit a maximized window.
       has_maximized_window = true;
-    } else if (is_active_fullscreen && wm::IsWindowFullscreen(*i)) {
-      // Ignore fullscreen windows if we're in the desktop. Such a state
-      // is transitory and means we haven't yet switched. If we did consider
-      // such windows we'll return the wrong thing, which can lead to
-      // prematurely anging the launcher state and clobbering restore bounds.
+    } else if (wm::IsWindowFullscreen(*i)) {
       return WORKSPACE_WINDOW_STATE_FULL_SCREEN;
     }
     if (!window_overlaps_launcher && (*i)->bounds().Intersects(shelf_bounds))
       window_overlaps_launcher = true;
   }
   if (has_maximized_window)
     return WORKSPACE_WINDOW_STATE_MAXIMIZED;
 
   return window_overlaps_launcher ?
       WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF :
@@ skipping 21 matching lines @@
     //   have to allow dragging of a fullscreen window to work in this case.
     // . The window persists across all workspaces. For example, the task
     //   manager is in the desktop worskpace and the current workspace is
     //   fullscreen. If we swapped to the desktop you would lose context.
     //   Instead we reparent.  The exception to this is if the window is
     //   fullscreen (it needs its own workspace then) or we're in the process of
     //   fullscreen. If we're in the process of fullscreen the window needs its
     //   own workspace.
     if (!GetTrackedByWorkspace(window) ||
         (GetPersistsAcrossAllWorkspaces(window) &&
-         !wm::IsWindowFullscreen(window) && !WillRestoreToWorkspace(window))) {
+         !wm::IsWindowFullscreen(window))) {
       ReparentWindow(window, active_workspace_->window(), NULL);
     } else {
       SetActiveWorkspace(workspace, SWITCH_WINDOW_MADE_ACTIVE);
     }
   }
-
-  if (workspace->is_fullscreen() && wm::IsWindowFullscreen(window)) {
-    // Clicking on the fullscreen window in a fullscreen workspace. Force all
-    // other windows to drop to the desktop.
-    MoveChildrenToDesktop(workspace->window(), NULL);
-  }
 }
 
 Window* WorkspaceManager::GetActiveWorkspaceWindow() {
   return active_workspace_->window();
 }
 
 Window* WorkspaceManager::GetParentForNewWindow(Window* window) {
   // Try to put windows with transient parents in the same workspace as their
   // transient parent.
-  if (window->transient_parent() && !wm::IsWindowFullscreen(window)) {
+  if (window->transient_parent()) {
     Workspace* workspace = FindBy(window->transient_parent());
     if (workspace)
       return workspace->window();
     // Fall through to normal logic.
   }
 
   if (!GetTrackedByWorkspace(window))
     return active_workspace_->window();
 
-  if (wm::IsWindowFullscreen(window)) {
-    // Wait for the window to be made active before showing the workspace.
-    Workspace* workspace = CreateWorkspace(true);
-    pending_workspaces_.insert(workspace);
-    return workspace->window();
-  }
-
-  if (!GetTrackedByWorkspace(window) || GetPersistsAcrossAllWorkspaces(window))
-    return active_workspace_->window();
-
   return desktop_workspace()->window();
 }
 
 bool WorkspaceManager::CanStartCyclingThroughWorkspaces() const {
   return workspace_cycler_.get() && workspaces_.size() > 1u;
 }
 
 void WorkspaceManager::InitWorkspaceCyclerAnimatorWithCurrentState(
     WorkspaceCyclerAnimator* animator) {
   if (animator)
@@ skipping 60 matching lines @@
   }
 
   Workspace* last_active = active_workspace_;
   active_workspace_ = workspace;
 
   // The display work-area may have changed while |workspace| was not the active
   // workspace. Give it a chance to adjust its state for the new work-area.
   active_workspace_->workspace_layout_manager()->
       OnDisplayWorkAreaInsetsChanged();
 
-  const bool is_unminimizing_fullscreen_window =
-      unminimizing_workspace_ && unminimizing_workspace_ == active_workspace_ &&
-      active_workspace_->is_fullscreen();
-  if (is_unminimizing_fullscreen_window) {
-    // If we're unminimizing a window it needs to be on the top, otherwise you
-    // won't see the animation.
-    contents_window_->StackChildAtTop(active_workspace_->window());
-  } else if (active_workspace_->is_fullscreen() &&
-             last_active->is_fullscreen() &&
-             reason != SWITCH_FULLSCREEN_FROM_FULLSCREEN_WORKSPACE) {
-    // When switching between fullscreen windows we need the last active
-    // workspace on top of the new, otherwise the animations won't look
-    // right. Since only one workspace is visible at a time stacking order of
-    // the workspace windows ultimately doesn't matter.
-    contents_window_->StackChildAtTop(last_active->window());
-  }
+  contents_window_->StackChildAtTop(last_active->window());
 
-  HideWorkspace(last_active, reason, is_unminimizing_fullscreen_window);
+  HideWorkspace(last_active, reason);
   ShowWorkspace(workspace, last_active, reason);
 
   UpdateShelfVisibility();
 
   // Showing or hiding a workspace may change the "solo window" status of
   // a window, requiring the header to be updated.
   FramePainter::UpdateSoloWindowHeader(contents_window_->GetRootWindow());
 }
 
 WorkspaceManager::Workspaces::iterator
 WorkspaceManager::FindWorkspace(Workspace* workspace)  {
   return std::find(workspaces_.begin(), workspaces_.end(), workspace);
 }
 
-Workspace* WorkspaceManager::CreateWorkspace(bool fullscreen) {
-  return new Workspace(this, contents_window_, fullscreen);
+Workspace* WorkspaceManager::CreateWorkspaceForTest() {
+  return new Workspace(this, contents_window_);
 }
 
 void WorkspaceManager::MoveWorkspaceToPendingOrDelete(
     Workspace* workspace,
     Window* stack_beneath,
     SwitchReason reason) {
   // We're all ready moving windows.
   if (in_move_)
     return;
 
@@ skipping 11 matching lines @@
 
   MoveChildrenToDesktop(workspace->window(), stack_beneath);
 
   {
     Workspaces::iterator workspace_i(FindWorkspace(workspace));
     if (workspace_i != workspaces_.end())
       workspaces_.erase(workspace_i);
   }
 
   if (workspace->window()->children().empty()) {
-    if (workspace == unminimizing_workspace_)
-      unminimizing_workspace_ = NULL;
     pending_workspaces_.erase(workspace);
     ScheduleDelete(workspace);
   } else {
     pending_workspaces_.insert(workspace);
   }
 }
 
 void WorkspaceManager::MoveChildrenToDesktop(aura::Window* window,
                                              aura::Window* stack_beneath) {
   // Build the list of windows to move. Exclude fullscreen and windows with
   // transient parents.
   Window::Windows to_move;
   for (size_t i = 0; i < window->children().size(); ++i) {
     Window* child = window->children()[i];
-    if (!child->transient_parent() && !wm::IsWindowFullscreen(child) &&
-        !WillRestoreToWorkspace(child)) {
+    if (!child->transient_parent() && !wm::IsWindowFullscreen(child)) {
       to_move.push_back(child);
     }
   }
   // Move the windows, but make sure the window is still a child of |window|
   // (moving may cascade and cause other windows to move).
   for (size_t i = 0; i < to_move.size(); ++i) {
     if (std::find(window->children().begin(), window->children().end(),
                   to_move[i]) != window->children().end()) {
       ReparentWindow(to_move[i], desktop_workspace()->window(),
                      stack_beneath);
@@ skipping 12 matching lines @@
     SetActiveWorkspace(*(workspace_i - 1), reason);
 }
 
 void WorkspaceManager::ScheduleDelete(Workspace* workspace) {
   to_delete_.insert(workspace);
   delete_timer_.Stop();
   delete_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
                       &WorkspaceManager::ProcessDeletion);
 }
 
-void WorkspaceManager::SetUnminimizingWorkspace(Workspace* workspace) {
-  // The normal sequence of unminimizing a window is: Show() the window, which
-  // triggers changing the kShowStateKey to NORMAL and lastly the window is made
-  // active. This means at the time the window is unminimized we don't know if
-  // the workspace it is in is going to become active. To track this
-  // |unminimizing_workspace_| is set at the time we unminimize and a task is
-  // schedule to reset it. This way when we get the activate we know we're in
-  // the process unminimizing and can do the right animation.
-  unminimizing_workspace_ = workspace;
-  if (unminimizing_workspace_) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&WorkspaceManager::SetUnminimizingWorkspace,
-                   clear_unminimizing_workspace_factory_.GetWeakPtr(),
-                   static_cast<Workspace*>(NULL)));
-  }
-}
-
 void WorkspaceManager::FadeDesktop(aura::Window* window,
                                    base::TimeDelta duration) {
   if (views::corewm::WindowAnimationsDisabled(NULL) ||
       ui::ScopedAnimationDurationScaleMode::duration_scale_mode() ==
       ui::ScopedAnimationDurationScaleMode::ZERO_DURATION)
     return;
 
   base::AutoReset<bool> reseter(&creating_fade_, true);
   DesktopBackgroundFadeController::Direction direction;
   aura::Window* parent = NULL;
@@ skipping 20 matching lines @@
     Workspace* last_active,
     SwitchReason reason) const {
   WorkspaceAnimationDetails details;
   details.direction =
       (last_active == desktop_workspace() || reason == SWITCH_INITIAL) ?
       WORKSPACE_ANIMATE_DOWN : WORKSPACE_ANIMATE_UP;
 
   switch (reason) {
     case SWITCH_WINDOW_MADE_ACTIVE:
     case SWITCH_TRACKED_BY_WORKSPACE_CHANGED:
-    case SWITCH_WINDOW_REMOVED:
-    case SWITCH_VISIBILITY_CHANGED:
-    case SWITCH_MINIMIZED:
       details.animate = details.animate_scale = true;
       details.animate_opacity = last_active == desktop_workspace();
       break;
 
     case SWITCH_INITIAL:
       details.animate = details.animate_opacity = details.animate_scale = true;
       details.pause_time_ms = kInitialPauseTimeMS;
       break;
 
     // Remaining cases require no animation.
     default:
       break;
   }
   ash::internal::ShowWorkspace(workspace->window(), details);
 }
 
 void WorkspaceManager::HideWorkspace(
     Workspace* workspace,
-    SwitchReason reason,
-    bool is_unminimizing_fullscreen_window) const {
+    SwitchReason reason) const {
   WorkspaceAnimationDetails details;
   details.direction = active_workspace_ == desktop_workspace() ?
       WORKSPACE_ANIMATE_UP : WORKSPACE_ANIMATE_DOWN;
   switch (reason) {
     case SWITCH_WINDOW_MADE_ACTIVE:
     case SWITCH_TRACKED_BY_WORKSPACE_CHANGED:
       details.animate_opacity =
           ((active_workspace_ == desktop_workspace() ||
-            workspace != desktop_workspace()) &&
-           !is_unminimizing_fullscreen_window);
+            workspace != desktop_workspace()));
       details.animate_scale = true;
       details.animate = true;
       break;
 
-    case SWITCH_VISIBILITY_CHANGED:
-      // The window is most likely closing. Make the workspace visible for the
-      // duration of the switch so that the close animation is visible.
-      details.animate = true;
-      details.animate_scale = true;
-      break;
-
-    case SWITCH_FULLSCREEN_FROM_FULLSCREEN_WORKSPACE:
-    case SWITCH_MAXIMIZED_OR_RESTORED:
-      if (active_workspace_->is_fullscreen()) {
-        // Delay the hide until the animation is done.
-        details.duration =
-            base::TimeDelta::FromMilliseconds(kCrossFadeSwitchTimeMS);
-        details.animate = true;
-      }
-      break;
-
     // Remaining cases require no animation.
     default:
       break;
   }
   ash::internal::HideWorkspace(workspace->window(), details);
 }
 
 void WorkspaceManager::ProcessDeletion() {
   std::set<Workspace*> to_delete;
   to_delete.swap(to_delete_);
@@ skipping 29 matching lines @@
 
 void WorkspaceManager::OnWillRemoveWindowFromWorkspace(Workspace* workspace,
                                                        Window* child) {
   if (child->TargetVisibility())
     RearrangeVisibleWindowOnHideOrRemove(child);
   child->ClearProperty(kWorkspaceKey);
 }
 
 void WorkspaceManager::OnWindowRemovedFromWorkspace(Workspace* workspace,
                                                     Window* child) {
-  if (workspace->ShouldMoveToPending())
-    MoveWorkspaceToPendingOrDelete(workspace, NULL, SWITCH_WINDOW_REMOVED);
   UpdateShelfVisibility();
 }
 
 void WorkspaceManager::OnWorkspaceChildWindowVisibilityChanged(
     Workspace* workspace,
     Window* child) {
-  if (workspace->ShouldMoveToPending()) {
-    MoveWorkspaceToPendingOrDelete(workspace, NULL, SWITCH_VISIBILITY_CHANGED);
-  } else {
-    if (child->TargetVisibility())
-      RearrangeVisibleWindowOnShow(child);
-    else
-      RearrangeVisibleWindowOnHideOrRemove(child);
-    if (workspace == active_workspace_) {
-      UpdateShelfVisibility();
-      FramePainter::UpdateSoloWindowHeader(child->GetRootWindow());
-    }
+  if (child->TargetVisibility())
+    RearrangeVisibleWindowOnShow(child);
+  else
+    RearrangeVisibleWindowOnHideOrRemove(child);
+  if (workspace == active_workspace_) {
+    UpdateShelfVisibility();
+    FramePainter::UpdateSoloWindowHeader(child->GetRootWindow());
   }
 }
 
 void WorkspaceManager::OnWorkspaceWindowChildBoundsChanged(
     Workspace* workspace,
     Window* child) {
   if (workspace == active_workspace_)
     UpdateShelfVisibility();
 }
 
 void WorkspaceManager::OnWorkspaceWindowShowStateChanged(
     Workspace* workspace,
     Window* child,
-    ui::WindowShowState last_show_state,
-    ui::Layer* old_layer) {
+    ui::WindowShowState last_show_state) {
   // |child| better still be in |workspace| else things have gone wrong.
   DCHECK_EQ(workspace, child->GetProperty(kWorkspaceKey));
 
-  if (wm::IsWindowMinimized(child)) {
-    if (workspace->ShouldMoveToPending())
-      MoveWorkspaceToPendingOrDelete(workspace, NULL, SWITCH_MINIMIZED);
-    DCHECK(!old_layer);
-  } else {
-    // Set of cases to deal with:
-    // . More than one fullscreen window: move newly fullscreen window into
-    //   own workspace.
-    // . One fullscreen window and not in a fullscreen workspace: move window
-    //   into own workspace.
-    // . No fullscreen window and not in desktop: move to desktop and further
-    //   any existing windows are stacked beneath |child|.
-    const bool is_active = wm::IsActiveWindow(child);
-    Workspace* new_workspace = NULL;
-    const int full_count = workspace->GetNumFullscreenWindows();
-    base::TimeDelta duration = (old_layer && !wm::IsWindowFullscreen(child)) ?
-            GetCrossFadeDuration(old_layer->bounds(), child->bounds()) :
-            base::TimeDelta::FromMilliseconds(kCrossFadeSwitchTimeMS);
-    if (full_count == 0) {
-      if (workspace != desktop_workspace()) {
-        {
-          base::AutoReset<bool> setter(&in_move_, true);
-          ReparentWindow(child, desktop_workspace()->window(), NULL);
-        }
-        DCHECK(!is_active || old_layer);
-        new_workspace = desktop_workspace();
-        SetActiveWorkspace(new_workspace, SWITCH_MAXIMIZED_OR_RESTORED);
-        MoveWorkspaceToPendingOrDelete(workspace, child,
-                                       SWITCH_MAXIMIZED_OR_RESTORED);
-        if (FindWorkspace(workspace) == workspaces_.end())
-          workspace = NULL;
-      }
-    } else if ((full_count == 1 && workspace == desktop_workspace()) ||
-               full_count > 1) {
-      new_workspace = CreateWorkspace(true);
-      pending_workspaces_.insert(new_workspace);
-      ReparentWindow(child, new_workspace->window(), NULL);
+  if (!wm::IsWindowMinimized(child) && workspace != desktop_workspace()) {
+    {
+      base::AutoReset<bool> setter(&in_move_, true);
+      ReparentWindow(child, desktop_workspace()->window(), NULL);
     }
-    if (is_active && new_workspace) {
-      // |old_layer| may be NULL if as part of processing
-      // WorkspaceLayoutManager::OnWindowPropertyChanged() the window is made
-      // active.
-      if (old_layer) {
-        SetActiveWorkspace(new_workspace,
-                           full_count >= 2 ?
-                               SWITCH_FULLSCREEN_FROM_FULLSCREEN_WORKSPACE :
-                               SWITCH_MAXIMIZED_OR_RESTORED);
-        CrossFadeWindowBetweenWorkspaces(new_workspace->window(), child,
-                                         old_layer);
-        if (workspace == desktop_workspace() ||
-            new_workspace == desktop_workspace()) {
-          FadeDesktop(child, duration);
-        }
-      } else {
-        SetActiveWorkspace(new_workspace, SWITCH_OTHER);
-      }
-    } else {
-      if (last_show_state == ui::SHOW_STATE_MINIMIZED)
-        SetUnminimizingWorkspace(new_workspace ? new_workspace : workspace);
-      DCHECK(!old_layer);
-    }
+    SetActiveWorkspace(desktop_workspace(), SWITCH_MAXIMIZED_OR_RESTORED);
+    MoveWorkspaceToPendingOrDelete(workspace,
+                                   child,
+                                   SWITCH_MAXIMIZED_OR_RESTORED);
   }
   UpdateShelfVisibility();
 }
 
 void WorkspaceManager::OnTrackedByWorkspaceChanged(Workspace* workspace,
                                                    aura::Window* window) {
-  Workspace* new_workspace = NULL;
-  if (wm::IsWindowFullscreen(window)) {
-    if (workspace->is_fullscreen() &&
-        workspace->GetNumFullscreenWindows() == 1) {
-      // If |window| is the only window in a fullscreen workspace then leave
-      // it there. Additionally animate it back to the origin.
-      ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-      // All bounds changes get routed through WorkspaceLayoutManager and since
-      // the window is fullscreen WorkspaceLayoutManager is going to force a
-      // value. In other words, it doesn't matter what we supply to SetBounds()
-      // here.
-      window->SetBounds(gfx::Rect());
-      return;
-    }
-    new_workspace = CreateWorkspace(true);
-    pending_workspaces_.insert(new_workspace);
-  } else if (workspace->is_fullscreen()) {
-    new_workspace = desktop_workspace();
-  } else {
+  if (workspace == active_workspace_)
     return;
-  }
+
   // If the window is active we need to make sure the destination Workspace
   // window is showing. Otherwise the window will be parented to a hidden window
   // and lose activation.
   const bool is_active = wm::IsActiveWindow(window);
   if (is_active)
-    new_workspace->window()->Show();
-  ReparentWindow(window, new_workspace->window(), NULL);
-  if (is_active) {
-    SetActiveWorkspace(new_workspace, SWITCH_TRACKED_BY_WORKSPACE_CHANGED);
-  }
+    workspace->window()->Show();
+  ReparentWindow(window, workspace->window(), NULL);
+  if (is_active)
+    SetActiveWorkspace(workspace, SWITCH_TRACKED_BY_WORKSPACE_CHANGED);
 }
 
 }  // namespace internal
 }  // namespace ash