Change ChooserBubbleDelegate class name to ChooserBubbleController

chrome/browser/ui/views/website_settings/chooser_bubble_ui_view.cc

 // Copyright 2015 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/website_settings/chooser_bubble_ui_view.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/views/exclusive_access_bubble_views.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #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"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/gfx/vector_icons_public.h"
 #include "ui/views/bubble/bubble_delegate.h"
@@ skipping 12 matching lines @@
 namespace {
 
 // Chooser permission bubble width
 const int kChooserPermissionBubbleWidth = 300;
 
 // Chooser permission bubble height
 const int kChooserPermissionBubbleHeight = 200;
 
 }  // namespace
 
-scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
+scoped_ptr<BubbleUi> ChooserBubbleController::BuildBubbleUi() {
   return make_scoped_ptr(new ChooserBubbleUiView(browser_, this));
 }
 
 class ChooserTableModel;
 
 ///////////////////////////////////////////////////////////////////////////////
 // View implementation for the chooser bubble.
 class ChooserBubbleUiViewDelegate : public views::BubbleDelegateView,
                                     public views::ButtonListener,
                                     public views::StyledLabelListener,
                                     public views::TableViewObserver {
  public:
   ChooserBubbleUiViewDelegate(views::View* anchor_view,
                               views::BubbleBorder::Arrow anchor_arrow,
                               ChooserBubbleUiView* owner,
-                              ChooserBubbleDelegate* chooser_bubble_delegate);
+                              ChooserBubbleController* controller);
   ~ChooserBubbleUiViewDelegate() override;
 
   void Close();
 
   // views::BubbleDelegateView:
   bool ShouldShowWindowTitle() const override;
   base::string16 GetWindowTitle() const override;
   void OnWidgetDestroying(views::Widget* widget) override;
 
   // views::ButtonListener:
   void ButtonPressed(views::Button* button, const ui::Event& event) override;
 
   // views::StyledLabelListener:
   void StyledLabelLinkClicked(views::StyledLabel* label,
                               const gfx::Range& range,
                               int event_flags) override;
 
   // views::TableViewObserver:
   void OnSelectionChanged() override;
 
   // Updates the anchor's arrow and view. Also repositions the bubble so it's
   // displayed in the correct location.
   void UpdateAnchor(views::View* anchor_view,
                     views::BubbleBorder::Arrow anchor_arrow);
 
  private:
   friend ChooserBubbleUiView;
 
   ChooserBubbleUiView* owner_;
-  ChooserBubbleDelegate* chooser_bubble_delegate_;
+  ChooserBubbleController* controller_;
 
   views::LabelButton* connect_button_;
   views::TableView* table_view_;
   ChooserTableModel* chooser_table_model_;
   bool button_pressed_;
 
   DISALLOW_COPY_AND_ASSIGN(ChooserBubbleUiViewDelegate);
 };
 
 ui::TableColumn ChooserTableColumn(int id, const std::string& title) {
   ui::TableColumn column;
   column.id = id;
   column.title = base::ASCIIToUTF16(title.c_str());
   return column;
 }
 
 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;
 
   void Update();
   void SetConnectButton(views::LabelButton* connect_button);
 
  private:
   ui::TableModelObserver* observer_;
-  ChooserBubbleDelegate* chooser_bubble_delegate_;
+  ChooserBubbleController* controller_;
   views::LabelButton* connect_button_;
 };
 
 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.
   // https://crbug.com/587545
   // ------------------------------------
   // | Chooser bubble title             |
   // | -------------------------------- |
   // | | option 0                     | |
   // | | option 1                     | |
   // | | option 2                     | |
@@ skipping 11 matching lines @@
 
   views::ColumnSet* column_set = layout->AddColumnSet(0);
   column_set->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1,
                         views::GridLayout::USE_PREF, 0, 0);
 
   // Lay out the table view.
   layout->StartRow(0, 0);
   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,
                   kChooserPermissionBubbleHeight);
 
   layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
 
   // Lay out the Connect/Cancel buttons.
   layout->StartRow(0, 0);
   views::View* button_row = new views::View();
