Change ChooserBubbleDelegate class name to ChooserBubbleController

This patch changed ChooserBubbleDelegate class name to
ChooserBubbleController since it better reflects the class's
responsibilities and clarifies the roles of the class.

BUG=492204, 588933

Review URL: https://codereview.chromium.org/1724183005

Cr-Commit-Position: refs/heads/master@{#377989}

16 files changed, 196 insertions, 196 deletions

diff --git a/chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_delegate.cc b/chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_controller.cc
index 10ad62b..9e9e280 100644
--- a/chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_delegate.cc
+++ b/chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_controller.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_delegate.h"
+#include "chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_controller.h"
 
 #include "base/stl_util.h"
 #include "chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.h"
@@ -10,26 +10,26 @@
 #include "components/bubble/bubble_controller.h"
 #include "url/gurl.h"
 
-BluetoothChooserBubbleDelegate::BluetoothChooserBubbleDelegate(
+BluetoothChooserBubbleController::BluetoothChooserBubbleController(
     content::RenderFrameHost* owner)
-    : ChooserBubbleDelegate(owner), bluetooth_chooser_(nullptr) {}
+    : ChooserBubbleController(owner), bluetooth_chooser_(nullptr) {}
 
-BluetoothChooserBubbleDelegate::~BluetoothChooserBubbleDelegate() {
+BluetoothChooserBubbleController::~BluetoothChooserBubbleController() {
   if (bluetooth_chooser_)
-    bluetooth_chooser_->set_bluetooth_chooser_bubble_delegate(nullptr);
+    bluetooth_chooser_->set_bluetooth_chooser_bubble_controller(nullptr);
 }
 
-size_t BluetoothChooserBubbleDelegate::NumOptions() const {
+size_t BluetoothChooserBubbleController::NumOptions() const {
   return device_names_and_ids_.size();
 }
 
-const base::string16& BluetoothChooserBubbleDelegate::GetOption(
+const base::string16& BluetoothChooserBubbleController::GetOption(
     size_t index) const {
   DCHECK_LT(index, device_names_and_ids_.size());
   return device_names_and_ids_[index].first;
 }
 
-void BluetoothChooserBubbleDelegate::Select(size_t index) {
+void BluetoothChooserBubbleController::Select(size_t index) {
   DCHECK_LT(index, device_names_and_ids_.size());
   if (bluetooth_chooser_) {
     bluetooth_chooser_->CallEventHandler(
@@ -37,32 +37,32 @@ void BluetoothChooserBubbleDelegate::Select(size_t index) {
         device_names_and_ids_[index].second);
   }
 
-  if (bubble_controller_)
-    bubble_controller_->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
+  if (bubble_reference_)
+    bubble_reference_->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
 }
 
-void BluetoothChooserBubbleDelegate::Cancel() {
+void BluetoothChooserBubbleController::Cancel() {
   if (bluetooth_chooser_) {
     bluetooth_chooser_->CallEventHandler(
         content::BluetoothChooser::Event::CANCELLED, std::string());
   }
 
-  if (bubble_controller_)
-    bubble_controller_->CloseBubble(BUBBLE_CLOSE_CANCELED);
+  if (bubble_reference_)
+    bubble_reference_->CloseBubble(BUBBLE_CLOSE_CANCELED);
 }
 
-void BluetoothChooserBubbleDelegate::Close() {
+void BluetoothChooserBubbleController::Close() {
   if (bluetooth_chooser_) {
     bluetooth_chooser_->CallEventHandler(
         content::BluetoothChooser::Event::CANCELLED, std::string());
   }
 }
 
-GURL BluetoothChooserBubbleDelegate::GetHelpCenterUrl() const {
+GURL BluetoothChooserBubbleController::GetHelpCenterUrl() const {
   return GURL(chrome::kChooserBluetoothOverviewURL);
 }
 
-void BluetoothChooserBubbleDelegate::AddDevice(
+void BluetoothChooserBubbleController::AddDevice(
     const std::string& device_id,
     const base::string16& device_name) {
   device_names_and_ids_.push_back(std::make_pair(device_name, device_id));
@@ -70,7 +70,7 @@ void BluetoothChooserBubbleDelegate::AddDevice(
     observer()->OnOptionAdded(device_names_and_ids_.size() - 1);
 }
 
-void BluetoothChooserBubbleDelegate::RemoveDevice(
+void BluetoothChooserBubbleController::RemoveDevice(
     const std::string& device_id) {
   for (auto it = device_names_and_ids_.begin();
        it != device_names_and_ids_.end(); ++it) {
diff --git a/chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_delegate.h b/chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_controller.h
index 26d2455..f619e13 100644
--- a/chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_delegate.h
+++ b/chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_controller.h
@@ -2,27 +2,27 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_UI_BLUETOOTH_BLUETOOTH_CHOOSER_BUBBLE_DELEGATE_H_
-#define CHROME_BROWSER_UI_BLUETOOTH_BLUETOOTH_CHOOSER_BUBBLE_DELEGATE_H_
+#ifndef CHROME_BROWSER_UI_BLUETOOTH_BLUETOOTH_CHOOSER_BUBBLE_CONTROLLER_H_
+#define CHROME_BROWSER_UI_BLUETOOTH_BLUETOOTH_CHOOSER_BUBBLE_CONTROLLER_H_
 
 #include <stddef.h>
 
 #include "base/macros.h"
-#include "chrome/browser/ui/website_settings/chooser_bubble_delegate.h"
+#include "chrome/browser/ui/website_settings/chooser_bubble_controller.h"
 #include "components/bubble/bubble_reference.h"
 
 class BluetoothChooserDesktop;
 
-// BluetoothChooserBubbleDelegate is a chooser that presents a list of
+// BluetoothChooserBubbleController is a chooser that presents a list of
 // Bluetooth device names, which come from |bluetooth_chooser_desktop_|.
 // It can be used by WebBluetooth API to get the user's permission to
 // access a Bluetooth device.
-class BluetoothChooserBubbleDelegate : public ChooserBubbleDelegate {
+class BluetoothChooserBubbleController : public ChooserBubbleController {
  public:
-  explicit BluetoothChooserBubbleDelegate(content::RenderFrameHost* owner);
-  ~BluetoothChooserBubbleDelegate() override;
+  explicit BluetoothChooserBubbleController(content::RenderFrameHost* owner);
+  ~BluetoothChooserBubbleController() override;
 
-  // ChooserBubbleDelegate:
+  // ChooserBubbleController:
   size_t NumOptions() const override;
   const base::string16& GetOption(size_t index) const override;
   void Select(size_t index) override;
@@ -41,17 +41,17 @@ class BluetoothChooserBubbleDelegate : public ChooserBubbleDelegate {
     bluetooth_chooser_ = bluetooth_chooser;
   }
 
-  void set_bubble_controller(BubbleReference bubble_controller) {
-    bubble_controller_ = bubble_controller;
+  void set_bubble_reference(BubbleReference bubble_reference) {
+    bubble_reference_ = bubble_reference;
   }
 
  private:
   // Each pair is a (device name, device id).
   std::vector<std::pair<base::string16, std::string>> device_names_and_ids_;
   BluetoothChooserDesktop* bluetooth_chooser_;
-  BubbleReference bubble_controller_;
+  BubbleReference bubble_reference_;
 
-  DISALLOW_COPY_AND_ASSIGN(BluetoothChooserBubbleDelegate);
+  DISALLOW_COPY_AND_ASSIGN(BluetoothChooserBubbleController);
 };
 
-#endif  // CHROME_BROWSER_UI_BLUETOOTH_BLUETOOTH_CHOOSER_BUBBLE_DELEGATE_H_
+#endif  // CHROME_BROWSER_UI_BLUETOOTH_BLUETOOTH_CHOOSER_BUBBLE_CONTROLLER_H_
diff --git a/chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.cc b/chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.cc
index 91bc638..b014048 100644
--- a/chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.cc
+++ b/chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.cc
@@ -4,16 +4,16 @@
 
 #include "chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.h"
 
-#include "chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_delegate.h"
+#include "chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_controller.h"
 
 BluetoothChooserDesktop::BluetoothChooserDesktop(
     const content::BluetoothChooser::EventHandler& event_handler)
     : event_handler_(event_handler),
-      bluetooth_chooser_bubble_delegate_(nullptr) {}
+      bluetooth_chooser_bubble_controller_(nullptr) {}
 
 BluetoothChooserDesktop::~BluetoothChooserDesktop() {
-  if (bluetooth_chooser_bubble_delegate_)
-    bluetooth_chooser_bubble_delegate_->set_bluetooth_chooser(nullptr);
+  if (bluetooth_chooser_bubble_controller_)
+    bluetooth_chooser_bubble_controller_->set_bluetooth_chooser(nullptr);
 }
 
 void BluetoothChooserDesktop::SetAdapterPresence(AdapterPresence presence) {}
@@ -22,13 +22,13 @@ void BluetoothChooserDesktop::ShowDiscoveryState(DiscoveryState state) {}
 
 void BluetoothChooserDesktop::AddDevice(const std::string& device_id,
                                         const base::string16& device_name) {
-  if (bluetooth_chooser_bubble_delegate_)
-    bluetooth_chooser_bubble_delegate_->AddDevice(device_id, device_name);
+  if (bluetooth_chooser_bubble_controller_)
+    bluetooth_chooser_bubble_controller_->AddDevice(device_id, device_name);
 }
 
 void BluetoothChooserDesktop::RemoveDevice(const std::string& device_id) {
-  if (bluetooth_chooser_bubble_delegate_)
-    bluetooth_chooser_bubble_delegate_->RemoveDevice(device_id);
+  if (bluetooth_chooser_bubble_controller_)
+    bluetooth_chooser_bubble_controller_->RemoveDevice(device_id);
 }
 
 void BluetoothChooserDesktop::CallEventHandler(
diff --git a/chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.h b/chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.h
index 9809640..ccd2817 100644
--- a/chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.h
+++ b/chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.h
@@ -8,7 +8,7 @@
 #include "base/macros.h"
 #include "content/public/browser/bluetooth_chooser.h"
 
-class BluetoothChooserBubbleDelegate;
+class BluetoothChooserBubbleController;
 
 // Represents a Bluetooth chooser to ask the user to select a Bluetooth
 // device from a list of options. This implementation is for desktop.
@@ -26,9 +26,9 @@ class BluetoothChooserDesktop : public content::BluetoothChooser {
                  const base::string16& device_name) override;
   void RemoveDevice(const std::string& device_id) override;
 
-  void set_bluetooth_chooser_bubble_delegate(
-      BluetoothChooserBubbleDelegate* bluetooth_chooser_bubble_delegate) {
-    bluetooth_chooser_bubble_delegate_ = bluetooth_chooser_bubble_delegate;
+  void set_bluetooth_chooser_bubble_controller(
+      BluetoothChooserBubbleController* bluetooth_chooser_bubble_controller) {
+    bluetooth_chooser_bubble_controller_ = bluetooth_chooser_bubble_controller;
   }
 
   // Use this function to call event_handler_.
@@ -37,7 +37,7 @@ class BluetoothChooserDesktop : public content::BluetoothChooser {
 
  private:
   content::BluetoothChooser::EventHandler event_handler_;
-  BluetoothChooserBubbleDelegate* bluetooth_chooser_bubble_delegate_;
+  BluetoothChooserBubbleController* bluetooth_chooser_bubble_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothChooserDesktop);
 };
diff --git a/chrome/browser/ui/browser.cc b/chrome/browser/ui/browser.cc
index ca1fb51..6f94a62 100644
--- a/chrome/browser/ui/browser.cc
+++ b/chrome/browser/ui/browser.cc
@@ -87,7 +87,7 @@
 #include "chrome/browser/translate/chrome_translate_client.h"
 #include "chrome/browser/ui/autofill/chrome_autofill_client.h"
 #include "chrome/browser/ui/blocked_content/popup_blocker_tab_helper.h"
-#include "chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_delegate.h"
+#include "chrome/browser/ui/bluetooth/bluetooth_chooser_bubble_controller.h"
 #include "chrome/browser/ui/bluetooth/bluetooth_chooser_desktop.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 #include "chrome/browser/ui/bookmarks/bookmark_utils.h"
@@ -1421,20 +1421,21 @@ scoped_ptr<content::BluetoothChooser> Browser::RunBluetoothChooser(
     const content::BluetoothChooser::EventHandler& event_handler) {
   scoped_ptr<BluetoothChooserDesktop> bluetooth_chooser_desktop(
       new BluetoothChooserDesktop(event_handler));
-  scoped_ptr<BluetoothChooserBubbleDelegate> bubble_delegate(
-      new BluetoothChooserBubbleDelegate(frame));
-  BluetoothChooserBubbleDelegate* bubble_delegate_ptr = bubble_delegate.get();
+  scoped_ptr<BluetoothChooserBubbleController> bubble_controller(
+      new BluetoothChooserBubbleController(frame));
+  BluetoothChooserBubbleController* bubble_controller_ptr =
+      bubble_controller.get();
 
-  // Wire the ChooserBubbleDelegate to the BluetoothChooser.
-  bluetooth_chooser_desktop->set_bluetooth_chooser_bubble_delegate(
-      bubble_delegate_ptr);
-  bubble_delegate->set_bluetooth_chooser(bluetooth_chooser_desktop.get());
+  // Wire the ChooserBubbleController to the BluetoothChooser.
+  bluetooth_chooser_desktop->set_bluetooth_chooser_bubble_controller(
+      bubble_controller_ptr);
+  bubble_controller->set_bluetooth_chooser(bluetooth_chooser_desktop.get());
 
   Browser* browser = chrome::FindBrowserWithWebContents(
       WebContents::FromRenderFrameHost(frame));
-  BubbleReference bubble_controller =
-      browser->GetBubbleManager()->ShowBubble(std::move(bubble_delegate));
-  bubble_delegate_ptr->set_bubble_controller(bubble_controller);
+  BubbleReference bubble_reference =
+      browser->GetBubbleManager()->ShowBubble(std::move(bubble_controller));
+  bubble_controller_ptr->set_bubble_reference(bubble_reference);
 
   return std::move(bluetooth_chooser_desktop);
 }
diff --git a/chrome/browser/ui/cocoa/website_settings/chooser_bubble_ui_cocoa.h b/chrome/browser/ui/cocoa/website_settings/chooser_bubble_ui_cocoa.h
index f742754..42323af 100644
--- a/chrome/browser/ui/cocoa/website_settings/chooser_bubble_ui_cocoa.h
+++ b/chrome/browser/ui/cocoa/website_settings/chooser_bubble_ui_cocoa.h
@@ -8,21 +8,20 @@
 #import <Cocoa/Cocoa.h>
 
 #include "base/macros.h"
-#include "chrome/browser/ui/website_settings/chooser_bubble_delegate.h"
+#include "chrome/browser/ui/website_settings/chooser_bubble_controller.h"
 #include "components/bubble/bubble_ui.h"
 
 class Browser;
-class ChooserBubbleDelegate;
 @class ChooserBubbleUiController;
 
 // ChooserBubbleUiCocoa implements a chooser-based permission model.
 // It uses |NSTableView| to show a list of options for user to grant
 // permission. It can be used by the WebUSB or WebBluetooth APIs.
 class ChooserBubbleUiCocoa : public BubbleUi,
-                             public ChooserBubbleDelegate::Observer {
+                             public ChooserBubbleController::Observer {
  public:
   ChooserBubbleUiCocoa(Browser* browser,
-                       ChooserBubbleDelegate* chooser_bubble_delegate);
+                       ChooserBubbleController* chooser_bubble_controller);
   ~ChooserBubbleUiCocoa() override;
 
   // BubbleUi:
@@ -30,7 +29,7 @@ class ChooserBubbleUiCocoa : public BubbleUi,
   void Close() override;
   void UpdateAnchorPosition() override;
 
-  // ChooserBubbleDelegate::Observer:
+  // ChooserBubbleController::Observer:
   void OnOptionsInitialized() override;
   void OnOptionAdded(size_t index) override;
   void OnOptionRemoved(size_t index) override;
@@ -39,8 +38,8 @@ class ChooserBubbleUiCocoa : public BubbleUi,
   void OnBubbleClosing();
 
  private:
-  Browser* browser_;                                // Weak.
-  ChooserBubbleDelegate* chooser_bubble_delegate_;  // Weak.
+  Browser* browser_;                                    // Weak.
+  ChooserBubbleController* chooser_bubble_controller_;  // Weak.
   // Cocoa-side chooser bubble UI controller. Weak, as it will close itself.
   ChooserBubbleUiController* chooser_bubble_ui_controller_;
 
diff --git a/chrome/browser/ui/cocoa/website_settings/chooser_bubble_ui_cocoa.mm b/chrome/browser/ui/cocoa/website_settings/chooser_bubble_ui_cocoa.mm
index 7e09ca9..bfae5ba 100644
--- a/chrome/browser/ui/cocoa/website_settings/chooser_bubble_ui_cocoa.mm
+++ b/chrome/browser/ui/cocoa/website_settings/chooser_bubble_ui_cocoa.mm
@@ -24,7 +24,6 @@
 #import "chrome/browser/ui/cocoa/info_bubble_view.h"
 #import "chrome/browser/ui/cocoa/info_bubble_window.h"
 #import "chrome/browser/ui/cocoa/location_bar/location_bar_view_mac.h"
-#include "chrome/browser/ui/website_settings/chooser_bubble_delegate.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "skia/ext/skia_utils_mac.h"
@@ -53,7 +52,7 @@ const CGFloat kVerticalPadding = 10.0f;
 
 }  // namespace
 
-scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
+scoped_ptr<BubbleUi> ChooserBubbleController::BuildBubbleUi() {
   return make_scoped_ptr(new ChooserBubbleUiCocoa(browser_, this));
 }
 
@@ -72,14 +71,15 @@ scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
   base::scoped_nsobject<HyperlinkTextView> message_;
   bool buttonPressed_;
 
-  Browser* browser_;                                // Weak.
-  ChooserBubbleDelegate* chooserBubbleDelegate_;    // Weak.
+  Browser* browser_;                                  // Weak.
+  ChooserBubbleController* chooserBubbleController_;  // Weak.
 }
 
 // Designated initializer.  |browser| and |bridge| must both be non-nil.
 - (id)initWithBrowser:(Browser*)browser
-    initWithChooserBubbleDelegate:(ChooserBubbleDelegate*)chooserBubbleDelegate
-                           bridge:(ChooserBubbleUiCocoa*)bridge;
+    initWithChooserBubbleController:
+        (ChooserBubbleController*)chooserBubbleController
+                             bridge:(ChooserBubbleUiCocoa*)bridge;
 
 // Makes the bubble visible.
 - (void)show;
@@ -140,14 +140,15 @@ scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
 @implementation ChooserBubbleUiController
 
 - (id)initWithBrowser:(Browser*)browser
-    initWithChooserBubbleDelegate:(ChooserBubbleDelegate*)chooserBubbleDelegate
-                           bridge:(ChooserBubbleUiCocoa*)bridge {
+    initWithChooserBubbleController:
+        (ChooserBubbleController*)chooserBubbleController
+                             bridge:(ChooserBubbleUiCocoa*)bridge {
   DCHECK(browser);
-  DCHECK(chooserBubbleDelegate);
+  DCHECK(chooserBubbleController);
   DCHECK(bridge);
 
   browser_ = browser;
-  chooserBubbleDelegate_ = chooserBubbleDelegate;
+  chooserBubbleController_ = chooserBubbleController;
 
   base::scoped_nsobject<InfoBubbleWindow> window([[InfoBubbleWindow alloc]
       initWithContentRect:ui::kWindowSizeDeterminedLater
@@ -178,7 +179,7 @@ scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
                 name:NSWindowDidMoveNotification
               object:nil];
   if (!buttonPressed_)
-    chooserBubbleDelegate_->Close();
+    chooserBubbleController_->Close();
   bridge_->OnBubbleClosing();
   [super windowWillClose:notification];
 }
@@ -335,15 +336,16 @@ scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
 - (NSInteger)numberOfRowsInTableView:(NSTableView*)tableView {
   // When there are no devices, the table contains a message saying there are
   // no devices, so the number of rows is always at least 1.
-  return std::max(static_cast<NSInteger>(chooserBubbleDelegate_->NumOptions()),
-                  static_cast<NSInteger>(1));
+  return std::max(
+      static_cast<NSInteger>(chooserBubbleController_->NumOptions()),
+      static_cast<NSInteger>(1));
 }
 
 - (id)tableView:(NSTableView*)tableView
     objectValueForTableColumn:(NSTableColumn*)tableColumn
                           row:(NSInteger)rowIndex {
   NSInteger num_options =
-      static_cast<NSInteger>(chooserBubbleDelegate_->NumOptions());
+      static_cast<NSInteger>(chooserBubbleController_->NumOptions());
   if (num_options == 0) {
     DCHECK_EQ(0, rowIndex);
     return l10n_util::GetNSString(IDS_CHOOSER_BUBBLE_NO_DEVICES_FOUND_PROMPT);
@@ -352,7 +354,7 @@ scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
   DCHECK_GE(rowIndex, 0);
   DCHECK_LT(rowIndex, num_options);
   return base::SysUTF16ToNSString(
-      chooserBubbleDelegate_->GetOption(static_cast<size_t>(rowIndex)));
+      chooserBubbleController_->GetOption(static_cast<size_t>(rowIndex)));
 }
 
 - (BOOL)tableView:(NSTableView*)aTableView
@@ -380,7 +382,7 @@ scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
 }
 
 - (void)updateTableView {
-  [tableView_ setEnabled:chooserBubbleDelegate_->NumOptions() > 0];
+  [tableView_ setEnabled:chooserBubbleController_->NumOptions() > 0];
   [tableView_ reloadData];
 }
 
@@ -473,11 +475,12 @@ scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
 
   NSColor* linkColor =
       skia::SkColorToCalibratedNSColor(chrome_style::GetLinkColor());
-  [textView addLinkRange:NSMakeRange([text length] - linkString.size(),
-                                     linkString.size())
-                 withURL:base::SysUTF8ToNSString(
-                             chooserBubbleDelegate_->GetHelpCenterUrl().spec())
-               linkColor:linkColor];
+  [textView
+      addLinkRange:NSMakeRange([text length] - linkString.size(),
+                               linkString.size())
+           withURL:base::SysUTF8ToNSString(
+                       chooserBubbleController_->GetHelpCenterUrl().spec())
+         linkColor:linkColor];
 
   // Removes the underlining from the link.
   NSTextStorage* textStorage = [textView textStorage];
@@ -513,13 +516,13 @@ scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
 - (void)onConnect:(id)sender {
   buttonPressed_ = true;
   NSInteger row = [tableView_ selectedRow];
-  chooserBubbleDelegate_->Select(row);
+  chooserBubbleController_->Select(row);
   [self close];
 }
 
 - (void)onCancel:(id)sender {
   buttonPressed_ = true;
-  chooserBubbleDelegate_->Cancel();
+  chooserBubbleController_->Cancel();
   [self close];
 }
 
@@ -527,17 +530,17 @@ scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
 
 ChooserBubbleUiCocoa::ChooserBubbleUiCocoa(
     Browser* browser,
-    ChooserBubbleDelegate* chooser_bubble_delegate)
+    ChooserBubbleController* chooser_bubble_controller)
     : browser_(browser),
-      chooser_bubble_delegate_(chooser_bubble_delegate),
+      chooser_bubble_controller_(chooser_bubble_controller),
       chooser_bubble_ui_controller_(nil) {
   DCHECK(browser);
-  DCHECK(chooser_bubble_delegate);
-  chooser_bubble_delegate_->set_observer(this);
+  DCHECK(chooser_bubble_controller);
+  chooser_bubble_controller_->set_observer(this);
 }
 
 ChooserBubbleUiCocoa::~ChooserBubbleUiCocoa() {
-  chooser_bubble_delegate_->set_observer(nullptr);
+  chooser_bubble_controller_->set_observer(nullptr);
   [chooser_bubble_ui_controller_ close];
   chooser_bubble_ui_controller_ = nil;
 }
@@ -545,9 +548,9 @@ ChooserBubbleUiCocoa::~ChooserBubbleUiCocoa() {
 void ChooserBubbleUiCocoa::Show(BubbleReference bubble_reference) {
   if (!chooser_bubble_ui_controller_) {
     chooser_bubble_ui_controller_ = [[ChooserBubbleUiController alloc]
-                      initWithBrowser:browser_
-        initWithChooserBubbleDelegate:chooser_bubble_delegate_
-                               bridge:this];
+                        initWithBrowser:browser_
+        initWithChooserBubbleController:chooser_bubble_controller_
+                                 bridge:this];
   }
 
   [chooser_bubble_ui_controller_ show];
diff --git a/chrome/browser/ui/views/website_settings/chooser_bubble_ui_view.cc b/chrome/browser/ui/views/website_settings/chooser_bubble_ui_view.cc
index b69e4c9..23a8991 100644
--- a/chrome/browser/ui/views/website_settings/chooser_bubble_ui_view.cc
+++ b/chrome/browser/ui/views/website_settings/chooser_bubble_ui_view.cc
@@ -19,7 +19,7 @@
 #include "chrome/browser/ui/views/frame/top_container_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/website_settings/chooser_bubble_delegate.h"
+#include "chrome/browser/ui/website_settings/chooser_bubble_controller.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/prefs/pref_service.h"
@@ -52,7 +52,7 @@ const int kChooserPermissionBubbleHeight = 200;
 
 }  // namespace
 
-scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
+scoped_ptr<BubbleUi> ChooserBubbleController::BuildBubbleUi() {
   return make_scoped_ptr(new ChooserBubbleUiView(browser_, this));
 }
 
@@ -68,7 +68,7 @@ class ChooserBubbleUiViewDelegate : public views::BubbleDelegateView,
   ChooserBubbleUiViewDelegate(views::View* anchor_view,
                               views::BubbleBorder::Arrow anchor_arrow,
                               ChooserBubbleUiView* owner,
-                              ChooserBubbleDelegate* chooser_bubble_delegate);
+                              ChooserBubbleController* controller);
   ~ChooserBubbleUiViewDelegate() override;
 
   void Close();
@@ -98,7 +98,7 @@ class ChooserBubbleUiViewDelegate : public views::BubbleDelegateView,
   friend ChooserBubbleUiView;
 
   ChooserBubbleUiView* owner_;
-  ChooserBubbleDelegate* chooser_bubble_delegate_;
+  ChooserBubbleController* controller_;
 
   views::LabelButton* connect_button_;
   views::TableView* table_view_;
@@ -116,16 +116,16 @@ ui::TableColumn ChooserTableColumn(int id, const std::string& title) {
 }
 
 class ChooserTableModel : public ui::TableModel,
-                          public ChooserBubbleDelegate::Observer {
+                          public ChooserBubbleController::Observer {
  public:
-  explicit ChooserTableModel(ChooserBubbleDelegate* chooser_bubble_delegate);
+  explicit ChooserTableModel(ChooserBubbleController* controller);
 
   // ui::TableModel:
   int RowCount() override;
   base::string16 GetText(int row, int column_id) override;
   void SetObserver(ui::TableModelObserver* observer) override;
 
-  // ChooserBubbleDelegate::Observer:
+  // ChooserBubbleController::Observer:
   void OnOptionsInitialized() override;
   void OnOptionAdded(size_t index) override;
   void OnOptionRemoved(size_t index) override;
@@ -135,7 +135,7 @@ class ChooserTableModel : public ui::TableModel,
 
  private:
   ui::TableModelObserver* observer_;
-  ChooserBubbleDelegate* chooser_bubble_delegate_;
+  ChooserBubbleController* controller_;
   views::LabelButton* connect_button_;
 };
 
@@ -143,10 +143,10 @@ ChooserBubbleUiViewDelegate::ChooserBubbleUiViewDelegate(
     views::View* anchor_view,
     views::BubbleBorder::Arrow anchor_arrow,
     ChooserBubbleUiView* owner,
-    ChooserBubbleDelegate* chooser_bubble_delegate)
+    ChooserBubbleController* controller)
     : views::BubbleDelegateView(anchor_view, anchor_arrow),
       owner_(owner),
-      chooser_bubble_delegate_(chooser_bubble_delegate),
+      controller_(controller),
       button_pressed_(false) {
   // TODO(juncai): try using DialogClientView to build the chooser UI view since
   // they look similar.
@@ -178,13 +178,13 @@ ChooserBubbleUiViewDelegate::ChooserBubbleUiViewDelegate(
   std::vector<ui::TableColumn> table_columns;
   table_columns.push_back(ChooserTableColumn(
       0, "" /* Empty string makes the column title invisible */));
-  chooser_table_model_ = new ChooserTableModel(chooser_bubble_delegate_);
+  chooser_table_model_ = new ChooserTableModel(controller_);
   table_view_ = new views::TableView(chooser_table_model_, table_columns,
                                      views::TEXT_ONLY, true);
   table_view_->set_select_on_remove(false);
   chooser_table_model_->SetObserver(table_view_);
   table_view_->SetObserver(this);
-  table_view_->SetEnabled(chooser_bubble_delegate_->NumOptions() > 0);
+  table_view_->SetEnabled(controller_->NumOptions() > 0);
   layout->AddView(table_view_->CreateParentIfNecessary(), 1, 1,
                   views::GridLayout::FILL, views::GridLayout::FILL,
                   kChooserPermissionBubbleWidth,
@@ -247,7 +247,7 @@ ChooserBubbleUiViewDelegate::~ChooserBubbleUiViewDelegate() {
 
 void ChooserBubbleUiViewDelegate::Close() {
   if (!button_pressed_)
-    chooser_bubble_delegate_->Close();
+    controller_->Close();
   owner_ = nullptr;
   GetWidget()->Close();
 }
@@ -273,9 +273,9 @@ void ChooserBubbleUiViewDelegate::ButtonPressed(views::Button* button,
   button_pressed_ = true;
 
   if (button == connect_button_)
-    chooser_bubble_delegate_->Select(table_view_->selection_model().active());
+    controller_->Select(table_view_->selection_model().active());
   else
-    chooser_bubble_delegate_->Cancel();
+    controller_->Cancel();
 
   if (owner_) {
     owner_->Close();
@@ -287,7 +287,7 @@ void ChooserBubbleUiViewDelegate::StyledLabelLinkClicked(
     views::StyledLabel* label,
     const gfx::Range& range,
     int event_flags) {
-  chooser_bubble_delegate_->OpenHelpCenterUrl();
+  controller_->OpenHelpCenterUrl();
 }
 
 void ChooserBubbleUiViewDelegate::OnSelectionChanged() {
@@ -315,20 +315,19 @@ void ChooserBubbleUiViewDelegate::UpdateAnchor(
   SetAnchorView(anchor_view);
 }
 
-ChooserTableModel::ChooserTableModel(
-    ChooserBubbleDelegate* chooser_bubble_delegate)
-    : observer_(nullptr), chooser_bubble_delegate_(chooser_bubble_delegate) {
-  chooser_bubble_delegate_->set_observer(this);
+ChooserTableModel::ChooserTableModel(ChooserBubbleController* controller)
+    : observer_(nullptr), controller_(controller) {
+  controller_->set_observer(this);
 }
 
 int ChooserTableModel::RowCount() {
   // When there are no devices, the table contains a message saying there
   // are no devices, so the number of rows is always at least 1.
-  return std::max(static_cast<int>(chooser_bubble_delegate_->NumOptions()), 1);
+  return std::max(static_cast<int>(controller_->NumOptions()), 1);
 }
 
 base::string16 ChooserTableModel::GetText(int row, int column_id) {
-  int num_options = static_cast<int>(chooser_bubble_delegate_->NumOptions());
+  int num_options = static_cast<int>(controller_->NumOptions());
   if (num_options == 0) {
     DCHECK_EQ(0, row);
     return l10n_util::GetStringUTF16(
@@ -337,7 +336,7 @@ base::string16 ChooserTableModel::GetText(int row, int column_id) {
 
   DCHECK_GE(row, 0);
   DCHECK_LT(row, num_options);
-  return chooser_bubble_delegate_->GetOption(static_cast<size_t>(row));
+  return controller_->GetOption(static_cast<size_t>(row));
 }
 
 void ChooserTableModel::SetObserver(ui::TableModelObserver* observer) {
@@ -368,7 +367,7 @@ void ChooserTableModel::OnOptionRemoved(size_t index) {
 void ChooserTableModel::Update() {
   views::TableView* table_view = static_cast<views::TableView*>(observer_);
 
-  if (chooser_bubble_delegate_->NumOptions() == 0) {
+  if (controller_->NumOptions() == 0) {
     observer_->OnModelChanged();
     table_view->SetEnabled(false);
   } else {
@@ -383,21 +382,20 @@ void ChooserTableModel::SetConnectButton(views::LabelButton* connect_button) {
 //////////////////////////////////////////////////////////////////////////////
 // ChooserBubbleUiView
 
-ChooserBubbleUiView::ChooserBubbleUiView(
-    Browser* browser,
-    ChooserBubbleDelegate* chooser_bubble_delegate)
+ChooserBubbleUiView::ChooserBubbleUiView(Browser* browser,
+                                         ChooserBubbleController* controller)
     : browser_(browser),
-      chooser_bubble_delegate_(chooser_bubble_delegate),
+      controller_(controller),
       chooser_bubble_ui_view_delegate_(nullptr) {
   DCHECK(browser_);
-  DCHECK(chooser_bubble_delegate_);
+  DCHECK(controller_);
 }
 
 ChooserBubbleUiView::~ChooserBubbleUiView() {}
 
 void ChooserBubbleUiView::Show(BubbleReference bubble_reference) {
   chooser_bubble_ui_view_delegate_ = new ChooserBubbleUiViewDelegate(
-      GetAnchorView(), GetAnchorArrow(), this, chooser_bubble_delegate_);
+      GetAnchorView(), GetAnchorArrow(), this, controller_);
 
   // Set |parent_window| because some valid anchors can become hidden.
   views::Widget* widget = views::Widget::GetWidgetForNativeWindow(
diff --git a/chrome/browser/ui/views/website_settings/chooser_bubble_ui_view.h b/chrome/browser/ui/views/website_settings/chooser_bubble_ui_view.h
index 72a71b6..b3d7241 100644
--- a/chrome/browser/ui/views/website_settings/chooser_bubble_ui_view.h
+++ b/chrome/browser/ui/views/website_settings/chooser_bubble_ui_view.h
@@ -13,7 +13,7 @@ class View;
 }
 
 class Browser;
-class ChooserBubbleDelegate;
+class ChooserBubbleController;
 class ChooserBubbleUiViewDelegate;
 
 // ChooserBubbleUiView implements a chooser-based permission model,
@@ -21,8 +21,7 @@ class ChooserBubbleUiViewDelegate;
 // for user to grant permission. It can be used by WebUsb, WebBluetooth.
 class ChooserBubbleUiView : public BubbleUi {
  public:
-  ChooserBubbleUiView(Browser* browser,
-                      ChooserBubbleDelegate* chooser_bubble_delegate);
+  ChooserBubbleUiView(Browser* browser, ChooserBubbleController* controller);
   ~ChooserBubbleUiView() override;
 
   // BubbleUi:
@@ -36,7 +35,7 @@ class ChooserBubbleUiView : public BubbleUi {
   views::BubbleBorder::Arrow GetAnchorArrow();
 
   Browser* browser_;
-  ChooserBubbleDelegate* chooser_bubble_delegate_;
+  ChooserBubbleController* controller_;
   ChooserBubbleUiViewDelegate* chooser_bubble_ui_view_delegate_;
 };
 
diff --git a/chrome/browser/ui/website_settings/chooser_bubble_delegate.cc b/chrome/browser/ui/website_settings/chooser_bubble_controller.cc
index 7622b5d..05113f0 100644
--- a/chrome/browser/ui/website_settings/chooser_bubble_delegate.cc
+++ b/chrome/browser/ui/website_settings/chooser_bubble_controller.cc
@@ -2,28 +2,30 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "chrome/browser/ui/website_settings/chooser_bubble_controller.h"
+
 #include "chrome/browser/net/referrer.h"
 #include "chrome/browser/ui/browser_finder.h"
-#include "chrome/browser/ui/website_settings/chooser_bubble_delegate.h"
 #include "content/public/browser/web_contents.h"
 
-ChooserBubbleDelegate::ChooserBubbleDelegate(content::RenderFrameHost* owner)
+ChooserBubbleController::ChooserBubbleController(
+    content::RenderFrameHost* owner)
     : browser_(chrome::FindBrowserWithWebContents(
           content::WebContents::FromRenderFrameHost(owner))),
       owning_frame_(owner) {}
 
-ChooserBubbleDelegate::~ChooserBubbleDelegate() {}
+ChooserBubbleController::~ChooserBubbleController() {}
 
-void ChooserBubbleDelegate::OpenHelpCenterUrl() const {
+void ChooserBubbleController::OpenHelpCenterUrl() const {
   browser_->OpenURL(content::OpenURLParams(
       GetHelpCenterUrl(), content::Referrer(), NEW_FOREGROUND_TAB,
       ui::PAGE_TRANSITION_AUTO_TOPLEVEL, false /* is_renderer_initiated */));
 }
 
-std::string ChooserBubbleDelegate::GetName() const {
+std::string ChooserBubbleController::GetName() const {
   return "ChooserBubble";
 }
 
-const content::RenderFrameHost* ChooserBubbleDelegate::OwningFrame() const {
+const content::RenderFrameHost* ChooserBubbleController::OwningFrame() const {
   return owning_frame_;
 }
diff --git a/chrome/browser/ui/website_settings/chooser_bubble_delegate.h b/chrome/browser/ui/website_settings/chooser_bubble_controller.h
index 93afa89..238b57d 100644
--- a/chrome/browser/ui/website_settings/chooser_bubble_delegate.h
+++ b/chrome/browser/ui/website_settings/chooser_bubble_controller.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_UI_WEBSITE_SETTINGS_CHOOSER_BUBBLE_DELEGATE_H_
-#define CHROME_BROWSER_UI_WEBSITE_SETTINGS_CHOOSER_BUBBLE_DELEGATE_H_
+#ifndef CHROME_BROWSER_UI_WEBSITE_SETTINGS_CHOOSER_BUBBLE_CONTROLLER_H_
+#define CHROME_BROWSER_UI_WEBSITE_SETTINGS_CHOOSER_BUBBLE_CONTROLLER_H_
 
 #include <vector>
 
@@ -14,7 +14,7 @@
 class Browser;
 class GURL;
 
-// Subclass ChooserBubbleDelegate to implement a chooser bubble, which has
+// Subclass ChooserBubbleController to implement a chooser bubble, which has
 // some introductory text and a list of options that users can pick one of.
 // Create an instance of your subclass and pass it to
 // BubbleManager::ShowBubble() to show the bubble. Your subclass must define
@@ -24,14 +24,10 @@ class GURL;
 // collecting metrics.
 // After Select/Cancel/Close is called, this object is destroyed and call back
 // into it is not allowed.
-// TODO(juncai): Change class name ChooserBubbleDelegate to
-// ChooserBubbleController since it better reflects its responsibilities and
-// clarifies the roles of this class.
-// https://crbug.com/588933
-class ChooserBubbleDelegate : public BubbleDelegate {
+class ChooserBubbleController : public BubbleDelegate {
  public:
-  explicit ChooserBubbleDelegate(content::RenderFrameHost* owner);
-  ~ChooserBubbleDelegate() override;
+  explicit ChooserBubbleController(content::RenderFrameHost* owner);
+  ~ChooserBubbleController() override;
 
   // Since the set of options can change while the UI is visible an
   // implementation should register an observer.
@@ -97,7 +93,7 @@ class ChooserBubbleDelegate : public BubbleDelegate {
   const content::RenderFrameHost* const owning_frame_;
   Observer* observer_ = nullptr;
 
-  DISALLOW_COPY_AND_ASSIGN(ChooserBubbleDelegate);
+  DISALLOW_COPY_AND_ASSIGN(ChooserBubbleController);
 };
 
-#endif  // CHROME_BROWSER_UI_WEBSITE_SETTINGS_CHOOSER_BUBBLE_DELEGATE_H_
+#endif  // CHROME_BROWSER_UI_WEBSITE_SETTINGS_CHOOSER_BUBBLE_CONTROLLER_H_
diff --git a/chrome/browser/usb/usb_chooser_bubble_delegate.cc b/chrome/browser/usb/usb_chooser_bubble_controller.cc
index 026641d..b4cce8f 100644
--- a/chrome/browser/usb/usb_chooser_bubble_delegate.cc
+++ b/chrome/browser/usb/usb_chooser_bubble_controller.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/usb/usb_chooser_bubble_delegate.h"
+#include "chrome/browser/usb/usb_chooser_bubble_controller.h"
 
 #include <stddef.h>
 #include <utility>
@@ -73,12 +73,12 @@ bool FindInAllowedOrigins(const device::WebUsbAllowedOrigins* allowed_origins,
 
 }  // namespace
 
-UsbChooserBubbleDelegate::UsbChooserBubbleDelegate(
+UsbChooserBubbleController::UsbChooserBubbleController(
     content::RenderFrameHost* owner,
     mojo::Array<device::usb::DeviceFilterPtr> device_filters,
     content::RenderFrameHost* render_frame_host,
     const webusb::WebUsbPermissionBubble::GetPermissionCallback& callback)
-    : ChooserBubbleDelegate(owner),
+    : ChooserBubbleController(owner),
       render_frame_host_(render_frame_host),
       callback_(callback),
       usb_service_observer_(this),
@@ -94,25 +94,27 @@ UsbChooserBubbleDelegate::UsbChooserBubbleDelegate(
   if (!device_filters.is_null())
     filters_ = device_filters.To<std::vector<device::UsbDeviceFilter>>();
 
-  usb_service->GetDevices(base::Bind(
-      &UsbChooserBubbleDelegate::GotUsbDeviceList, weak_factory_.GetWeakPtr()));
+  usb_service->GetDevices(
+      base::Bind(&UsbChooserBubbleController::GotUsbDeviceList,
+                 weak_factory_.GetWeakPtr()));
 }
 
-UsbChooserBubbleDelegate::~UsbChooserBubbleDelegate() {
+UsbChooserBubbleController::~UsbChooserBubbleController() {
   if (!callback_.is_null())
     callback_.Run(nullptr);
 }
 
-size_t UsbChooserBubbleDelegate::NumOptions() const {
+size_t UsbChooserBubbleController::NumOptions() const {
   return devices_.size();
 }
 
-const base::string16& UsbChooserBubbleDelegate::GetOption(size_t index) const {
+const base::string16& UsbChooserBubbleController::GetOption(
+    size_t index) const {
   DCHECK_LT(index, devices_.size());
   return devices_[index].second;
 }
 
-void UsbChooserBubbleDelegate::Select(size_t index) {
+void UsbChooserBubbleController::Select(size_t index) {
   DCHECK_LT(index, devices_.size());
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host_);
@@ -135,22 +137,22 @@ void UsbChooserBubbleDelegate::Select(size_t index) {
                            ? WEBUSB_CHOOSER_CLOSED_EPHEMERAL_PERMISSION_GRANTED
                            : WEBUSB_CHOOSER_CLOSED_PERMISSION_GRANTED);
 
-  if (bubble_controller_)
-    bubble_controller_->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
+  if (bubble_reference_)
+    bubble_reference_->CloseBubble(BUBBLE_CLOSE_ACCEPTED);
 }
 
-void UsbChooserBubbleDelegate::Cancel() {
+void UsbChooserBubbleController::Cancel() {
   RecordChooserClosure(devices_.size() == 0
                            ? WEBUSB_CHOOSER_CLOSED_CANCELLED_NO_DEVICES
                            : WEBUSB_CHOOSER_CLOSED_CANCELLED);
 
-  if (bubble_controller_)
-    bubble_controller_->CloseBubble(BUBBLE_CLOSE_CANCELED);
+  if (bubble_reference_)
+    bubble_reference_->CloseBubble(BUBBLE_CLOSE_CANCELED);
 }
 
-void UsbChooserBubbleDelegate::Close() {}
+void UsbChooserBubbleController::Close() {}
 
-void UsbChooserBubbleDelegate::OnDeviceAdded(
+void UsbChooserBubbleController::OnDeviceAdded(
     scoped_refptr<device::UsbDevice> device) {
   if (device::UsbDeviceFilter::MatchesAny(device, filters_) &&
       FindInAllowedOrigins(
@@ -162,11 +164,11 @@ void UsbChooserBubbleDelegate::OnDeviceAdded(
   }
 }
 
-GURL UsbChooserBubbleDelegate::GetHelpCenterUrl() const {
+GURL UsbChooserBubbleController::GetHelpCenterUrl() const {
   return GURL(chrome::kChooserUsbOverviewURL);
 }
 
-void UsbChooserBubbleDelegate::OnDeviceRemoved(
+void UsbChooserBubbleController::OnDeviceRemoved(
     scoped_refptr<device::UsbDevice> device) {
   for (auto it = devices_.begin(); it != devices_.end(); ++it) {
     if (it->first == device) {
@@ -181,7 +183,7 @@ void UsbChooserBubbleDelegate::OnDeviceRemoved(
 
 // Get a list of devices that can be shown in the chooser bubble UI for
 // user to grant permsssion.
-void UsbChooserBubbleDelegate::GotUsbDeviceList(
+void UsbChooserBubbleController::GotUsbDeviceList(
     const std::vector<scoped_refptr<device::UsbDevice>>& devices) {
   for (const auto& device : devices) {
     if (device::UsbDeviceFilter::MatchesAny(device, filters_) &&
@@ -195,7 +197,7 @@ void UsbChooserBubbleDelegate::GotUsbDeviceList(
     observer()->OnOptionsInitialized();
 }
 
-void UsbChooserBubbleDelegate::set_bubble_controller(
-    BubbleReference bubble_controller) {
-  bubble_controller_ = bubble_controller;
+void UsbChooserBubbleController::set_bubble_reference(
+    BubbleReference bubble_reference) {
+  bubble_reference_ = bubble_reference;
 }
diff --git a/chrome/browser/usb/usb_chooser_bubble_delegate.h b/chrome/browser/usb/usb_chooser_bubble_controller.h
index 4921b0f..6de8fb0 100644
--- a/chrome/browser/usb/usb_chooser_bubble_delegate.h
+++ b/chrome/browser/usb/usb_chooser_bubble_controller.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_USB_USB_CHOOSER_BUBBLE_DELEGATE_H_
-#define CHROME_BROWSER_USB_USB_CHOOSER_BUBBLE_DELEGATE_H_
+#ifndef CHROME_BROWSER_USB_USB_CHOOSER_BUBBLE_CONTROLLER_H_
+#define CHROME_BROWSER_USB_USB_CHOOSER_BUBBLE_CONTROLLER_H_
 
 #include <utility>
 
@@ -11,7 +11,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
-#include "chrome/browser/ui/website_settings/chooser_bubble_delegate.h"
+#include "chrome/browser/ui/website_settings/chooser_bubble_controller.h"
 #include "components/bubble/bubble_reference.h"
 #include "components/webusb/public/interfaces/webusb_permission_bubble.mojom.h"
 #include "device/usb/usb_service.h"
@@ -26,18 +26,18 @@ class UsbDevice;
 class UsbDeviceFilter;
 }
 
-// UsbChooserBubbleDelegate creates a chooser bubble for WebUsb.
-class UsbChooserBubbleDelegate : public ChooserBubbleDelegate,
-                                 public device::UsbService::Observer {
+// UsbChooserBubbleController creates a chooser bubble for WebUsb.
+class UsbChooserBubbleController : public ChooserBubbleController,
+                                   public device::UsbService::Observer {
  public:
-  UsbChooserBubbleDelegate(
+  UsbChooserBubbleController(
       content::RenderFrameHost* owner,
       mojo::Array<device::usb::DeviceFilterPtr> device_filters,
       content::RenderFrameHost* render_frame_host,
       const webusb::WebUsbPermissionBubble::GetPermissionCallback& callback);
-  ~UsbChooserBubbleDelegate() override;
+  ~UsbChooserBubbleController() override;
 
-  // ChooserBubbleDelegate:
+  // ChooserBubbleController:
   size_t NumOptions() const override;
   const base::string16& GetOption(size_t index) const override;
   void Select(size_t index) override;
@@ -52,7 +52,7 @@ class UsbChooserBubbleDelegate : public ChooserBubbleDelegate,
   void GotUsbDeviceList(
       const std::vector<scoped_refptr<device::UsbDevice>>& devices);
 
-  void set_bubble_controller(BubbleReference bubble_controller);
+  void set_bubble_reference(BubbleReference bubble_reference);
 
  private:
   content::RenderFrameHost* const render_frame_host_;
@@ -63,10 +63,10 @@ class UsbChooserBubbleDelegate : public ChooserBubbleDelegate,
   // Each pair is a (device, device name).
   std::vector<std::pair<scoped_refptr<device::UsbDevice>, base::string16>>
       devices_;
-  BubbleReference bubble_controller_;
-  base::WeakPtrFactory<UsbChooserBubbleDelegate> weak_factory_;
+  BubbleReference bubble_reference_;
+  base::WeakPtrFactory<UsbChooserBubbleController> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(UsbChooserBubbleDelegate);
+  DISALLOW_COPY_AND_ASSIGN(UsbChooserBubbleController);
 };
 
-#endif  // CHROME_BROWSER_USB_USB_CHOOSER_BUBBLE_DELEGATE_H_
+#endif  // CHROME_BROWSER_USB_USB_CHOOSER_BUBBLE_CONTROLLER_H_
diff --git a/chrome/browser/usb/web_usb_permission_bubble.cc b/chrome/browser/usb/web_usb_permission_bubble.cc
index 6ba7d26..8b6b7d1 100644
--- a/chrome/browser/usb/web_usb_permission_bubble.cc
+++ b/chrome/browser/usb/web_usb_permission_bubble.cc
@@ -8,7 +8,7 @@
 
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/chrome_bubble_manager.h"
-#include "chrome/browser/usb/usb_chooser_bubble_delegate.h"
+#include "chrome/browser/usb/usb_chooser_bubble_controller.h"
 #include "components/bubble/bubble_controller.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
@@ -33,15 +33,15 @@ void ChromeWebUsbPermissionBubble::GetPermission(
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host_);
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
-  scoped_ptr<UsbChooserBubbleDelegate> bubble_delegate(
-      new UsbChooserBubbleDelegate(render_frame_host_,
-                                   std::move(device_filters),
-                                   render_frame_host_, callback));
-  UsbChooserBubbleDelegate* bubble_delegate_ptr = bubble_delegate.get();
-  BubbleReference bubble_controller =
-      browser->GetBubbleManager()->ShowBubble(std::move(bubble_delegate));
-  bubble_delegate_ptr->set_bubble_controller(bubble_controller);
-  bubbles_.push_back(bubble_controller);
+  scoped_ptr<UsbChooserBubbleController> bubble_controller(
+      new UsbChooserBubbleController(render_frame_host_,
+                                     std::move(device_filters),
+                                     render_frame_host_, callback));
+  UsbChooserBubbleController* bubble_controller_ptr = bubble_controller.get();
+  BubbleReference bubble_reference =
+      browser->GetBubbleManager()->ShowBubble(std::move(bubble_controller));
+  bubble_controller_ptr->set_bubble_reference(bubble_reference);
+  bubbles_.push_back(bubble_reference);
 }
 
 void ChromeWebUsbPermissionBubble::Bind(
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index e0efbf2..ea5fb38 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -1388,8 +1388,8 @@
       'browser/tracing/chrome_tracing_delegate.h',
       'browser/upgrade_detector.cc',
       'browser/upgrade_detector.h',
-      'browser/usb/usb_chooser_bubble_delegate.cc',
-      'browser/usb/usb_chooser_bubble_delegate.h',
+      'browser/usb/usb_chooser_bubble_controller.cc',
+      'browser/usb/usb_chooser_bubble_controller.h',
       'browser/usb/web_usb_permission_bubble.cc',
       'browser/usb/web_usb_permission_bubble.h',
     ],
diff --git a/chrome/chrome_browser_ui.gypi b/chrome/chrome_browser_ui.gypi
index 89978e91b..180dc22 100644
--- a/chrome/chrome_browser_ui.gypi
+++ b/chrome/chrome_browser_ui.gypi
@@ -1529,8 +1529,8 @@
       'browser/ui/autofill/new_credit_card_bubble_view.h',
       'browser/ui/blocked_content/app_modal_dialog_helper.cc',
       'browser/ui/blocked_content/app_modal_dialog_helper.h',
-      'browser/ui/bluetooth/bluetooth_chooser_bubble_delegate.cc',
-      'browser/ui/bluetooth/bluetooth_chooser_bubble_delegate.h',
+      'browser/ui/bluetooth/bluetooth_chooser_bubble_controller.cc',
+      'browser/ui/bluetooth/bluetooth_chooser_bubble_controller.h',
       'browser/ui/bluetooth/bluetooth_chooser_desktop.cc',
       'browser/ui/bluetooth/bluetooth_chooser_desktop.h',
       'browser/ui/bookmarks/bookmark_bubble_sign_in_delegate.cc',
@@ -1799,8 +1799,8 @@
       'browser/ui/unload_controller.h',
       'browser/ui/user_manager.cc',
       'browser/ui/user_manager.h',
-      'browser/ui/website_settings/chooser_bubble_delegate.cc',
-      'browser/ui/website_settings/chooser_bubble_delegate.h',
+      'browser/ui/website_settings/chooser_bubble_controller.cc',
+      'browser/ui/website_settings/chooser_bubble_controller.h',
       'browser/ui/website_settings/permission_bubble_manager.cc',
       'browser/ui/website_settings/permission_bubble_manager.h',
       'browser/ui/website_settings/permission_bubble_view.h',