Align expanded panel to the bottom of screen edge when there is an auto-hiding taskbar

chrome/browser/ui/panels/panel_manager.cc

 // Copyright (c) 2011 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 "chrome/browser/ui/panels/panel_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 310 matching lines @@
 }
 
 void PanelManager::OnPanelExpansionStateChanged(
     Panel::ExpansionState old_state, Panel::ExpansionState new_state) {
   DCHECK_NE(new_state, old_state);
   switch (new_state) {
     case Panel::EXPANDED:
       DecrementMinimizedPanels();
       break;
     case Panel::MINIMIZED:
+    case Panel::TITLE_ONLY:
       if (old_state == Panel::EXPANDED)
         IncrementMinimizedPanels();
       break;
     default:
       break;
   }
 }
 
 void PanelManager::IncrementMinimizedPanels() {
   if (!mouse_watching_disabled_ && !minimized_panel_count_)
@@ skipping 176 matching lines @@
       if (panel->expansion_state() == Panel::TITLE_ONLY)
         panel->SetExpansionState(Panel::MINIMIZED);
     }
   }
 }
 
 void PanelManager::AdjustWorkAreaForAutoHidingDesktopBars() {
   // Note that we do not care about the desktop bar aligned to the top edge
   // since panels could not reach so high due to size constraint.
   adjusted_work_area_ = work_area_;
-  if (auto_hiding_desktop_bar_->IsEnabled(AutoHidingDesktopBar::ALIGN_BOTTOM)) {
-    int space = auto_hiding_desktop_bar_->GetThickness(
-        AutoHidingDesktopBar::ALIGN_BOTTOM);
-    adjusted_work_area_.set_height(adjusted_work_area_.height() - space);
-  }
   if (auto_hiding_desktop_bar_->IsEnabled(AutoHidingDesktopBar::ALIGN_LEFT)) {
     int space = auto_hiding_desktop_bar_->GetThickness(
         AutoHidingDesktopBar::ALIGN_LEFT);
     adjusted_work_area_.set_x(adjusted_work_area_.x() + space);
     adjusted_work_area_.set_width(adjusted_work_area_.width() - space);
   }
   if (auto_hiding_desktop_bar_->IsEnabled(AutoHidingDesktopBar::ALIGN_RIGHT)) {
     int space = auto_hiding_desktop_bar_->GetThickness(
         AutoHidingDesktopBar::ALIGN_RIGHT);
     adjusted_work_area_.set_width(adjusted_work_area_.width() - space);
   }
 }
 
 int PanelManager::GetBottomPositionForExpansionState(
     Panel::ExpansionState expansion_state) const {
   int bottom = adjusted_work_area_.bottom();
   // If there is an auto-hiding desktop bar aligned to the bottom edge, we need
-  // to move the minimize panel down to the bottom edge.
-  if (expansion_state == Panel::MINIMIZED &&
+  // to move the title-only panel above the auto-hiding desktop bar.
+  if (expansion_state == Panel::TITLE_ONLY &&
       auto_hiding_desktop_bar_->IsEnabled(AutoHidingDesktopBar::ALIGN_BOTTOM)) {
-    bottom += auto_hiding_desktop_bar_->GetThickness(
+    bottom -= auto_hiding_desktop_bar_->GetThickness(
         AutoHidingDesktopBar::ALIGN_BOTTOM);
   }
 
   return bottom;
 }
 
 BrowserWindow* PanelManager::GetNextBrowserWindowToActivate(
     Panel* panel) const {
   // Find the last active browser window that is not minimized.
   BrowserList::const_reverse_iterator iter = BrowserList::begin_last_active();
@@ skipping 33 matching lines @@
   DoBringUpOrDownTitlebars(delayed_titlebar_action_ == BRING_UP);
   delayed_titlebar_action_ = NO_ACTION;
 }
 
 void PanelManager::Rearrange(Panels::iterator iter_to_start,
                              int rightmost_position) {
   for (Panels::iterator iter = iter_to_start; iter != panels_.end(); ++iter) {
     Panel* panel = *iter;
     gfx::Rect new_bounds(panel->GetBounds());
     new_bounds.set_x(rightmost_position - new_bounds.width());
-    new_bounds.set_y(adjusted_work_area_.bottom() - new_bounds.height());
+    new_bounds.set_y(
+        GetBottomPositionForExpansionState(panel->expansion_state()) -
+            new_bounds.height());
     if (new_bounds != panel->GetBounds())
       panel->SetPanelBounds(new_bounds);
 
     rightmost_position = new_bounds.x() - kPanelsHorizontalSpacing;
   }
 }
 
 void PanelManager::RemoveAll() {
   // This should not be called when we're in the process of dragging.
   DCHECK(dragging_panel_index_ == kInvalidPanelIndex);
 
   // Make a copy of the iterator as closing panels can modify the vector.
   Panels panels_copy = panels_;
 
   // Start from the bottom to avoid reshuffling.
   for (Panels::reverse_iterator iter = panels_copy.rbegin();
        iter != panels_copy.rend(); ++iter)
     (*iter)->Close();
 }
 
 bool PanelManager::is_dragging_panel() const {
   return dragging_panel_index_ != kInvalidPanelIndex;
 }