@@ skipping 42 matching lines @@
 
 ChooserBubbleUiViewDelegate::~ChooserBubbleUiViewDelegate() {
   RemoveAllChildViews(true);
   if (owner_)
     owner_->Close();
   chooser_table_model_->SetObserver(nullptr);
 }
 
 void ChooserBubbleUiViewDelegate::Close() {
   if (!button_pressed_)
-    chooser_bubble_delegate_->Close();
+    controller_->Close();
   owner_ = nullptr;
   GetWidget()->Close();
 }
 
 bool ChooserBubbleUiViewDelegate::ShouldShowWindowTitle() const {
   return true;
 }
 
 base::string16 ChooserBubbleUiViewDelegate::GetWindowTitle() const {
   return l10n_util::GetStringUTF16(IDS_CHOOSER_BUBBLE_PROMPT);
 }
 
 void ChooserBubbleUiViewDelegate::OnWidgetDestroying(views::Widget* widget) {
   views::BubbleDelegateView::OnWidgetDestroying(widget);
   if (owner_) {
     owner_->Close();
     owner_ = nullptr;
   }
 }
 
 void ChooserBubbleUiViewDelegate::ButtonPressed(views::Button* button,
                                                 const ui::Event& event) {
   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();
     owner_ = nullptr;
   }
 }
 
 void ChooserBubbleUiViewDelegate::StyledLabelLinkClicked(
     views::StyledLabel* label,
     const gfx::Range& range,
     int event_flags) {
-  chooser_bubble_delegate_->OpenHelpCenterUrl();
+  controller_->OpenHelpCenterUrl();
 }
 
 void ChooserBubbleUiViewDelegate::OnSelectionChanged() {
   connect_button_->SetEnabled(!table_view_->selection_model().empty());
 }
 
 void ChooserBubbleUiViewDelegate::UpdateAnchor(
     views::View* anchor_view,
     views::BubbleBorder::Arrow anchor_arrow) {
   if (GetAnchorView() == anchor_view && arrow() == anchor_arrow)
     return;
 
   set_arrow(anchor_arrow);
 
   // Update the border in the bubble: will either add or remove the arrow.
   views::BubbleFrameView* frame =
       views::BubbleDelegateView::GetBubbleFrameView();
   views::BubbleBorder::Arrow adjusted_arrow = anchor_arrow;
   if (base::i18n::IsRTL())
     adjusted_arrow = views::BubbleBorder::horizontal_mirror(adjusted_arrow);
   frame->SetBubbleBorder(scoped_ptr<views::BubbleBorder>(
       new views::BubbleBorder(adjusted_arrow, shadow(), color())));
 
   // Reposition the bubble based on the updated arrow and view.
   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(
         IDS_CHOOSER_BUBBLE_NO_DEVICES_FOUND_PROMPT);
   }
 
   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) {
   observer_ = observer;
 }
 
 void ChooserTableModel::OnOptionsInitialized() {
   if (observer_) {
     observer_->OnModelChanged();
     Update();
@@ skipping 10 matching lines @@
 void ChooserTableModel::OnOptionRemoved(size_t index) {
   if (observer_) {
     observer_->OnItemsRemoved(static_cast<int>(index), 1);
     Update();
   }
 }
 
 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 {
     table_view->SetEnabled(true);
   }
 }
 
 void ChooserTableModel::SetConnectButton(views::LabelButton* connect_button) {
   connect_button_ = 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(
       browser_->window()->GetNativeWindow());
   chooser_bubble_ui_view_delegate_->set_parent_window(widget->GetNativeView());
 
   views::BubbleDelegateView::CreateBubble(chooser_bubble_ui_view_delegate_)
       ->Show();
 
   chooser_bubble_ui_view_delegate_->chooser_table_model_->Update();
@@ skipping 23 matching lines @@
     return browser_view->exclusive_access_bubble()->GetView();
 
   return browser_view->top_container();
 }
 
 views::BubbleBorder::Arrow ChooserBubbleUiView::GetAnchorArrow() {
   if (browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR))
     return views::BubbleBorder::TOP_LEFT;
   return views::BubbleBorder::NONE;
 }