Convert ExtensionInstalledBubble to BubbleDialogDelegateView

chrome/browser/ui/views/extensions/extension_installed_bubble_view.cc

 // Copyright 2013 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/extensions/extension_installed_bubble_view.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/macros.h"
 #include "base/metrics/user_metrics_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
+#include "chrome/browser/ui/views/location_bar/location_icon_view.h"
 #include "chrome/browser/ui/views/location_bar/page_action_with_badge_view.h"
 #include "chrome/browser/ui/views/sync/bubble_sync_promo_view.h"
 #include "chrome/browser/ui/views/toolbar/app_menu_button.h"
 #include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
 #include "chrome/browser/ui/views/toolbar/toolbar_view.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/bubble/bubble_controller.h"
 #include "components/bubble/bubble_ui.h"
@@ skipping 76 matching lines @@
  private:
   views::Label* heading_;
   views::LabelButton* close_;
 
   DISALLOW_COPY_AND_ASSIGN(HeadingAndCloseButtonView);
 };
 
 }  // namespace
 
 ExtensionInstalledBubbleView::ExtensionInstalledBubbleView(
-    ExtensionInstalledBubble* bubble,
-    BubbleReference bubble_reference)
-    : bubble_(bubble),
-      bubble_reference_(bubble_reference),
-      extension_(bubble->extension()),
-      browser_(bubble->browser()),
-      type_(bubble->type()),
-      anchor_position_(bubble->anchor_position()),
+    ExtensionInstalledBubble* controller)
+    : BubbleDialogDelegateView(nullptr,
+                               controller->anchor_position() ==
+                                       ExtensionInstalledBubble::ANCHOR_OMNIBOX
+                                   ? views::BubbleBorder::TOP_LEFT
+                                   : views::BubbleBorder::TOP_RIGHT),
+      controller_(controller),
       close_(nullptr),
       manage_shortcut_(nullptr) {}
 
 ExtensionInstalledBubbleView::~ExtensionInstalledBubbleView() {}
 
 void ExtensionInstalledBubbleView::UpdateAnchorView() {

[msw, 2016/04/07 21:48:57]

nit q: Should this function also update the arrow? (may not really matter)

[Evan Stade, 2016/04/07 22:19:15]

I don't think that can change (because the controller_->type()/anchor_position()
can't change) and it wasn't doing so before.

[msw, 2016/04/07 22:30:58]

Acknowledged.

-  BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser_);
+  BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser());
 
   views::View* reference_view = nullptr;
-  switch (anchor_position_) {
+  switch (controller_->anchor_position()) {
     case ExtensionInstalledBubble::ANCHOR_BROWSER_ACTION: {
       BrowserActionsContainer* container =
           browser_view->GetToolbarView()->browser_actions();
       // Hitting this DCHECK means |ShouldShow| failed.
       DCHECK(!container->animating());
 
-      reference_view = container->GetViewForId(extension_->id());
+      reference_view = container->GetViewForId(controller_->extension()->id());
       // If the view is not visible then it is in the chevron, so point the
       // install bubble to the chevron instead. If this is an incognito window,
       // both could be invisible.
       if (!reference_view || !reference_view->visible()) {
         reference_view = container->chevron();
         if (!reference_view || !reference_view->visible())
           reference_view = nullptr;  // fall back to app menu below.
       }
       break;
     }
     case ExtensionInstalledBubble::ANCHOR_PAGE_ACTION: {
       LocationBarView* location_bar_view = browser_view->GetLocationBarView();
       ExtensionAction* page_action =
-          extensions::ExtensionActionManager::Get(browser_->profile())
-              ->GetPageAction(*extension_);
+          extensions::ExtensionActionManager::Get(browser()->profile())
+              ->GetPageAction(*controller_->extension());
       location_bar_view->SetPreviewEnabledPageAction(page_action,
                                                      true);  // preview_enabled
       reference_view = location_bar_view->GetPageActionView(page_action);
       DCHECK(reference_view);
       break;
     }
     case ExtensionInstalledBubble::ANCHOR_OMNIBOX: {
-      LocationBarView* location_bar_view = browser_view->GetLocationBarView();
-      reference_view = location_bar_view;
-      DCHECK(reference_view);
+      reference_view = browser_view->GetLocationBarView()->location_icon_view();
       break;
     }
     case ExtensionInstalledBubble::ANCHOR_APP_MENU:
       // Will be caught below.
       break;
   }
 
   // Default case.
   if (!reference_view)
     reference_view = browser_view->GetToolbarView()->app_menu_button();
   SetAnchorView(reference_view);
 }
 
 views::View* ExtensionInstalledBubbleView::CreateFootnoteView() {
-  if (!(bubble_->options() & ExtensionInstalledBubble::SIGN_IN_PROMO))
+  if (!(controller_->options() & ExtensionInstalledBubble::SIGN_IN_PROMO))
     return nullptr;
 
   return new BubbleSyncPromoView(this,
                                  IDS_EXTENSION_INSTALLED_SYNC_PROMO_LINK_NEW,
                                  IDS_EXTENSION_INSTALLED_SYNC_PROMO_NEW);
 }
 
