[linux_views][Win] spoof proof redesign infobar extension with tab.

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/confirm_infobar_delegate.h"
 #include "chrome/browser/ui/views/infobars/infobar_background.h"
@@ skipping 23 matching lines @@
 #include "ui/base/win/hwnd_util.h"
 #include "ui/gfx/icon_util.h"
 #endif
 
 // static
 const int InfoBarView::kDefaultTargetHeight = 36;
 const int InfoBarView::kButtonButtonSpacing = 10;
 const int InfoBarView::kEndOfLabelSpacing = 16;
 const int InfoBarView::kHorizontalPadding = 6;
 
+const int InfoBarView::kCurveWidth = 13;
+const int InfoBarView::kMaxIconWidth = 30;
+const int InfoBarView::kTabHeight = 9;
+const int InfoBarView::kTabIconPadding = 2;
+
+const int InfoBarView::kTabWidth = (kCurveWidth + kTabIconPadding) * 2 +
+    kMaxIconWidth;
+
 InfoBarView::InfoBarView(InfoBarDelegate* delegate)
     : InfoBar(delegate),
       container_(NULL),
       delegate_(delegate),
       icon_(NULL),
       close_button_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(animation_(new ui::SlideAnimation(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(delete_factory_(this)),
-      target_height_(kDefaultTargetHeight) {
+      target_height_(kDefaultTargetHeight),
+      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));
   SetAccessibleName(l10n_util::GetStringUTF16(
       (infobar_type == InfoBarDelegate::WARNING_TYPE) ?
       IDS_ACCNAME_INFOBAR_WARNING : IDS_ACCNAME_INFOBAR_PAGE_ACTION));
 
   animation_->SetTweenType(ui::Tween::LINEAR);
 }
@@ skipping 19 matching lines @@
       restore_focus = false;
   #endif  // defined(OS_WIN)
     DestroyFocusTracker(restore_focus);
     animation_->Hide();
   } else {
     animation_->Reset(0.0);
     Close();
   }
 }
 
-void InfoBarView::PaintArrow(gfx::Canvas* canvas,
-                             View* outer_view,
-                             int arrow_center_x) {
-  gfx::Point infobar_top(0, y());
-  ConvertPointToView(parent(), outer_view, &infobar_top);
-  int infobar_top_y = infobar_top.y();
-  SkPoint gradient_points[2] = {
-      {SkIntToScalar(0), SkIntToScalar(infobar_top_y)},
-      {SkIntToScalar(0), SkIntToScalar(infobar_top_y + target_height_)}
-  };
-  InfoBarDelegate::Type infobar_type = delegate_->GetInfoBarType();
-  SkColor gradient_colors[2] = {
-      InfoBarBackground::GetTopColor(infobar_type),
-      InfoBarBackground::GetBottomColor(infobar_type),
-  };
-  SkShader* gradient_shader = SkGradientShader::CreateLinear(gradient_points,
-      gradient_colors, NULL, 2, SkShader::kMirror_TileMode);
-  SkPaint paint;
-  paint.setStrokeWidth(1);
-  paint.setStyle(SkPaint::kFill_Style);
-  paint.setShader(gradient_shader);
-  gradient_shader->unref();
-
-  // The size of the arrow (its height; also half its width).  The
-  // arrow area is |arrow_size| ^ 2.  By taking the square root of the
-  // animation value, we cause a linear animation of the area, which
-  // matches the perception of the animation of the InfoBar.
-  const int kArrowSize = 10;
-  int arrow_size = static_cast<int>(kArrowSize *
-                                    sqrt(animation_->GetCurrentValue()));
-  SkPath fill_path;
-  fill_path.moveTo(SkPoint::Make(SkIntToScalar(arrow_center_x - arrow_size),
-                                 SkIntToScalar(infobar_top_y)));
-  fill_path.rLineTo(SkIntToScalar(arrow_size), SkIntToScalar(-arrow_size));
-  fill_path.rLineTo(SkIntToScalar(arrow_size), SkIntToScalar(arrow_size));
-  SkPath border_path(fill_path);
-  fill_path.close();
-  gfx::CanvasSkia* canvas_skia = canvas->AsCanvasSkia();
-  canvas_skia->drawPath(fill_path, paint);
-
-  // 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.
-  border_path.offset(SK_ScalarHalf, SK_ScalarHalf);
-  paint.setShader(NULL);
-  paint.setColor(SkColorSetA(ResourceBundle::toolbar_separator_color,
-                             SkColorGetA(gradient_colors[0])));
-  paint.setStyle(SkPaint::kStroke_Style);
-  canvas_skia->drawPath(border_path, paint);
-}
-
 InfoBarView::~InfoBarView() {
 }
 
 // static
 views::Label* InfoBarView::CreateLabel(const string16& text) {
   views::Label* label = new views::Label(UTF16ToWideHack(text),
       ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::MediumFont));
   label->SetColor(SK_ColorBLACK);
   label->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
   return label;
