Implement learn more bubble on views.

chrome/browser/ui/views/autofill/autofill_dialog_views.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/autofill/autofill_dialog_views.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/autofill/autofill_dialog_sign_in_delegate.h"
 #include "chrome/browser/ui/autofill/autofill_dialog_view_delegate.h"
 #include "chrome/browser/ui/autofill/loading_animation.h"
 #include "chrome/browser/ui/views/autofill/decorated_textfield.h"
-#include "chrome/browser/ui/views/autofill/tooltip_icon.h"
+#include "chrome/browser/ui/views/autofill/learn_more_icon.h"
 #include "chrome/browser/ui/views/constrained_window_views.h"
 #include "components/autofill/content/browser/wallet/wallet_service_url.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/web_modal/web_contents_modal_dialog_host.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "components/web_modal/web_contents_modal_dialog_manager_delegate.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/combobox_model.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/skia_util.h"
+#include "ui/gfx/vector2d.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/bubble/bubble_border.h"
 #include "ui/views/bubble/bubble_frame_view.h"
 #include "ui/views/controls/button/blue_button.h"
 #include "ui/views/controls/button/checkbox.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/combobox/combobox.h"
@@ skipping 40 matching lines @@
 
 const int kArrowHeight = 7;
 const int kArrowWidth = 2 * kArrowHeight;
 
 // The padding inside the edges of the dialog, in pixels.
 const int kDialogEdgePadding = 20;
 
 // The vertical padding between rows of manual inputs (in pixels).
 const int kManualInputRowPadding = 10;
 
-// The margin between the content of the error bubble and its border.
-const int kErrorBubbleHorizontalMargin = 14;
-const int kErrorBubbleVerticalMargin = 12;
+// The margin between the content of an info bubble and its border.
+const int kInfoBubbleHorizontalMargin = 14;
+const int kInfoBubbleVerticalMargin = 12;
 
 // The visible width of bubble borders (differs from the actual width) in px.
 const int kBubbleBorderVisibleWidth = 1;
 
 // Slight shading for mouse hover and legal document background.
 SkColor kShadingColor = SkColorSetARGB(7, 0, 0, 0);
 
 // A border color for the legal document view.
 SkColor kSubtleBorderColor = SkColorSetARGB(10, 0, 0, 0);
 
@@ skipping 132 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(LayoutPropagationView);
 };
 
 // A View for a single notification banner.
 class NotificationView : public views::View,
                          public views::ButtonListener,
                          public views::StyledLabelListener {
  public:
   NotificationView(const DialogNotification& data,
-                   AutofillDialogViewDelegate* delegate)
+                   AutofillDialogViewDelegate* delegate,
+                   const base::WeakPtr<LearnMoreIconDelegate>& icon_delegate)
       : data_(data),
         delegate_(delegate),
         checkbox_(NULL) {
     scoped_ptr<views::View> label_view;
     if (data.HasCheckbox()) {
       scoped_ptr<views::Checkbox> checkbox(
           new views::Checkbox(base::string16()));
       checkbox->SetText(data.display_text());
       checkbox->SetTextMultiLine(true);
       checkbox->SetHorizontalAlignment(gfx::ALIGN_LEFT);
@@ skipping 27 matching lines @@
       } else {
         label->AddStyleRange(gfx::Range(0, data.display_text().size()),
                              text_style);
       }
 
       label_view.reset(label.release());
     }
 
     AddChildView(label_view.release());
 
