Makes the launcher auto-hide for maximized windows. This turned out to

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 "ash/screen_ash.h"
 #include "ash/shell.h"
@@ skipping 52 matching lines @@
 
 namespace ash {
 namespace internal {
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManager, public:
 
 WorkspaceManager::WorkspaceManager(aura::Window* contents_view)
     : contents_view_(contents_view),
       active_workspace_(NULL),
-      workspace_size_(
-          gfx::Screen::GetMonitorAreaNearestWindow(contents_view_).size()),
       is_overview_(false),
       ignored_window_(NULL),
       grid_size_(0),
       shelf_(NULL) {
   DCHECK(contents_view);
 }
 
 WorkspaceManager::~WorkspaceManager() {
   std::vector<Workspace*> copy_to_delete(workspaces_);
   STLDeleteElements(&copy_to_delete);
@@ skipping 13 matching lines @@
 
   Workspace* current_workspace = FindBy(window);
   if (current_workspace) {
     // Already know about this window. Make sure the workspace is active.
     if (active_workspace_ != current_workspace) {
       if (active_workspace_)
         window->layer()->GetAnimator()->StopAnimating();
       current_workspace->Activate();
     }
     window->Show();
+    UpdateShelfVisibility();
     return;
   }
 
   if (wm::IsWindowNormal(window) && grid_size_ > 1)
     SetWindowBounds(window, AlignBoundsToGrid(window->GetTargetBounds()));
 
   Workspace* workspace = NULL;
   Workspace::Type type_for_window = Workspace::TypeForWindow(window);
   switch (type_for_window) {
     case Workspace::TYPE_MANAGED:
       // All normal windows go in the same workspace.
       workspace = GetManagedWorkspace();
       break;
 
     case Workspace::TYPE_MAXIMIZED:
       // All maximized windows go in their own workspace.
       break;
   }
 
   if (!workspace)
     workspace = CreateWorkspace(type_for_window);
   workspace->AddWindowAfter(window, NULL);
   workspace->Activate();
+  UpdateShelfVisibility();
 }
 
 void WorkspaceManager::RemoveWindow(aura::Window* window) {
   Workspace* workspace = FindBy(window);
   if (!workspace)
     return;
   workspace->RemoveWindow(window);
   CleanupWorkspace(workspace);
+  UpdateShelfVisibility();
 }
 
 void WorkspaceManager::SetActiveWorkspaceByWindow(aura::Window* window) {
   Workspace* workspace = FindBy(window);
   if (workspace)
     workspace->Activate();
 }
 
-gfx::Rect WorkspaceManager::GetDragAreaBounds() {
-  return GetWorkAreaBounds();
-}
-
 void WorkspaceManager::SetOverview(bool overview) {
   if (is_overview_ == overview)
     return;
   NOTIMPLEMENTED();
 }
 
-void WorkspaceManager::SetWorkspaceSize(const gfx::Size& workspace_size) {
-  if (workspace_size == workspace_size_)
-    return;
-  workspace_size_ = workspace_size;
-  SetWorkspaceBounds();
-}
-
-void WorkspaceManager::OnMonitorWorkAreaInsetsChanged() {
-  SetWorkspaceBounds();
-}
-
 gfx::Rect WorkspaceManager::AlignBoundsToGrid(const gfx::Rect& bounds) {
   if (grid_size_ <= 1)
     return bounds;
   return AlignRectToGrid(bounds, grid_size_);
 }
 
+void WorkspaceManager::UpdateShelfVisibility() {
+  if (!shelf_ || !active_workspace_) {
+    shelf_->SetState(ShelfLayoutManager::VISIBLE,
+                     ShelfLayoutManager::AUTO_HIDE_SHOWN);
+    shelf_->SetWindowOverlapsShelf(false);
+    return;
+  }
+
+  // TODO: this code needs to be made multi-monitor aware.
+  gfx::Rect bounds(gfx::Screen::GetMonitorAreaNearestWindow(contents_view_));
+  bounds.set_height(bounds.height() - shelf_->shelf_height());
+  const aura::Window::Windows& windows(contents_view_->children());
+  bool has_full_screen_window = false;
+  bool has_max_window = false;
+  bool window_overlaps_launcher = false;
+  for (aura::Window::Windows::const_iterator i = windows.begin();
+       i != windows.end(); ++i) {
+    if (!IsManagingWindow(*i))
+      continue;
+    ui::Layer* layer = (*i)->layer();
+    if (!layer->GetTargetVisibility() || layer->GetTargetOpacity() == 0.0f)
+      continue;
+    if (wm::IsWindowMaximized(*i)) {
+      has_max_window = true;
+      break;
+    }
+    if (wm::IsWindowFullscreen(*i)) {
+      has_full_screen_window = true;
+      break;
+    }
+    if (!window_overlaps_launcher && (*i)->bounds().bottom() > bounds.bottom())
+      window_overlaps_launcher = true;
+  }
+
+  ShelfLayoutManager::VisibilityState visibility_state =
+      ShelfLayoutManager::VISIBLE;
+  ShelfLayoutManager::AutoHideState auto_hide_state =
+      shelf_->auto_hide_state();
+  if (has_full_screen_window) {
+    visibility_state = ShelfLayoutManager::HIDDEN;
+  } else if (has_max_window) {
+    visibility_state = ShelfLayoutManager::AUTO_HIDE;
+  }
+  shelf_->SetState(visibility_state, auto_hide_state);
+  shelf_->SetWindowOverlapsShelf(window_overlaps_launcher);
+}
+
 void WorkspaceManager::ShowStateChanged(aura::Window* window) {
   if (!IsManagedWindow(window) || !FindBy(window))
     return;
 
   Workspace::Type old_type = FindBy(window)->type();
   Workspace::Type new_type = Workspace::TypeForWindow(window);
   if (new_type != old_type)
     OnTypeOfWorkspacedNeededChanged(window);
   UpdateShelfVisibility();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WorkspaceManager, private:
 
 void WorkspaceManager::AddWorkspace(Workspace* workspace) {
   DCHECK(std::find(workspaces_.begin(), workspaces_.end(),
                    workspace) == workspaces_.end());
-  workspace->SetBounds(GetWorkAreaBounds());
   if (active_workspace_) {
     // New workspaces go right after current workspace.
     Workspaces::iterator i = std::find(workspaces_.begin(), workspaces_.end(),
                                        active_workspace_);
     workspaces_.insert(++i, workspace);
   } else {
     workspaces_.push_back(workspace);
   }
 }
 
 void WorkspaceManager::RemoveWorkspace(Workspace* workspace) {
   Workspaces::iterator i = std::find(workspaces_.begin(),
                                      workspaces_.end(),
                                      workspace);
   DCHECK(i != workspaces_.end());
   i = workspaces_.erase(i);
   if (active_workspace_ == workspace) {
     // TODO: need mru order.
     if (i != workspaces_.end())
       SetActiveWorkspace(*i);
     else if (!workspaces_.empty())
       SetActiveWorkspace(workspaces_.back());
     else
       active_workspace_ = NULL;
   }
 }
 
-void WorkspaceManager::UpdateShelfVisibility() {
-  if (!shelf_ || !active_workspace_)
-    return;
-  std::set<aura::Window*> windows;
-  windows.insert(active_workspace_->windows().begin(),
-                 active_workspace_->windows().end());
-  shelf_->SetVisible(!wm::HasFullscreenWindow(windows));
-}
-
 void WorkspaceManager::SetVisibilityOfWorkspaceWindows(
     ash::internal::Workspace* workspace,
     AnimateChangeType change_type,
     bool value) {
   std::vector<aura::Window*> children;
   BuildWindowList(workspace->windows(), &children);
   SetWindowLayerVisibility(children, change_type, value);
 }
 
 void WorkspaceManager::SetWindowLayerVisibility(
@@ skipping 46 matching lines @@
   active_workspace_ = workspace;
   if (active_workspace_) {
     SetVisibilityOfWorkspaceWindows(active_workspace_,
                                     last_active ? ANIMATE : DONT_ANIMATE, true);
     UpdateShelfVisibility();
   }
 
   is_overview_ = false;
 }
 
-gfx::Rect WorkspaceManager::GetWorkAreaBounds() const {
-  gfx::Rect bounds(workspace_size_);
-  const aura::MonitorManager* monitor_manager =
-      aura::Env::GetInstance()->monitor_manager();
-  const aura::Monitor* monitor =
-      monitor_manager->GetMonitorNearestWindow(contents_view_);
-  bounds.Inset(monitor->work_area_insets());
-  return bounds;
-}
-
 // Returns the index of the workspace that contains the |window|.
 int WorkspaceManager::GetWorkspaceIndexContaining(aura::Window* window) const {
   for (Workspaces::const_iterator i = workspaces_.begin();
        i != workspaces_.end();
        ++i) {
     if ((*i)->Contains(window))
       return i - workspaces_.begin();
   }
   return -1;
 }
 
 void WorkspaceManager::SetWindowBounds(aura::Window* window,
                                        const gfx::Rect& bounds) {
   ignored_window_ = window;
   window->SetBounds(bounds);
   ignored_window_ = NULL;
 }
 
-void WorkspaceManager::SetWorkspaceBounds() {
-  for (Workspaces::const_iterator i = workspaces_.begin();
-       i != workspaces_.end(); ++i) {
-    (*i)->SetBounds(GetWorkAreaBounds());
-  }
-}
-
 void WorkspaceManager::OnTypeOfWorkspacedNeededChanged(aura::Window* window) {
   DCHECK(IsManagedWindow(window));
   Workspace* current_workspace = FindBy(window);
   DCHECK(current_workspace);
   Workspace* new_workspace = NULL;
   if (Workspace::TypeForWindow(window) == Workspace::TYPE_MAXIMIZED) {
     // Unmaximized -> maximized; create a new workspace.
     current_workspace->RemoveWindow(window);
     new_workspace = CreateWorkspace(Workspace::TYPE_MAXIMIZED);
     new_workspace->AddWindowAfter(window, NULL);
@@ skipping 30 matching lines @@
   return workspace;
 }
 
 void WorkspaceManager::CleanupWorkspace(Workspace* workspace) {
   if (workspace->type() != Workspace::TYPE_MANAGED && workspace->is_empty())
     delete workspace;
 }
 
 }  // namespace internal
 }  // namespace ash