@@ skipping 67 matching lines @@
         gfx::Size(GetSystemMetrics(SM_CXSMICON),
                   GetSystemMetrics(SM_CYSMICON))));
   }
 #endif
   return text_button;
 }
 
 void InfoBarView::Layout() {
   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();
-    icon_->SetBounds(start_x, OffsetY(icon_size), icon_size.width(),
-                     icon_size.height());
+    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.
+    int offset_y =
+        std::max((full_height - icon_size.height()) / 2, 0) -
+        (full_height - height());
+    icon_->SetBounds(center_x, offset_y, icon_size.width(), icon_size.height());
     start_x += icon_->bounds().right();
   }
 
   gfx::Size button_size = close_button_->GetPreferredSize();
   close_button_->SetBounds(std::max(start_x + ContentMinimumWidth(),
       width() - kHorizontalPadding - button_size.width()),
       OffsetY(button_size), button_size.width(), button_size.height());
 }
 
 void InfoBarView::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
@@ skipping 53 matching lines @@
 
   // For accessibility, ensure the close button is the last child view.
   if ((close_button_ != NULL) && (parent == this) && (child != close_button_) &&
       (close_button_->parent() == this) &&
       (GetChildViewAt(child_count() - 1) != close_button_)) {
     RemoveChildView(close_button_);
     AddChildView(close_button_);
   }
 }
 
+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);
+
+  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();
   }
 }
 
 void InfoBarView::AnimationProgressed(const ui::Animation* animation) {
@@ skipping 21 matching lines @@
 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) - (target_height_ - height());
+  return CenterY(prefsize) + AnimatedTabHeight() -
+      (target_height_ - AnimatedBarHeight());
+}
+
+int InfoBarView::AnimatedTabHeight() const {
+  return static_cast<int>(kTabHeight * animation_->GetCurrentValue());
+}
+
+int InfoBarView::AnimatedBarHeight() const {
+  return static_cast<int>(target_height_ * animation_->GetCurrentValue());
 }
 
 AccessibilityTypes::Role InfoBarView::GetAccessibleRole() {
   return AccessibilityTypes::ROLE_ALERT;
 }
 
 gfx::Size InfoBarView::GetPreferredSize() {
-  return gfx::Size(0,
-      static_cast<int>(target_height_ * animation_->GetCurrentValue()));
+  return gfx::Size(0, AnimatedTabHeight() + AnimatedBarHeight());
+}
+
+void InfoBarView::OnBoundsChanged() {
+  views::View::OnBoundsChanged();
+  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()));
+  }
 }
 
 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))
     NotifyAccessibilityEvent(AccessibilityTypes::EVENT_ALERT);
 }
 
@@ skipping 24 matching lines @@
   // window), since this action can cause the delegate to destroy itself.
   if (delegate_) {
     delegate_->InfoBarClosed();
     delegate_ = NULL;
   }
 }
 
 void InfoBarView::DeleteSelf() {
   delete this;
 }