-    if (!data.tooltip_text().empty())
-      AddChildView(new TooltipIcon(data.tooltip_text()));
+    if (!data.learn_more_text().empty())
+      AddChildView(new LearnMoreIcon(data.learn_more_text(), icon_delegate));
 
     set_background(
        views::Background::CreateSolidBackground(data.GetBackgroundColor()));
     set_border(views::Border::CreateSolidSidedBorder(1, 0, 1, 0,
                                                      data.GetBorderColor()));
   }
 
   virtual ~NotificationView() {}
 
   views::Checkbox* checkbox() {
     return checkbox_;
   }
 
   // views::View implementation.
   virtual gfx::Insets GetInsets() const OVERRIDE {
     int vertical_padding = kNotificationPadding;
     if (checkbox_)
       vertical_padding -= 3;
     return gfx::Insets(vertical_padding, kDialogEdgePadding,
                        vertical_padding, kDialogEdgePadding);
   }
 
   virtual int GetHeightForWidth(int width) OVERRIDE {
     int label_width = width - GetInsets().width();
     if (child_count() > 1) {
-      views::View* tooltip_icon = child_at(1);
-      label_width -= tooltip_icon->GetPreferredSize().width() +
+      views::View* learn_more_icon = child_at(1);
+      label_width -= learn_more_icon->GetPreferredSize().width() +
           kDialogEdgePadding;
     }
 
     return child_at(0)->GetHeightForWidth(label_width) + GetInsets().height();
   }
 
   virtual void Layout() OVERRIDE {
     // Surprisingly, GetContentsBounds() doesn't consult GetInsets().
     gfx::Rect bounds = GetLocalBounds();
     bounds.Inset(GetInsets());
     int right_bound = bounds.right();
 
     if (child_count() > 1) {
       // The icon takes up the entire vertical space and an extra 20px on
-      // each side. This increases the hover target for the tooltip.
-      views::View* tooltip_icon = child_at(1);
-      gfx::Size icon_size = tooltip_icon->GetPreferredSize();
+      // each side. This increases the hover target for the learn more icon.
+      views::View* learn_more_icon = child_at(1);
+      gfx::Size icon_size = learn_more_icon->GetPreferredSize();
       int icon_width = icon_size.width() + kDialogEdgePadding;
       right_bound -= icon_width;
-      tooltip_icon->SetBounds(
+      learn_more_icon->SetBounds(
           right_bound, 0,
           icon_width + kDialogEdgePadding, GetLocalBounds().height());
     }
 
     child_at(0)->SetBounds(bounds.x(), bounds.y(),
                            right_bound - bounds.x(), bounds.height());
   }
 
   // views::ButtonListener implementation.
   virtual void ButtonPressed(views::Button* sender,
@@ skipping 91 matching lines @@
   // Contains the "Loading" label and the dots.
   views::View* container_;
 
   LoadingAnimation animation_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadingAnimationView);
 };
 
 }  // namespace
 
-// AutofillDialogViews::ErrorBubble --------------------------------------------
+// AutofillDialogViews::InfoBubble --------------------------------------------
 
-AutofillDialogViews::ErrorBubble::ErrorBubble(views::View* anchor,
-                                              views::View* anchor_container,
-                                              const base::string16& message)
+AutofillDialogViews::InfoBubble::InfoBubble(views::View* anchor,
+                                            const base::string16& message,
+                                            bool snap_to_grid)
     : anchor_(anchor),
-      anchor_container_(anchor_container),
+      anchor_container_(anchor->GetWidget()->non_client_view()),
       show_above_anchor_(
-          anchor->GetClassName() == views::Combobox::kViewClassName) {
+          anchor->GetClassName() == views::Combobox::kViewClassName),
+      snap_to_grid_(snap_to_grid) {
   DCHECK(anchor_container_->Contains(anchor));
   SetAnchorView(anchor_);
 
   // TODO(dbeam): currently we assume that combobox menus always show downward
   // (which isn't true). If the invalid combobox is low enough on the screen,
   // its menu will actually show upward and obscure the bubble. Figure out when
   // this might happen and adjust |show_above_anchor_| accordingly. This is not
   // that big of deal because it rarely happens in practice.
   if (show_above_anchor_) {
     set_arrow(ShouldArrowGoOnTheRight() ? views::BubbleBorder::BOTTOM_RIGHT :
                                           views::BubbleBorder::BOTTOM_LEFT);
   } else {
     set_arrow(ShouldArrowGoOnTheRight() ? views::BubbleBorder::TOP_RIGHT :
                                           views::BubbleBorder::TOP_LEFT);
   }
 
-  set_margins(gfx::Insets(kErrorBubbleVerticalMargin,
-                          kErrorBubbleHorizontalMargin,
-                          kErrorBubbleVerticalMargin,
-                          kErrorBubbleHorizontalMargin));
+  set_margins(gfx::Insets(kInfoBubbleVerticalMargin,
+                          kInfoBubbleHorizontalMargin,
+                          kInfoBubbleVerticalMargin,
+                          kInfoBubbleHorizontalMargin));
   set_use_focusless(true);
 
   SetLayoutManager(new views::FillLayout);
   views::Label* label = new views::Label(message);
   label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   label->SetMultiLine(true);
   AddChildView(label);
 
   widget_ = views::BubbleDelegateView::CreateBubble(this);
   UpdatePosition();
 }
 
