Fix DCHECK() in infobar animation.

chrome/browser/ui/views/infobars/infobar_view.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/views/infobars/infobar_view.h"
 
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/tab_contents/infobar_delegate.h"
 #include "chrome/browser/ui/views/infobars/infobar_background.h"
@@ skipping 38 matching lines @@
 
 const int InfoBarView::kTabWidth = (kCurveWidth + kTabIconPadding) * 2 +
     kMaxIconWidth;
 
 InfoBarView::InfoBarView(InfoBarDelegate* delegate)
     : InfoBar(delegate),
       icon_(NULL),
       close_button_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(delete_factory_(this)),
       target_height_(kDefaultTargetHeight),
+      tab_height_(0),
+      bar_height_(0),
       fill_path_(new SkPath),
       stroke_path_(new SkPath) {
   set_parent_owned(false);  // InfoBar deletes itself at the appropriate time.
 
   InfoBarDelegate::Type infobar_type = delegate->GetInfoBarType();
   set_background(new InfoBarBackground(infobar_type));
 }
 
 InfoBarView::~InfoBarView() {
 }
@@ skipping 73 matching lines @@
     (*func)(SIID_SHIELD, SHGSI_ICON | SHGSI_SMALLICON, &icon_info);
     text_button->SetIcon(*IconUtil::CreateSkBitmapFromHICON(icon_info.hIcon,
         gfx::Size(GetSystemMetrics(SM_CXSMICON),
                   GetSystemMetrics(SM_CYSMICON))));
   }
 #endif
   return text_button;
 }
 
 void InfoBarView::Layout() {
+  // Calculate the fill and stroke paths.  We do this here, rather than in
+  // PlatformSpecificRecalculateHeight(), because this is also reached when our
+  // width is changed, which affects both paths.
+  stroke_path_->rewind();
+  fill_path_->rewind();
+  if (tab_height_) {
+    int divider_y = tab_height_ - 1;
+    stroke_path_->moveTo(
+        SkIntToScalar(GetMirroredXWithWidthInView(0, kTabWidth)),
+        SkIntToScalar(divider_y));
+    stroke_path_->rCubicTo(
+        SkScalarDiv(kCurveWidth, 2), 0.0,
+        SkScalarDiv(kCurveWidth, 2),
+        SkIntToScalar(-divider_y),
+        SkIntToScalar(kCurveWidth),
+        SkIntToScalar(-divider_y));
+    stroke_path_->rLineTo(SkScalarMulAdd(kTabIconPadding, 2, kMaxIconWidth),
+                          0.0);
+    stroke_path_->rCubicTo(
+        SkScalarDiv(kCurveWidth, 2), 0.0,
+        SkScalarDiv(kCurveWidth, 2),
+        SkIntToScalar(divider_y),
+        SkIntToScalar(kCurveWidth),
+        SkIntToScalar(divider_y));
+
+    // Create the fill portion of the tab.  Because the fill is inside the
+    // bounds and will not cover the separator, we need to extend downward by a
+    // pixel before closing.
+    *fill_path_ = *stroke_path_;
+    fill_path_->rLineTo(0.0, 1.0);
+    fill_path_->rLineTo(-SkIntToScalar(kTabWidth), 0.0);
+    fill_path_->close();
+
+    // Fill and stroke have different opinions about how to treat paths.
+    // Because in Skia integral coordinates represent pixel boundaries,
+    // offsetting the path makes it go exactly through pixel centers; this
+    // results in lines that are exactly where we expect, instead of having odd
+    // "off by one" issues.  Were we to do this for |fill_path|, however, which
+    // tries to fill "inside" the path (using some questionable math), we'd get
+    // a fill at a very different place than we'd want.
+    stroke_path_->offset(SK_ScalarHalf, SK_ScalarHalf);
+  }
+  if (bar_height_) {
+    fill_path_->addRect(0.0, SkIntToScalar(tab_height_), SkIntToScalar(width()),
+                        SkIntToScalar(height()));
+  }
+
   int start_x = kHorizontalPadding;
   if (icon_ != NULL) {
     // Center the icon horizontally within the tab, and vertically between the
     // entire height (tab + bar).
     gfx::Size icon_size = icon_->GetPreferredSize();
     int center_x = std::max((kTabWidth - icon_size.width()) / 2, 0);
     int full_height = target_height_ + kTabHeight;
 
     // This duplicates OffsetY except centered within the entire height (tab +
     // bar) instead of just within the bar.
@@ skipping 76 matching lines @@
 
 void InfoBarView::PaintChildren(gfx::Canvas* canvas) {
   canvas->Save();
 
   // TODO(scr): This really should be the |fill_path_|, but the clipPath seems
   // broken on non-Windows platforms (crbug.com/75154). For now, just clip to
   // the bar bounds.
   //
   // gfx::CanvasSkia* canvas_skia = canvas->AsCanvasSkia();
   // canvas_skia->clipPath(*fill_path_);
-  int tab_height = AnimatedTabHeight();
-  int bar_height = AnimatedBarHeight();
-  DCHECK_EQ(tab_height + bar_height, height())
-      << "Animation progressed between OnBoundsChanged & PaintChildren.";
-  canvas->ClipRectInt(0, tab_height, width(), bar_height);
-
+  DCHECK_EQ(tab_height_ + bar_height_, height())
+      << "Infobar piecewise heights do not match overall height";
+  canvas->ClipRectInt(0, tab_height_, width(), bar_height_);
   views::View::PaintChildren(canvas);
   canvas->Restore();
 }
 
 void InfoBarView::ButtonPressed(views::Button* sender,
                                 const views::Event& event) {
   if (sender == close_button_) {
     if (delegate())
       delegate()->InfoBarDismissed();
     RemoveInfoBar();
   }
 }
 
 int InfoBarView::ContentMinimumWidth() const {
   return 0;
 }
 
+void InfoBarView::SetTargetHeight(int height) {
+  if (target_height_ != height) {
+    target_height_ = height;
+    RecalculateHeight();
+  }
+}
+
 int InfoBarView::StartX() const {
   // Ensure we don't return a value greater than EndX(), so children can safely
   // set something's width to "EndX() - StartX()" without risking that being
   // negative.
   return std::min(EndX(),
       ((icon_ != NULL) ? icon_->bounds().right() : 0) + kHorizontalPadding);
 }
 
 int InfoBarView::EndX() const {
   const int kCloseButtonSpacing = 12;
   return close_button_->x() - kCloseButtonSpacing;
 }
 
 int InfoBarView::CenterY(const gfx::Size prefsize) const {
   return std::max((target_height_ - prefsize.height()) / 2, 0);
 }
 
 int InfoBarView::OffsetY(const gfx::Size prefsize) const {
-  return CenterY(prefsize) + AnimatedTabHeight() -
-      (target_height_ - AnimatedBarHeight());
+  return CenterY(prefsize) + tab_height_ - (target_height_ - bar_height_);
 }
 
 void InfoBarView::PlatformSpecificHide(bool animate) {
   if (!animate)
     return;
 
   bool restore_focus = true;
 #if defined(OS_WIN)
   // Do not restore focus (and active state with it) on Windows if some other
   // top-level window became active.
   if (GetWidget() &&
       !ui::DoesWindowBelongToActiveWindow(GetWidget()->GetNativeView()))
     restore_focus = false;
 #endif  // defined(OS_WIN)
   DestroyFocusTracker(restore_focus);
 }
 
+void InfoBarView::PlatformSpecificRecalculateHeight() {
+  int old_tab_height = tab_height_;
+  int old_bar_height = bar_height_;
+  tab_height_ = static_cast<int>(kTabHeight * animation()->GetCurrentValue());
+  bar_height_ =
+      static_cast<int>(target_height_ * animation()->GetCurrentValue());
+
+  // Don't re-layout if nothing has changed, e.g. because the animation step was
+  // not large enough to actually change the heights by at least a pixel.
+  if ((old_tab_height != tab_height_) || (old_bar_height != bar_height_)) {
+    // Ensure that notifying our container of our size change will result in a
+    // re-layout.
+    InvalidateLayout();
+  }
+}
+
 void InfoBarView::GetAccessibleState(ui::AccessibleViewState* state) {
   if (delegate()) {
     state->name = l10n_util::GetStringUTF16(
         (delegate()->GetInfoBarType() == InfoBarDelegate::WARNING_TYPE) ?
         IDS_ACCNAME_INFOBAR_WARNING : IDS_ACCNAME_INFOBAR_PAGE_ACTION);
   }
   state->role = ui::AccessibilityTypes::ROLE_ALERT;
 }
 
-int InfoBarView::AnimatedTabHeight() const {
-  return static_cast<int>(kTabHeight * animation()->GetCurrentValue());
-}
-
-int InfoBarView::AnimatedBarHeight() const {
-  return static_cast<int>(target_height_ * animation()->GetCurrentValue());
-}
-
 gfx::Size InfoBarView::GetPreferredSize() {
-  return gfx::Size(0, AnimatedTabHeight() + AnimatedBarHeight());
-}
-
-void InfoBarView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
-  int tab_height = AnimatedTabHeight();
-  int bar_height = AnimatedBarHeight();
-  int divider_y = tab_height - 1;
-  DCHECK_EQ(tab_height + bar_height, height())
-      << "Animation progressed between Layout & OnBoundsChanged.";
-
-  int mirrored_x = GetMirroredXWithWidthInView(0, kTabWidth);
-  stroke_path_->rewind();
-  fill_path_->rewind();
-
-  if (tab_height) {
-    stroke_path_->moveTo(SkIntToScalar(mirrored_x),
-                         SkIntToScalar(divider_y));
-    stroke_path_->rCubicTo(
-        SkScalarDiv(kCurveWidth, 2), 0.0,
-        SkScalarDiv(kCurveWidth, 2),
-        SkIntToScalar(-divider_y),
-        SkIntToScalar(kCurveWidth),
-        SkIntToScalar(-divider_y));
-    stroke_path_->rLineTo(SkScalarMulAdd(kTabIconPadding, 2, kMaxIconWidth),
-                          0.0);
-    stroke_path_->rCubicTo(
-        SkScalarDiv(kCurveWidth, 2), 0.0,
-        SkScalarDiv(kCurveWidth, 2),
-        SkIntToScalar(divider_y),
-        SkIntToScalar(kCurveWidth),
-        SkIntToScalar(divider_y));
-
-    // Create the fill portion of the tab.  Because the fill is inside the
-    // bounds and will not cover the separator, we need to extend downward by a
-    // pixel before closing.
-    *fill_path_ = *stroke_path_;
-    fill_path_->rLineTo(0.0, 1.0);
-    fill_path_->rLineTo(-SkIntToScalar(kTabWidth), 0.0);
-    fill_path_->close();
-
-    // Fill and stroke have different opinions about how to treat paths.
-    // Because in Skia integral coordinates represent pixel boundaries,
-    // offsetting the path makes it go exactly through pixel centers; this
-    // results in lines that are exactly where we expect, instead of having odd
-    // "off by one" issues.  Were we to do this for |fill_path|, however, which
-    // tries to fill "inside" the path (using some questionable math), we'd get
-    // a fill at a very different place than we'd want.
-    stroke_path_->offset(SK_ScalarHalf, SK_ScalarHalf);
-  }
-  if (bar_height) {
-    fill_path_->addRect(0.0, SkIntToScalar(tab_height),
-                        SkIntToScalar(width()), SkIntToScalar(height()));
-  }
+  return gfx::Size(0, tab_height_ + bar_height_);
 }
 
 void InfoBarView::FocusWillChange(View* focused_before, View* focused_now) {
   // This will trigger some screen readers to read the entire contents of this
   // infobar.
   if (focused_before && focused_now && !this->Contains(focused_before) &&
       this->Contains(focused_now) && GetWidget()) {
     GetWidget()->NotifyAccessibilityEvent(
         this, ui::AccessibilityTypes::EVENT_ALERT, true);
   }
 }
 
 void InfoBarView::DestroyFocusTracker(bool restore_focus) {
   if (focus_tracker_ != NULL) {
     if (restore_focus)
       focus_tracker_->FocusLastFocusedExternalView();
     focus_tracker_->SetFocusManager(NULL);
     focus_tracker_.reset();
   }
 }
 
 void InfoBarView::DeleteSelf() {
   delete this;
 }