Remove dependency from infobars component to the embedder

chrome/browser/ui/views/infobars/infobar_view.cc

 // Copyright (c) 2012 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 <algorithm>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/ui/views/infobars/infobar_background.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/infobars/core/infobar_delegate.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
@@ skipping 20 matching lines @@
 const int kBeforeCloseButtonSpacing = views::kUnrelatedControlHorizontalSpacing;
 
 bool SortLabelsByDecreasingWidth(views::Label* label_1, views::Label* label_2) {
   return label_1->GetPreferredSize().width() >
       label_2->GetPreferredSize().width();
 }
 
 }  // namespace
 
 
-// InfoBar --------------------------------------------------------------------
-
-// static
-const int infobars::InfoBar::kSeparatorLineHeight =
-    views::NonClientFrameView::kClientEdgeThickness;
-const int infobars::InfoBar::kDefaultArrowTargetHeight = 9;
-const int infobars::InfoBar::kMaximumArrowTargetHeight = 24;
-const int infobars::InfoBar::kDefaultArrowTargetHalfWidth =
-    kDefaultArrowTargetHeight;
-const int infobars::InfoBar::kMaximumArrowTargetHalfWidth = 14;
-const int infobars::InfoBar::kDefaultBarTargetHeight = 36;
-
 // InfoBarView ----------------------------------------------------------------
 
 // static
 const int InfoBarView::kButtonButtonSpacing = views::kRelatedButtonHSpacing;
 const int InfoBarView::kEndOfLabelSpacing = views::kItemLabelSpacing;
 
 InfoBarView::InfoBarView(scoped_ptr<infobars::InfoBarDelegate> delegate)
     : infobars::InfoBar(delegate.Pass()),
-      views::ExternalFocusTracker(this, NULL),
-      icon_(NULL),
-      close_button_(NULL) {
+      views::ExternalFocusTracker(this, nullptr),
+      icon_(nullptr),
+      close_button_(nullptr) {
   set_owned_by_client();  // InfoBar deletes itself at the appropriate time.
   set_background(
       new InfoBarBackground(infobars::InfoBar::delegate()->GetInfoBarType()));
 }
 
 InfoBarView::~InfoBarView() {
   // We should have closed any open menus in PlatformSpecificHide(), then
   // subclasses' RunMenu() functions should have prevented opening any new ones
   // once we became unowned.
   DCHECK(!menu_runner_.get());
@@ skipping 58 matching lines @@
   std::sort(labels->begin(), labels->end(), SortLabelsByDecreasingWidth);
   AssignWidthsSorted(labels, available_width);
 }
 
 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();
+  DCHECK(owner());
+  const infobars::InfoBarConstants& constants = owner()->GetInfoBarConstants();
   const infobars::InfoBarContainer::Delegate* delegate = container_delegate();
   if (delegate) {
     static_cast<InfoBarBackground*>(background())->set_separator_color(
         delegate->GetInfoBarSeparatorColor());
     int arrow_x;
-    SkScalar arrow_fill_height =
-        SkIntToScalar(std::max(arrow_height() - kSeparatorLineHeight, 0));
+    SkScalar arrow_fill_height = SkIntToScalar(
+        std::max(arrow_height() - constants.separator_line_height, 0));
     SkScalar arrow_fill_half_width = SkIntToScalar(arrow_half_width());
-    SkScalar separator_height = SkIntToScalar(kSeparatorLineHeight);
+    SkScalar separator_height = SkIntToScalar(constants.separator_line_height);
     if (delegate->DrawInfoBarArrows(&arrow_x) && arrow_fill_height) {
       // Skia pixel centers are at the half-values, so the arrow is horizontally
       // centered at |arrow_x| + 0.5.  Vertically, the stroke path is the center
       // of the separator, while the fill path is a closed path that extends up
       // through the entire height of the separator and down to the bottom of
       // the arrow where it joins the bar.
       stroke_path_.moveTo(
           SkIntToScalar(arrow_x) + SK_ScalarHalf - arrow_fill_half_width,
           SkIntToScalar(arrow_height()) - (separator_height * SK_ScalarHalf));
       stroke_path_.rLineTo(arrow_fill_half_width, -arrow_fill_height);
       stroke_path_.rLineTo(arrow_fill_half_width, arrow_fill_height);
 
       fill_path_ = stroke_path_;
       // Move the top of the fill path up to the top of the separator and then
       // extend it down all the way through.
       fill_path_.offset(0, -separator_height * SK_ScalarHalf);
       // This 0.01 hack prevents the fill from filling more pixels on the right
       // edge of the arrow than on the left.
       const SkScalar epsilon = 0.01f;
       fill_path_.rLineTo(-epsilon, 0);
       fill_path_.rLineTo(0, separator_height);
       fill_path_.rLineTo(epsilon - (arrow_fill_half_width * 2), 0);
       fill_path_.close();
     }
   }
   if (bar_height()) {
-    fill_path_.addRect(0.0, SkIntToScalar(arrow_height()),
-        SkIntToScalar(width()), SkIntToScalar(height() - kSeparatorLineHeight));
+    fill_path_.addRect(
+        0.0, SkIntToScalar(arrow_height()), SkIntToScalar(width()),
+        SkIntToScalar(height() - constants.separator_line_height));
   }
 
   int start_x = kEdgeItemPadding;
-  if (icon_ != NULL) {
+  if (icon_) {
     icon_->SetPosition(gfx::Point(start_x, OffsetY(icon_)));
     start_x = icon_->bounds().right() + kIconToLabelSpacing;
   }
 
   int content_minimum_width = ContentMinimumWidth();
   close_button_->SetPosition(gfx::Point(
       std::max(
           start_x + content_minimum_width +
               ((content_minimum_width > 0) ? kBeforeCloseButtonSpacing : 0),
           width() - kEdgeItemPadding - close_button_->width()),
       OffsetY(close_button_)));
 }
 
 void InfoBarView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   View::ViewHierarchyChanged(details);
 
-  if (details.is_add && (details.child == this) && (close_button_ == NULL)) {
+  if (details.is_add && (details.child == this) && !close_button_) {
     gfx::Image image = delegate()->GetIcon();
     if (!image.IsEmpty()) {
       icon_ = new views::ImageView;
       icon_->SetImage(image.ToImageSkia());
       icon_->SizeToPreferredSize();
       AddChildView(icon_);
     }
 
     close_button_ = new views::ImageButton(this);
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     close_button_->SetImage(views::CustomButton::STATE_NORMAL,
                             rb.GetImageNamed(IDR_CLOSE_1).ToImageSkia());
     close_button_->SetImage(views::CustomButton::STATE_HOVERED,
                             rb.GetImageNamed(IDR_CLOSE_1_H).ToImageSkia());
     close_button_->SetImage(views::CustomButton::STATE_PRESSED,
                             rb.GetImageNamed(IDR_CLOSE_1_P).ToImageSkia());
     close_button_->SizeToPreferredSize();
     close_button_->SetAccessibleName(
         l10n_util::GetStringUTF16(IDS_ACCNAME_CLOSE));
     close_button_->SetFocusable(true);
     AddChildView(close_button_);
-  } else if ((close_button_ != NULL) && (details.parent == this) &&
-      (details.child != close_button_) && (close_button_->parent() == this) &&
-      (child_at(child_count() - 1) != close_button_)) {
+  } else if (close_button_ && (details.parent == this) &&
+             (details.child != close_button_) &&
+             (close_button_->parent() == this) &&
+             (child_at(child_count() - 1) != close_button_)) {
     // For accessibility, ensure the close button is the last child view.
     RemoveChildView(close_button_);
     AddChildView(close_button_);
   }
 
+  DCHECK(owner());
+  const infobars::InfoBarConstants& constants = owner()->GetInfoBarConstants();
   // Ensure the infobar is tall enough to display its contents.
   const int kMinimumVerticalPadding = 6;
-  int height = kDefaultBarTargetHeight;
+  int height = constants.default_bar_target_height;
   for (int i = 0; i < child_count(); ++i) {
     const int child_height = child_at(i)->height();
     height = std::max(height, child_height + kMinimumVerticalPadding);
   }
   SetBarTargetHeight(height);
 }
 
 void InfoBarView::PaintChildren(gfx::Canvas* canvas,
                                 const views::CullSet& cull_set) {
   canvas->Save();
@@ skipping 21 matching lines @@
 }
 
 int InfoBarView::ContentMinimumWidth() const {
   return 0;
 }
 
 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() + kIconToLabelSpacing) : kEdgeItemPadding);