-AutofillDialogViews::ErrorBubble::~ErrorBubble() {
+AutofillDialogViews::InfoBubble::~InfoBubble() {
   DCHECK(!widget_);
 }
 
-void AutofillDialogViews::ErrorBubble::Hide() {
+void AutofillDialogViews::InfoBubble::Hide() {
   views::Widget* widget = GetWidget();
   if (widget && !widget->IsClosed())
     widget->Close();
 }
 
-void AutofillDialogViews::ErrorBubble::UpdatePosition() {
+void AutofillDialogViews::InfoBubble::UpdatePosition() {
   if (!widget_)
     return;
 
   if (!anchor_->GetVisibleBounds().IsEmpty()) {
     SizeToContents();
     widget_->SetVisibilityChangedAnimationsEnabled(true);
     widget_->ShowInactive();
   } else {
     widget_->SetVisibilityChangedAnimationsEnabled(false);
     widget_->Hide();
   }
 }
 
-gfx::Size AutofillDialogViews::ErrorBubble::GetPreferredSize() {
+gfx::Size AutofillDialogViews::InfoBubble::GetPreferredSize() {
   int pref_width = GetPreferredBubbleWidth();
   pref_width -= GetBubbleFrameView()->GetInsets().width();
   pref_width -= 2 * kBubbleBorderVisibleWidth;
   return gfx::Size(pref_width, GetHeightForWidth(pref_width));
 }
 
-gfx::Rect AutofillDialogViews::ErrorBubble::GetBubbleBounds() {
+gfx::Rect AutofillDialogViews::InfoBubble::GetBubbleBounds() {
   gfx::Rect bounds = views::BubbleDelegateView::GetBubbleBounds();
   gfx::Rect anchor_bounds = anchor_->GetBoundsInScreen();
 
+  if (anchor_->GetClassName() == LearnMoreIcon::kViewClassName) {

[Evan Stade, 2013/11/05 02:01:40]

boooo

[Dan Beam, 2013/11/05 07:00:55]

removed

+    gfx::Size pref_size = anchor_->GetPreferredSize();
+    gfx::Point new_origin = anchor_bounds.CenterPoint();
+    new_origin.Offset(-pref_size.width() / 2, -pref_size.height() / 2);
+    anchor_bounds = gfx::Rect(new_origin, pref_size);
+    bounds.set_y(anchor_bounds.bottom());
+  }
+
   if (show_above_anchor_)
     bounds.set_y(anchor_bounds.y() - GetBubbleFrameView()->height());
 
-  anchor_bounds.Inset(-GetBubbleFrameView()->bubble_border()->GetInsets());
-  bounds.set_x(ShouldArrowGoOnTheRight() ?
-      anchor_bounds.right() - bounds.width() - kBubbleBorderVisibleWidth :
-      anchor_bounds.x() + kBubbleBorderVisibleWidth);
+  if (snap_to_grid_) {
+    anchor_bounds.Inset(-GetBubbleFrameView()->bubble_border()->GetInsets());
+    bounds.set_x(ShouldArrowGoOnTheRight() ?
+        anchor_bounds.right() - bounds.width() - kBubbleBorderVisibleWidth :
+        anchor_bounds.x() + kBubbleBorderVisibleWidth);
+  }
+
   return bounds;
 }
 
-void AutofillDialogViews::ErrorBubble::OnWidgetClosing(views::Widget* widget) {
+void AutofillDialogViews::InfoBubble::OnWidgetClosing(views::Widget* widget) {
   if (widget == widget_)
     widget_ = NULL;
 }
 
-bool AutofillDialogViews::ErrorBubble::ShouldFlipArrowForRtl() const {
+bool AutofillDialogViews::InfoBubble::ShouldFlipArrowForRtl() const {
   return false;
 }
 
-int AutofillDialogViews::ErrorBubble::GetContainerWidth() {
-  return anchor_container_->width() - anchor_container_->GetInsets().width();
+int AutofillDialogViews::InfoBubble::GetPreferredBubbleWidth() {
+  return (kSectionContainerWidth - views::kRelatedControlHorizontalSpacing) / 2;
 }
 
-int AutofillDialogViews::ErrorBubble::GetPreferredBubbleWidth() {
-  return (GetContainerWidth() - views::kRelatedControlHorizontalSpacing) / 2;
-}
-
-bool AutofillDialogViews::ErrorBubble::ShouldArrowGoOnTheRight() {
+bool AutofillDialogViews::InfoBubble::ShouldArrowGoOnTheRight() {
   gfx::Point anchor_offset;
   views::View::ConvertPointToTarget(anchor_, anchor_container_, &anchor_offset);
   anchor_offset.Offset(-anchor_container_->GetInsets().left(), 0);
 
   if (base::i18n::IsRTL()) {
     int anchor_right_x = anchor_offset.x() + anchor_->width();
     return anchor_right_x >= GetPreferredBubbleWidth();
   }
 
-  return anchor_offset.x() + GetPreferredBubbleWidth() > GetContainerWidth();
+  int container_width = anchor_container_->width();
+  return anchor_offset.x() + GetPreferredBubbleWidth() > container_width;
 }
 
 // AutofillDialogViews::AccountChooser -----------------------------------------
 
 AutofillDialogViews::AccountChooser::AccountChooser(
     AutofillDialogViewDelegate* delegate)
     : image_(new views::ImageView()),
       menu_button_(new views::MenuButton(NULL, base::string16(), this, true)),
       link_(new views::Link()),
       delegate_(delegate) {
@@ skipping 213 matching lines @@
   int bubble_width = 5;
   if (GetBubbleBorder())
     bubble_width = GetBubbleBorder()->GetBorderThickness();
   bounds.Inset(bubble_width, bubble_width, bubble_width, bubble_width);
   return bounds;
 }
 
 // AutofillDialogViews::NotificationArea ---------------------------------------
 
 AutofillDialogViews::NotificationArea::NotificationArea(
-    AutofillDialogViewDelegate* delegate)
-    : delegate_(delegate) {
+    AutofillDialogViewDelegate* delegate,
+    const base::WeakPtr<LearnMoreIconDelegate>& icon_delegate)
+    : delegate_(delegate),
+      icon_delegate_(icon_delegate) {
   // Reserve vertical space for the arrow (regardless of whether one exists).
   // The -1 accounts for the border.
   set_border(views::Border::CreateEmptyBorder(kArrowHeight - 1, 0, 0, 0));
 
   views::BoxLayout* box_layout =
       new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0);
   SetLayoutManager(box_layout);
 }
 
 AutofillDialogViews::NotificationArea::~NotificationArea() {}
 
 void AutofillDialogViews::NotificationArea::SetNotifications(
     const std::vector<DialogNotification>& notifications) {
   notifications_ = notifications;
 
   RemoveAllChildViews(true);
 
   if (notifications_.empty())
     return;
 
   for (size_t i = 0; i < notifications_.size(); ++i) {
     const DialogNotification& notification = notifications_[i];
     scoped_ptr<NotificationView> view(new NotificationView(notification,
-                                                           delegate_));
+                                                           delegate_,
+                                                           icon_delegate_));
 
     AddChildView(view.release());
   }
 
   PreferredSizeChanged();
 }
 
 gfx::Size AutofillDialogViews::NotificationArea::GetPreferredSize() {
   gfx::Size size = views::View::GetPreferredSize();
   // Ensure that long notifications wrap and don't enlarge the dialog.
@@ skipping 424 matching lines @@
       loading_shield_height_(0),
       overlay_view_(NULL),
       button_strip_extra_view_(NULL),
       save_in_chrome_checkbox_(NULL),
       save_in_chrome_checkbox_container_(NULL),
       button_strip_image_(NULL),
       footnote_view_(NULL),
       legal_document_view_(NULL),
       focus_manager_(NULL),
       error_bubble_(NULL),
-      observer_(this) {
+      learn_more_bubble_(NULL),
+      observer_(this),
+      weak_ptr_factory_(this) {
   DCHECK(delegate);
   detail_groups_.insert(std::make_pair(SECTION_CC,
                                        DetailsGroup(SECTION_CC)));
   detail_groups_.insert(std::make_pair(SECTION_BILLING,
                                        DetailsGroup(SECTION_BILLING)));
   detail_groups_.insert(std::make_pair(SECTION_CC_BILLING,
                                        DetailsGroup(SECTION_CC_BILLING)));
   detail_groups_.insert(std::make_pair(SECTION_SHIPPING,
                                        DetailsGroup(SECTION_SHIPPING)));
 }
 
 AutofillDialogViews::~AutofillDialogViews() {
   HideErrorBubble();
+  HideLearnMoreBubble();
   DCHECK(!window_);
 }
 
 void AutofillDialogViews::Show() {
   InitChildViews();
   UpdateAccountChooser();
   UpdateNotificationArea();
   UpdateButtonStripExtraView();
 
   // Ownership of |contents_| is handed off by this call. The widget will take
@@ skipping 350 matching lines @@
     DCHECK_EQ(scrollable_area_->contents(), details_container_);
     details_container_->SizeToPreferredSize();
     // TODO(estade): remove this hack. See crbug.com/285996
     details_container_->set_ignore_layouts(true);
     scrollable_area_->SetBounds(x, scroll_y, width, scroll_bottom - scroll_y);
     details_container_->set_ignore_layouts(false);
   }
 
   if (error_bubble_)
     error_bubble_->UpdatePosition();
+  if (learn_more_bubble_)
+    learn_more_bubble_->UpdatePosition();
 }
 
 base::string16 AutofillDialogViews::GetWindowTitle() const {
   base::string16 title = delegate_->DialogTitle();
   // Hack alert: we don't want the dialog to jiggle when a title is added or
   // removed. Setting a non-empty string here keeps the dialog's title bar the
   // same size.
   return title.empty() ? ASCIIToUTF16(" ") : title;
 }
 
@@ skipping 216 matching lines @@
                               views::MenuItemView::TOPRIGHT,
                               ui::MENU_SOURCE_NONE,
                               0) == views::MenuRunner::MENU_DELETED) {
     return;
   }
 
   group->container->SetActive(false);
   group->suggested_button->SetState(state);
 }
 
+void AutofillDialogViews::OnLearnMoreIconMouseEntered(LearnMoreIcon* icon) {
+  ShowLearnMoreBubbleIfNecessary(icon);
+}
+
+void AutofillDialogViews::OnLearnMoreIconMouseExited(LearnMoreIcon* icon) {
+  DCHECK_EQ(icon, learn_more_bubble_->anchor());
+  HideLearnMoreBubble();
+}
+
 gfx::Size AutofillDialogViews::CalculatePreferredSize(bool get_minimum_size) {
   gfx::Insets insets = GetInsets();
   gfx::Size scroll_size = scrollable_area_->contents()->GetPreferredSize();
   // The width is always set by the scroll area.
   const int width = scroll_size.width();
 
   if (sign_in_web_view_->visible()) {
     const gfx::Size size = static_cast<views::View*>(sign_in_web_view_)->
         GetPreferredSize();
     return gfx::Size(width + insets.width(), size.height() + insets.height());
@@ skipping 62 matching lines @@
   save_in_chrome_checkbox_container_->SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 7));
   button_strip_extra_view_->AddChildView(save_in_chrome_checkbox_container_);
 
   save_in_chrome_checkbox_ =
       new views::Checkbox(delegate_->SaveLocallyText());
   save_in_chrome_checkbox_->SetChecked(delegate_->ShouldSaveInChrome());
   save_in_chrome_checkbox_container_->AddChildView(save_in_chrome_checkbox_);
 
   save_in_chrome_checkbox_container_->AddChildView(
-      new TooltipIcon(delegate_->SaveLocallyTooltip()));
+      new LearnMoreIcon(delegate_->SaveLocallyLearnMoreText(),
+                        weak_ptr_factory_.GetWeakPtr()));
 
   button_strip_image_ = new views::ImageView();
   button_strip_extra_view_->AddChildView(button_strip_image_);
 
   account_chooser_ = new AccountChooser(delegate_);
-  notification_area_ = new NotificationArea(delegate_);
+  notification_area_ =
+      new NotificationArea(delegate_, weak_ptr_factory_.GetWeakPtr());
   notification_area_->set_arrow_centering_anchor(account_chooser_->AsWeakPtr());
   AddChildView(notification_area_);
 
   scrollable_area_ = new views::ScrollView();
   scrollable_area_->set_hide_horizontal_scrollbar(true);
   scrollable_area_->SetContents(CreateDetailsContainer());
   AddChildView(scrollable_area_);
 
   loading_shield_ = new LoadingAnimationView(delegate_->SpinnerText());
   AddChildView(loading_shield_);
@@ skipping 247 matching lines @@
     return;
   }
 
   std::map<views::View*, base::string16>::iterator error_message =
       validity_map_.find(view);
   if (error_message != validity_map_.end()) {
     view->ScrollRectToVisible(view->GetLocalBounds());
 
     if (!error_bubble_ || error_bubble_->anchor() != view) {
       HideErrorBubble();
-      views::View* section =
-          view->GetAncestorWithClassName(kSectionContainerClassName);
-      error_bubble_ = new ErrorBubble(view, section, error_message->second);
+      error_bubble_ = new InfoBubble(view, error_message->second, true);
     }
   }
 }
 
+void AutofillDialogViews::ShowLearnMoreBubbleIfNecessary(LearnMoreIcon* icon) {
+  if (!icon->GetWidget())
+    return;
+
+  if (!learn_more_bubble_ || learn_more_bubble_->anchor() != icon) {
+    HideLearnMoreBubble();
+    learn_more_bubble_ = new InfoBubble(icon, icon->learn_more_text(), false);
+  }
+}
+
 void AutofillDialogViews::HideErrorBubble() {
   if (error_bubble_) {
     error_bubble_->Hide();
     error_bubble_ = NULL;
   }
 }
 
+void AutofillDialogViews::HideLearnMoreBubble() {
+  if (learn_more_bubble_) {
+    learn_more_bubble_->Hide();
+    learn_more_bubble_ = NULL;
+  }
+}
+
 void AutofillDialogViews::MarkInputsInvalid(
     DialogSection section,
     const ValidityMessages& messages,
     bool overwrite_unsure) {
   DetailsGroup* group = GroupForSection(section);
   DCHECK(group->container->visible());
 
   if (group->manual_input->visible()) {
     for (TextfieldMap::const_iterator iter = group->textfields.begin();
          iter != group->textfields.end(); ++iter) {
@@ skipping 226 matching lines @@
     if (combo_mapping != group.comboboxes.end())
       return combo_mapping->second;
   }
 
   return NULL;
 }
 
 void AutofillDialogViews::DetailsContainerBoundsChanged() {
   if (error_bubble_)
     error_bubble_->UpdatePosition();
+  if (learn_more_bubble_)
+    learn_more_bubble_->UpdatePosition();
 }
 
 void AutofillDialogViews::SetIconsForSection(DialogSection section) {
   DetailOutputMap user_input;
   GetUserInput(section, &user_input);
   FieldValueMap field_values;
   for (DetailOutputMap::const_iterator user_input_it = user_input.begin();
        user_input_it != user_input.end();
        ++user_input_it) {
     const DetailInput* field_detail = user_input_it->first;
     const string16& field_value = user_input_it->second;
     field_values[field_detail->type] = field_value;
   }
   FieldIconMap field_icons = delegate_->IconsForFields(field_values);
   TextfieldMap* textfields = &GroupForSection(section)->textfields;
   for (TextfieldMap::const_iterator textfield_it = textfields->begin();
        textfield_it != textfields->end();
        ++textfield_it) {
     ServerFieldType field_type = textfield_it->first->type;
     FieldIconMap::const_iterator field_icon_it = field_icons.find(field_type);
     DecoratedTextfield* textfield = textfield_it->second;
-    if (field_icon_it != field_icons.end())
+    if (field_icon_it != field_icons.end()) {
       textfield->SetIcon(field_icon_it->second);
-    else
-      textfield->SetTooltipIcon(delegate_->TooltipForField(field_type));
+    } else {
+      textfield->SetLearnMoreIcon(delegate_->LearnMoreTextForField(field_type),
+                                  weak_ptr_factory_.GetWeakPtr());
+    }
   }
 }
 
 void AutofillDialogViews::SetEditabilityForSection(DialogSection section) {
   const DetailInputs& inputs =
       delegate_->RequestedFieldsForSection(section);
   DetailsGroup* group = GroupForSection(section);
 
   for (DetailInputs::const_iterator iter = inputs.begin();
        iter != inputs.end(); ++iter) {
@@ skipping 18 matching lines @@
 AutofillDialogViews::DetailsGroup::DetailsGroup(DialogSection section)
     : section(section),
       container(NULL),
       manual_input(NULL),
       suggested_info(NULL),
       suggested_button(NULL) {}
 
 AutofillDialogViews::DetailsGroup::~DetailsGroup() {}
 
 }  // namespace autofill