+int ExtensionInstalledBubbleView::GetDialogButtons() const {
+  return ui::DIALOG_BUTTON_NONE;
+}
+
 void ExtensionInstalledBubbleView::WindowClosing() {
-  if (anchor_position_ == ExtensionInstalledBubble::ANCHOR_PAGE_ACTION) {
-    BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser_);
+  if (controller_->anchor_position() ==
+      ExtensionInstalledBubble::ANCHOR_PAGE_ACTION) {
+    BrowserView* browser_view =
+        BrowserView::GetBrowserViewForBrowser(browser());
     browser_view->GetLocationBarView()->SetPreviewEnabledPageAction(
-        extensions::ExtensionActionManager::Get(browser_->profile())
-            ->GetPageAction(*extension_),
+        extensions::ExtensionActionManager::Get(browser()->profile())
+            ->GetPageAction(*controller_->extension()),
         false);  // preview_enabled
   }
 }
 
-gfx::Rect ExtensionInstalledBubbleView::GetAnchorRect() const {
-  // For omnibox keyword bubbles, move the arrow to point to the left edge
-  // of the omnibox, just to the right of the icon.
-  if (type_ == ExtensionInstalledBubble::OMNIBOX_KEYWORD) {

[msw, 2016/04/07 21:48:57]

These bubbles shouldn't point to the left omnibox edge anymore?

[Evan Stade, 2016/04/07 22:19:15]

I accomplished this in a simpler way, see L163

[msw, 2016/04/07 22:30:59]

Ah, I figured this really wanted the left edge, not the location icon on the
left side; but it probably doesn't matter.

-    const LocationBarView* location_bar_view =
-        BrowserView::GetBrowserViewForBrowser(browser_)->GetLocationBarView();
-    return gfx::Rect(location_bar_view->GetOmniboxViewOrigin(),
-                     gfx::Size(0, location_bar_view->omnibox_view()->height()));
-  }
-  return views::BubbleDelegateView::GetAnchorRect();
-}
-
-void ExtensionInstalledBubbleView::OnWidgetClosing(views::Widget* widget) {
-  if (bubble_reference_) {
-    DCHECK_EQ(widget, GetWidget());
-    // A more specific close reason should already be recorded.
-    // This is the catch-all close reason for this bubble.
-    bubble_reference_->CloseBubble(BUBBLE_CLOSE_FOCUS_LOST);
-  }
-}
-
-void ExtensionInstalledBubbleView::OnWidgetActivationChanged(
-    views::Widget* widget,
-    bool active) {
-  if (!active && bubble_reference_ && widget == GetWidget())
-    bubble_reference_->CloseBubble(BUBBLE_CLOSE_FOCUS_LOST);
-}
-
-bool ExtensionInstalledBubbleView::AcceleratorPressed(
-    const ui::Accelerator& accelerator) {
-  if (!close_on_esc() || accelerator.key_code() != ui::VKEY_ESCAPE)
-    return false;
-  DCHECK(bubble_reference_);
-  bool did_close = bubble_reference_->CloseBubble(BUBBLE_CLOSE_USER_DISMISSED);

[msw, 2016/04/07 21:48:57]

Was this implementing the close on esc behavior? Does it still work? I just
realized that BubbleDialogDelegateView doesn't have close_on_esc, and wonder if
some of the converted bubbles aren't closing on escape now...

[Evan Stade, 2016/04/07 22:19:15]

DCV handles close on escape.

[msw, 2016/04/07 22:30:59]

Acknowledged.

-  DCHECK(did_close);
-  return true;
-}
-
 void ExtensionInstalledBubbleView::OnSignInLinkClicked() {
   GetWidget()->Close();
   chrome::ShowBrowserSignin(
-      browser_,
+      browser(),
       signin_metrics::AccessPoint::ACCESS_POINT_EXTENSION_INSTALL_BUBBLE);
 }
 
 void ExtensionInstalledBubbleView::ButtonPressed(views::Button* sender,
                                                  const ui::Event& event) {
   DCHECK_EQ(sender, close_);
   GetWidget()->Close();
 }
 
 void ExtensionInstalledBubbleView::LinkClicked(views::Link* source,
                                                int event_flags) {
   DCHECK_EQ(manage_shortcut_, source);
   GetWidget()->Close();
 
   std::string configure_url = chrome::kChromeUIExtensionsURL;
   configure_url += chrome::kExtensionConfigureCommandsSubPage;
   chrome::NavigateParams params(
-      chrome::GetSingletonTabNavigateParams(browser_, GURL(configure_url)));
+      chrome::GetSingletonTabNavigateParams(browser(), GURL(configure_url)));
   chrome::Navigate(&params);
 }
 
