Change ChooserBubbleDelegate class name to ChooserBubbleController

chrome/browser/ui/cocoa/website_settings/chooser_bubble_ui_cocoa.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/website_settings/chooser_bubble_ui_cocoa.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
 #include "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #import "chrome/browser/ui/chrome_style.h"
 #import "chrome/browser/ui/cocoa/base_bubble_controller.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #import "chrome/browser/ui/cocoa/browser_window_utils.h"
 #import "chrome/browser/ui/cocoa/constrained_window/constrained_window_button.h"
 #import "chrome/browser/ui/cocoa/hover_close_button.h"
 #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 "ui/base/cocoa/window_size_constants.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
 namespace {
 
 // Chooser bubble width.
 const CGFloat kChooserBubbleWidth = 320.0f;
 
 // Chooser bubble height.
 const CGFloat kChooserBubbleHeight = 220.0f;
 
 // Distance between the bubble border and the view that is closest to the
 // border.
 const CGFloat kMarginX = 20.0f;
 const CGFloat kMarginY = 20.0f;
 
 // Distance between two views inside the bubble.
 const CGFloat kHorizontalPadding = 10.0f;
 const CGFloat kVerticalPadding = 10.0f;
 
 const CGFloat kTitlePaddingX = 50.0f;
 }
 
-scoped_ptr<BubbleUi> ChooserBubbleDelegate::BuildBubbleUi() {
+scoped_ptr<BubbleUi> ChooserBubbleController::BuildBubbleUi() {
   return make_scoped_ptr(new ChooserBubbleUiCocoa(browser_, this));
 }
 
 @interface ChooserBubbleUiController
     : BaseBubbleController<NSTableViewDataSource, NSTableViewDelegate> {
  @private
   // Bridge to the C++ class that created this object.
   ChooserBubbleUiCocoa* bridge_;
 
   base::scoped_nsobject<NSTextField> titleView_;
   base::scoped_nsobject<NSScrollView> scrollView_;
   base::scoped_nsobject<NSTableColumn> tableColumn_;
   base::scoped_nsobject<NSTableView> tableView_;
   base::scoped_nsobject<NSButton> connectButton_;
   base::scoped_nsobject<NSButton> cancelButton_;
   bool buttonPressed_;
 
   Browser* browser_;                                // Weak.
-  ChooserBubbleDelegate* chooserBubbleDelegate_;    // 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;
 
 // Will reposition the bubble based in case the anchor or parent should change.
 - (void)updateAnchorPosition;
 
 // Will calculate the expected anchor point for this bubble.
 // Should only be used outside this class for tests.
 - (NSPoint)getExpectedAnchorPoint;
@@ skipping 37 matching lines @@
 - (void)onConnect:(id)sender;
 
 // Called when the "Cancel" button is pressed.
 - (void)onCancel:(id)sender;
 
 @end
 
 @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
                 styleMask:NSBorderlessWindowMask
                   backing:NSBackingStoreBuffered
                     defer:NO]);
   [window setAllowedAnimations:info_bubble::kAnimateNone];
   [window setReleasedWhenClosed:NO];
   if ((self = [super initWithWindow:window
                        parentWindow:[self getExpectedParentWindow]
@@ skipping 10 matching lines @@
   }
   return self;
 }
 
 - (void)windowWillClose:(NSNotification*)notification {
   [[NSNotificationCenter defaultCenter]
       removeObserver:self
                 name:NSWindowDidMoveNotification
               object:nil];
   if (!buttonPressed_)
-    chooserBubbleDelegate_->Close();
+    chooserBubbleController_->Close();
   bridge_->OnBubbleClosing();
   [super windowWillClose:notification];
 }
 
 - (void)parentWindowWillToggleFullScreen:(NSNotification*)notification {
   // Override the base class implementation, which would have closed the bubble.
 }
 
 - (void)parentWindowDidResize:(NSNotification*)notification {
   [self setAnchorPoint:[self getExpectedAnchorPoint]];
@@ skipping 105 matching lines @@
     [self setAnchorPoint:[self getExpectedAnchorPoint]];
     [self showWindow:nil];
     [[self window] makeFirstResponder:nil];
     [[self window] setInitialFirstResponder:connectButton_.get()];
   }
 }
 
 - (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);
   }
 
   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
     shouldEditTableColumn:(NSTableColumn*)aTableColumn
                       row:(NSInteger)rowIndex {
   return NO;
 }
 
 - (void)onOptionsInitialized {
   [self updateTableView];
 }
 
 - (void)onOptionAdded:(NSInteger)index {
   [self updateTableView];
 }
 
 - (void)onOptionRemoved:(NSInteger)index {
   // |tableView_| will automatically selects the next item if the current
   // item is removed, so here it tracks if the removed item is the item
   // that was previously selected, if so, deselect it.
   if ([tableView_ selectedRow] == index)
     [tableView_ deselectRow:index];
 
   [self updateTableView];
 }
 
 - (void)updateTableView {
-  [tableView_ setEnabled:chooserBubbleDelegate_->NumOptions() > 0];
+  [tableView_ setEnabled:chooserBubbleController_->NumOptions() > 0];
   [tableView_ reloadData];
 }
 
 - (void)tableViewSelectionDidChange:(NSNotification*)aNotification {
   [connectButton_ setEnabled:[tableView_ numberOfSelectedRows] > 0];
 }
 
 - (void)updateAnchorPosition {
   [self setParentWindow:[self getExpectedParentWindow]];
   [self setAnchorPoint:[self getExpectedAnchorPoint]];
@@ skipping 80 matching lines @@
   NSRect frameA = [viewA frame];
   NSRect frameB = [viewB frame];
   frameA.origin.y =
       NSMinY(frameB) + std::floor((NSHeight(frameB) - NSHeight(frameA)) / 2);
   [viewA setFrameOrigin:frameA.origin];
 }
 
 - (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];
 }
 
 @end
 
 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;
 }
 
 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];
   [chooser_bubble_ui_controller_ updateTableView];
 }
 
 void ChooserBubbleUiCocoa::Close() {
   [chooser_bubble_ui_controller_ close];
   chooser_bubble_ui_controller_ = nil;
 }
@@ skipping 10 matching lines @@
   [chooser_bubble_ui_controller_ onOptionAdded:static_cast<NSInteger>(index)];
 }
 
 void ChooserBubbleUiCocoa::OnOptionRemoved(size_t index) {
   [chooser_bubble_ui_controller_ onOptionRemoved:static_cast<NSInteger>(index)];
 }
 
 void ChooserBubbleUiCocoa::OnBubbleClosing() {
   chooser_bubble_ui_controller_ = nil;
 }