+  return std::min(EndX(), icon_
+                              ? (icon_->bounds().right() + kIconToLabelSpacing)
+                              : kEdgeItemPadding);
 }
 
 int InfoBarView::EndX() const {
   return close_button_->x() - kBeforeCloseButtonSpacing;
 }
 
 int InfoBarView::OffsetY(views::View* view) const {
   return arrow_height() +
       std::max((bar_target_height() - view->height()) / 2, 0) -
       (bar_target_height() - bar_height());
 }
 
 const infobars::InfoBarContainer::Delegate* InfoBarView::container_delegate()
     const {
   const infobars::InfoBarContainer* infobar_container = container();
-  return infobar_container ? infobar_container->delegate() : NULL;
+  return infobar_container ? infobar_container->delegate() : nullptr;
 }
 
 void InfoBarView::RunMenuAt(ui::MenuModel* menu_model,
                             views::MenuButton* button,
                             views::MenuAnchorPosition anchor) {
   DCHECK(owner());  // We'd better not open any menus while we're closing.
   gfx::Point screen_point;
   views::View::ConvertPointToScreen(button, &screen_point);
   menu_runner_.reset(
       new views::MenuRunner(menu_model, views::MenuRunner::HAS_MNEMONICS));
@@ skipping 29 matching lines @@
 
 void InfoBarView::PlatformSpecificHide(bool animate) {
   // Cancel any menus we may have open.  It doesn't make sense to leave them
   // open while we're hidden, and if we're going to become unowned, we can't
   // allow the user to choose any options and potentially call functions that
   // try to access the owner.
   menu_runner_.reset();
 
   // It's possible to be called twice (once with |animate| true and once with it
   // false); in this case the second SetFocusManager() call will silently no-op.
-  SetFocusManager(NULL);
+  SetFocusManager(nullptr);
 
   if (!animate)
     return;
 
   // Do not restore focus (and active state with it) if some other top-level
   // window became active.
   views::Widget* widget = GetWidget();
   if (!widget || widget->IsActive())
     FocusLastFocusedExternalView();
 }
@@ skipping 24 matching lines @@
 void InfoBarView::OnWillChangeFocus(View* focused_before, View* focused_now) {
   views::ExternalFocusTracker::OnWillChangeFocus(focused_before, focused_now);
 
   // This will trigger some screen readers to read the entire contents of this
   // infobar.
   if (focused_before && focused_now && !Contains(focused_before) &&
       Contains(focused_now)) {
     NotifyAccessibilityEvent(ui::AX_EVENT_ALERT, true);
   }
 }