Remove dependency from infobars component to the embedder

components/infobars/core/infobar.cc

 // Copyright 2014 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 "components/infobars/core/infobar.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "components/infobars/core/infobar_container.h"
 #include "components/infobars/core/infobar_manager.h"
 #include "ui/gfx/animation/slide_animation.h"
 
 namespace infobars {
 
+// static
+int InfoBar::gSeparatorLineHeight = 1;
+int InfoBar::gDefaultArrowTargetHeight = 9;
+int InfoBar::gMaximumArrowTargetHeight = 24;
+int InfoBar::gDefaultArrowTargetHalfWidth = gDefaultArrowTargetHeight;
+int InfoBar::gMaximumArrowTargetHalfWidth = 14;
+int InfoBar::gDefaultBarTargetHeight = 36;
+
 InfoBar::InfoBar(scoped_ptr<InfoBarDelegate> delegate)
     : owner_(NULL),
       delegate_(delegate.Pass()),
       container_(NULL),
       animation_(this),
       arrow_height_(0),
-      arrow_target_height_(kDefaultArrowTargetHeight),
+      arrow_target_height_(gDefaultArrowTargetHeight),
       arrow_half_width_(0),
       bar_height_(0),
-      bar_target_height_(kDefaultBarTargetHeight) {
+      bar_target_height_(gDefaultBarTargetHeight) {
   DCHECK(delegate_ != NULL);
   animation_.SetTweenType(gfx::Tween::LINEAR);
   delegate_->set_infobar(this);
 }
 
 InfoBar::~InfoBar() {
   DCHECK(!owner_);
 }
 
 // static
+void InfoBar::Initialize(int defaultBarTargetHeight,
+                         int separatorLineHeight,
+                         int defaultArrowTargetHeight,
+                         int maximumArrowTargetHeight,
+                         int defaultArrowTargetHalfWidth,
+                         int maximumArrowTargetHalfWidth) {
+  gDefaultBarTargetHeight = defaultBarTargetHeight;
+  gSeparatorLineHeight = separatorLineHeight;
+  gDefaultArrowTargetHeight = defaultArrowTargetHeight;
+  gMaximumArrowTargetHeight = maximumArrowTargetHeight;
+  gDefaultArrowTargetHalfWidth = defaultArrowTargetHalfWidth;
+  gMaximumArrowTargetHalfWidth = maximumArrowTargetHalfWidth;
+}
+
+// static
 SkColor InfoBar::GetTopColor(InfoBarDelegate::Type infobar_type) {
   static const SkColor kWarningBackgroundColorTop =
       SkColorSetRGB(255, 242, 183);  // Yellow
   static const SkColor kPageActionBackgroundColorTop =
       SkColorSetRGB(237, 237, 237);  // Gray
   return (infobar_type == InfoBarDelegate::WARNING_TYPE) ?
       kWarningBackgroundColorTop : kPageActionBackgroundColorTop;
 }
 
 // static
@@ skipping 31 matching lines @@
     animation_.Reset(0.0);
     // We want to remove ourselves from the container immediately even if we
     // still have an owner, which MaybeDelete() won't do.
     DCHECK(container_);
     container_->RemoveInfoBar(this);
     MaybeDelete();  // Necessary if the infobar was already closing.
   }
 }
 
 void InfoBar::SetArrowTargetHeight(int height) {
-  DCHECK_LE(height, kMaximumArrowTargetHeight);
+  DCHECK_LE(height, gMaximumArrowTargetHeight);
   // Once the closing animation starts, we ignore further requests to change the
   // target height.
   if ((arrow_target_height_ != height) && !animation_.IsClosing()) {
     arrow_target_height_ = height;
     RecalculateHeights(false);
   }
 }
 
 void InfoBar::CloseSoon() {
   owner_ = NULL;
@@ skipping 32 matching lines @@
 
   // Find the desired arrow height/half-width.  The arrow area is
   // |arrow_height_| * |arrow_half_width_|.  When the bar is opening or closing,
   // scaling each of these with the square root of the animation value causes a
   // linear animation of the area, which matches the perception of the animation
   // of the bar portion.
   double scale_factor = sqrt(animation_.GetCurrentValue());
   arrow_height_ = static_cast<int>(arrow_target_height_ * scale_factor);
   if (animation_.is_animating()) {
     arrow_half_width_ = static_cast<int>(std::min(arrow_target_height_,
-        kMaximumArrowTargetHalfWidth) * scale_factor);
+        gMaximumArrowTargetHalfWidth) * scale_factor);
   } else {
     // When the infobar is not animating (i.e. fully open), we set the
     // half-width to be proportionally the same distance between its default and
     // maximum values as the height is between its.
-    arrow_half_width_ = kDefaultArrowTargetHalfWidth +
-        ((kMaximumArrowTargetHalfWidth - kDefaultArrowTargetHalfWidth) *
-         ((arrow_height_ - kDefaultArrowTargetHeight) /
-          (kMaximumArrowTargetHeight - kDefaultArrowTargetHeight)));
+    arrow_half_width_ = gDefaultArrowTargetHalfWidth +
+        ((gMaximumArrowTargetHalfWidth - gDefaultArrowTargetHalfWidth) *
+         ((arrow_height_ - gDefaultArrowTargetHeight) /
+          (gMaximumArrowTargetHeight - gDefaultArrowTargetHeight)));
   }
   // Add pixels for the stroke, if the arrow is to be visible at all.  Without
-  // this, changing the arrow height from 0 to kSeparatorLineHeight would
+  // this, changing the arrow height from 0 to gSeparatorLineHeight would
   // produce no visible effect, because the stroke would paint atop the divider
   // line above the infobar.
   if (arrow_height_)
-    arrow_height_ += kSeparatorLineHeight;
+    arrow_height_ += gSeparatorLineHeight;
 
   bar_height_ = animation_.CurrentValueBetween(0, bar_target_height_);
 
   // 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.
   bool heights_differ =
       (old_arrow_height != arrow_height_) || (old_bar_height != bar_height_);
   if (heights_differ)
     PlatformSpecificOnHeightsRecalculated();
 
   if (container_ && (heights_differ || force_notify))
     container_->OnInfoBarStateChanged(animation_.is_animating());
 }
 
 void InfoBar::MaybeDelete() {
   if (!owner_ && (animation_.GetCurrentValue() == 0.0)) {
     if (container_)
       container_->RemoveInfoBar(this);
     delete this;
   }
 }
 
 }  // namespace infobars