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 169 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;
+    OnSizeChanged();
+  }
+}
+
 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::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;
-}
+void InfoBarView::PlatformSpecificOnSizeChanged() {
+  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());
+  if ((old_tab_height == tab_height_) && (old_bar_height == bar_height_))
+    return;
 
-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));
+  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,
@@ skipping 12 matching lines @@
 
     // 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),
+  if (bar_height_) {
+    fill_path_->addRect(0.0, SkIntToScalar(tab_height_),
                         SkIntToScalar(width()), SkIntToScalar(height()));
   }
+
+  // Ensure that notifying our container of our size change will result in a
+  // re-layout.
+  InvalidateLayout();

[Sheridan Rawlins, 2011/04/01 18:41:48]

InvalidateLayout only needs_layout, but doesn't cause Layout AFAIK.  Does this
need to notify container_?

[Peter Kasting, 2011/04/01 19:07:15]

We will notify the container immediately upon return, see
InfoBar::OnSizeChanged().

+}
+
+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;
+}
+
+gfx::Size InfoBarView::GetPreferredSize() {
+  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;
 }