Add Panel::SetPanelBoundsInstantly for all platforms.

chrome/browser/ui/panels/panel_strip.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_strip.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 106 matching lines @@
   int x = GetRightMostAvailablePosition() - width;
   panel->Initialize(gfx::Rect(x, y, width, height));
 }
 
 void PanelStrip::AddExistingPanel(Panel* panel) {
   gfx::Size restored_size = panel->restored_size();
   int height = restored_size.height();
   int width = restored_size.width();
   int x = GetRightMostAvailablePosition() - width;
   int y = strip_bounds_.bottom() - height;
-  panel->SetPanelBounds(gfx::Rect(x, y, width, height));
+  panel->SetPanelBounds(gfx::Rect(x, y, width, height),
+                        true);  // use animation.
 }
 
 int PanelStrip::GetMaxPanelWidth() const {
   return static_cast<int>(strip_bounds_.width() * kPanelMaxWidthFactor);
 }
 
 int PanelStrip::GetMaxPanelHeight() const {
   return strip_bounds_.height();
 }
 
@@ skipping 53 matching lines @@
 void PanelStrip::Drag(int delta_x) {
   DCHECK(dragging_panel_index_ != kInvalidPanelIndex);
 
   if (!delta_x)
     return;
 
   // Moves this panel to the dragging position.
   Panel* dragging_panel = panels_[dragging_panel_index_];
   gfx::Rect new_bounds(dragging_panel->GetBounds());
   new_bounds.set_x(new_bounds.x() + delta_x);
-  dragging_panel->SetPanelBounds(new_bounds);
+  dragging_panel->SetPanelBounds(new_bounds, true);  // use animation.
 
   // Checks and processes other affected panels.
   if (delta_x > 0)
     DragRight();
   else
     DragLeft();
 }
 
 void PanelStrip::DragLeft() {
   Panel* dragging_panel = panels_[dragging_panel_index_];
@@ skipping 14 matching lines @@
     // Current panel will only be affected if the left corner of dragging
     // panel goes beyond the middle position of the current panel.
     if (dragging_panel_left_boundary > current_panel->GetBounds().x() +
             current_panel->GetBounds().width() / 2)
       break;
 
     // Moves current panel to the new position.
     gfx::Rect bounds(current_panel->GetBounds());
     bounds.set_x(current_panel_right_boundary - bounds.width());
     current_panel_right_boundary -= bounds.width() + kPanelsHorizontalSpacing;
-    current_panel->SetPanelBounds(bounds);
+    current_panel->SetPanelBounds(bounds, true);  // use animation.
 
     // Updates the index of current panel since it has been moved to the
     // position of previous panel.
     panels_[current_panel_index - 1] = current_panel;
   }
 
   // Updates the position and index of dragging panel as the result of moving
   // other affected panels.
   if (current_panel_index != dragging_panel_index_ + 1) {
     dragging_panel_bounds_.set_x(current_panel_right_boundary -
@@ skipping 22 matching lines @@
     // Current panel will only be affected if the right corner of dragging
     // panel goes beyond the middle position of the current panel.
     if (dragging_panel_right_boundary < current_panel->GetBounds().x() +
             current_panel->GetBounds().width() / 2)
       break;
 
     // Moves current panel to the new position.
     gfx::Rect bounds(current_panel->GetBounds());
     bounds.set_x(current_panel_left_boundary);
     current_panel_left_boundary += bounds.width() + kPanelsHorizontalSpacing;
-    current_panel->SetPanelBounds(bounds);
+    current_panel->SetPanelBounds(bounds, true);  // use animation.
 
     // Updates the index of current panel since it has been moved to the
     // position of previous panel.
     panels_[current_panel_index + 1] = current_panel;
   }
 
   // Updates the position and index of dragging panel as the result of moving
   // other affected panels.
   if (current_panel_index != static_cast<int>(dragging_panel_index_) - 1) {
     dragging_panel_bounds_.set_x(current_panel_left_boundary);
     dragging_panel_index_ = current_panel_index + 1;
     panels_[dragging_panel_index_] = dragging_panel;
   }
 }
 
 void PanelStrip::EndDragging(bool cancelled) {
   DCHECK(dragging_panel_index_ != kInvalidPanelIndex);
 
   if (cancelled) {
     Drag(dragging_panel_original_x_ -
          panels_[dragging_panel_index_]->GetBounds().x());
   } else {
     panels_[dragging_panel_index_]->SetPanelBounds(
-        dragging_panel_bounds_);
+        dragging_panel_bounds_, true);  // use animation.
   }
 
   dragging_panel_index_ = kInvalidPanelIndex;
 
   DelayedRemove();
 }
 
 void PanelStrip::OnPanelExpansionStateChanged(
     Panel::ExpansionState old_state, Panel::ExpansionState new_state) {
   DCHECK_NE(new_state, old_state);
@@ skipping 48 matching lines @@
       if (panels_[i] == panel) {
         panel_index = i;
         break;
       }
     }
     DCHECK(panel_index >= 0);
     for (int i = static_cast<int>(panels_.size()) -1; i > panel_index;
          --i) {
       gfx::Rect this_bounds = panels_[i]->GetBounds();
       this_bounds.set_x(this_bounds.x() + delta);
-      panels_[i]->SetPanelBounds(this_bounds);
+      panels_[i]->SetPanelBounds(this_bounds, true);  // use animation.
     }
   }
 
   // The panel height:
   // * cannot grow or shrink to go beyond [min_height, max_height]
   int new_height = preferred_window_size.height();
   if (new_height > panel->max_size().height())
     new_height = panel->max_size().height();
   if (new_height < panel->min_size().height())
     new_height = panel->min_size().height();
 
   // Only need to adjust bounds height when panel is expanded.
   gfx::Size restored_size = panel->restored_size();
   if (new_height != restored_size.height() &&
       panel->expansion_state() == Panel::EXPANDED) {
     bounds.set_y(bounds.y() - new_height + bounds.height());
     bounds.set_height(new_height);
   }
 
   gfx::Size new_size = gfx::Size(new_width, new_height);
   if (new_size != restored_size)
     panel->set_restored_size(new_size);
 
-  panel->SetPanelBounds(bounds);
+  panel->SetPanelBounds(bounds, true);  // use animation.
 }
 
 bool PanelStrip::ShouldBringUpTitlebars(int mouse_x, int mouse_y) const {
   // We should always bring up the titlebar if the mouse is over the
   // visible auto-hiding bottom bar.
   AutoHidingDesktopBar* desktop_bar = panel_manager_->auto_hiding_desktop_bar();
   if (desktop_bar->IsEnabled(AutoHidingDesktopBar::ALIGN_BOTTOM) &&
       desktop_bar->GetVisibility(AutoHidingDesktopBar::ALIGN_BOTTOM) ==
           AutoHidingDesktopBar::VISIBLE &&
       mouse_y >= strip_bounds_.bottom())
@@ skipping 140 matching lines @@
 
 void PanelStrip::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(
         GetBottomPositionForExpansionState(panel->expansion_state()) -
             new_bounds.height());
-    panel->SetPanelBounds(new_bounds);
+    panel->SetPanelBounds(new_bounds, true);  // use animation.
 
     rightmost_position = new_bounds.x() - kPanelsHorizontalSpacing;
   }
 }
 
 void PanelStrip::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 PanelStrip::is_dragging_panel() const {
   return dragging_panel_index_ != kInvalidPanelIndex;
 }