-void ExtensionInstalledBubbleView::InitLayout() {
+void ExtensionInstalledBubbleView::Init() {
+  UpdateAnchorView();
+
   // The Extension Installed bubble takes on various forms, depending on the
   // type of extension installed. In general, though, they are all similar:
   //
   // -------------------------
   // |      | Heading    [X] |
   // | Icon | Info           |
   // |      | Extra info     |
   // -------------------------
   //
   // Icon and Heading are always shown (as well as the close button).
   // Info is shown for browser actions, page actions and Omnibox keyword
   // extensions and might list keyboard shorcut for the former two types.
   // Extra info is...
   // ... for other types, either a description of how to manage the extension
   //     or a link to configure the keybinding shortcut (if one exists).
   // Extra info can include a promo for signing into sync.
 
-  const ExtensionInstalledBubble& bubble = *bubble_;
   // The number of rows in the content section of the bubble.
   int main_content_row_count = 1;
-  if (bubble.options() & ExtensionInstalledBubble::HOW_TO_USE)
+  if (controller_->options() & ExtensionInstalledBubble::HOW_TO_USE)
     ++main_content_row_count;
-  if (bubble.options() & ExtensionInstalledBubble::SHOW_KEYBINDING)
+  if (controller_->options() & ExtensionInstalledBubble::SHOW_KEYBINDING)
     ++main_content_row_count;
-  if (bubble.options() & ExtensionInstalledBubble::HOW_TO_MANAGE)
+  if (controller_->options() & ExtensionInstalledBubble::HOW_TO_MANAGE)
     ++main_content_row_count;
 
   views::GridLayout* layout = new views::GridLayout(this);
   SetLayoutManager(layout);
 
   const int cs_id = 0;
 
   views::ColumnSet* main_cs = layout->AddColumnSet(cs_id);
   // Icon column.
   main_cs->AddColumn(views::GridLayout::CENTER, views::GridLayout::LEADING, 0,
                      views::GridLayout::USE_PREF, 0, 0);
   main_cs->AddPaddingColumn(0, views::kUnrelatedControlHorizontalSpacing);
   // Heading column.
   main_cs->AddColumn(views::GridLayout::LEADING, views::GridLayout::LEADING, 0,
                      views::GridLayout::FIXED, kRightColumnWidth, 0);
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   const gfx::FontList& font_list = rb.GetFontList(ui::ResourceBundle::BaseFont);
 
-  const SkBitmap& bitmap = bubble.icon();
+  const SkBitmap& bitmap = controller_->icon();
   // Add the icon (for all options).
   // Scale down to 43x43, but allow smaller icons (don't scale up).
   gfx::Size size(bitmap.width(), bitmap.height());
   if (size.width() > kIconSize || size.height() > kIconSize)
     size = gfx::Size(kIconSize, kIconSize);
   views::ImageView* icon = new views::ImageView();
   icon->SetImageSize(size);
   icon->SetImage(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
 
   layout->StartRow(0, cs_id);
   layout->AddView(icon, 1, main_content_row_count);
 
   // Add the heading (for all options).
-  base::string16 extension_name = base::UTF8ToUTF16(extension_->name());
+  base::string16 extension_name =
+      base::UTF8ToUTF16(controller_->extension()->name());
   base::i18n::AdjustStringForLocaleDirection(&extension_name);
   views::Label* heading =
       CreateLabel(l10n_util::GetStringFUTF16(IDS_EXTENSION_INSTALLED_HEADING,
                                              extension_name),
                   rb.GetFontList(ui::ResourceBundle::MediumFont));
 
   close_ = views::BubbleFrameView::CreateCloseButton(this);
 
   HeadingAndCloseButtonView* heading_and_close =
       new HeadingAndCloseButtonView(heading, close_);
 
   layout->AddView(heading_and_close);
   layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
 
   auto add_content_view = [&layout, &cs_id](views::View* view) {
     layout->StartRow(0, cs_id);
     // Skip the icon column.
     layout->SkipColumns(1);
     layout->AddView(view);
     layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
   };
 
-  if (bubble.options() & ExtensionInstalledBubble::HOW_TO_USE) {
-    add_content_view(CreateLabel(bubble.GetHowToUseDescription(), font_list));
+  if (controller_->options() & ExtensionInstalledBubble::HOW_TO_USE) {
+    add_content_view(
+        CreateLabel(controller_->GetHowToUseDescription(), font_list));
   }
 
-  if (bubble.options() & ExtensionInstalledBubble::SHOW_KEYBINDING) {
+  if (controller_->options() & ExtensionInstalledBubble::SHOW_KEYBINDING) {
     manage_shortcut_ = new views::Link(
         l10n_util::GetStringUTF16(IDS_EXTENSION_INSTALLED_MANAGE_SHORTCUTS));
     manage_shortcut_->set_listener(this);
     manage_shortcut_->SetUnderline(false);
     add_content_view(manage_shortcut_);
   }
 
-  if (bubble.options() & ExtensionInstalledBubble::HOW_TO_MANAGE) {
+  if (controller_->options() & ExtensionInstalledBubble::HOW_TO_MANAGE) {
     add_content_view(CreateLabel(
         l10n_util::GetStringUTF16(IDS_EXTENSION_INSTALLED_MANAGE_INFO),
         font_list));
   }
 }
 
 // Views specific implementation.
 bool ExtensionInstalledBubble::ShouldShow() {
   if (anchor_position() == ANCHOR_BROWSER_ACTION) {
     BrowserActionsContainer* container =
         BrowserView::GetBrowserViewForBrowser(browser())
             ->GetToolbarView()
             ->browser_actions();
     return !container->animating();
   }
   return true;
 }
 
+// NB: This bubble is using the temporarily-deprecated bubble manager interface
+// BubbleUi. Do not copy this pattern.
 class ExtensionInstalledBubbleUi : public BubbleUi {
  public:
   explicit ExtensionInstalledBubbleUi(ExtensionInstalledBubble* bubble);
   ~ExtensionInstalledBubbleUi() override;
 
  private:
   // BubbleUi:
   void Show(BubbleReference bubble_reference) override;
   void Close() override;
   void UpdateAnchorPosition() override;
 
   ExtensionInstalledBubble* bubble_;
-  ExtensionInstalledBubbleView* delegate_view_;
+  ExtensionInstalledBubbleView* bubble_view_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionInstalledBubbleUi);
 };
 
 // Implemented here to create the platform specific instance of the BubbleUi.
 scoped_ptr<BubbleUi> ExtensionInstalledBubble::BuildBubbleUi() {
   return make_scoped_ptr(new ExtensionInstalledBubbleUi(this));
 }
 
 ExtensionInstalledBubbleUi::ExtensionInstalledBubbleUi(
     ExtensionInstalledBubble* bubble)
-    : bubble_(bubble), delegate_view_(nullptr) {
+    : bubble_(bubble), bubble_view_(nullptr) {
   DCHECK(bubble_);
 }
 
 ExtensionInstalledBubbleUi::~ExtensionInstalledBubbleUi() {}
 
-void ExtensionInstalledBubbleUi::Show(BubbleReference bubble_reference) {
-  // Owned by widget.
-  delegate_view_ = new ExtensionInstalledBubbleView(bubble_, bubble_reference);
-  delegate_view_->UpdateAnchorView();
+void ExtensionInstalledBubbleUi::Show(BubbleReference /*bubble_reference*/) {
+  bubble_view_ = new ExtensionInstalledBubbleView(bubble_);
 
-  delegate_view_->set_arrow(bubble_->type() == bubble_->OMNIBOX_KEYWORD
-                                ? views::BubbleBorder::TOP_LEFT
-                                : views::BubbleBorder::TOP_RIGHT);
-
-  delegate_view_->InitLayout();
-
-  views::BubbleDelegateView::CreateBubble(delegate_view_)->Show();
+  views::BubbleDialogDelegateView::CreateBubble(bubble_view_)->Show();
   content::RecordAction(
       base::UserMetricsAction("Signin_Impression_FromExtensionInstallBubble"));
 }
 
 void ExtensionInstalledBubbleUi::Close() {
-  if (delegate_view_) {
-    delegate_view_->GetWidget()->Close();
-    delegate_view_ = nullptr;
+  if (bubble_view_) {
+    bubble_view_->GetWidget()->Close();
+    bubble_view_ = nullptr;
   }
 }
 
 void ExtensionInstalledBubbleUi::UpdateAnchorPosition() {
-  DCHECK(delegate_view_);
-  delegate_view_->UpdateAnchorView();
+  DCHECK(bubble_view_);
+  bubble_view_->UpdateAnchorView();
 }