UI: Rename MediaState to AlertState

chrome/browser/ui/cocoa/tabs/tab_controller.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/tabs/tab_controller.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/i18n/rtl.h"
 #include "base/mac/bundle_locations.h"
 #import "chrome/browser/themes/theme_properties.h"
 #import "chrome/browser/themes/theme_service.h"
 #import "chrome/browser/ui/cocoa/sprite_view.h"
-#import "chrome/browser/ui/cocoa/tabs/media_indicator_button_cocoa.h"
+#import "chrome/browser/ui/cocoa/tabs/alert_indicator_button_cocoa.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_controller_target.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_view.h"
 #import "chrome/browser/ui/cocoa/themed_window.h"
 #include "content/public/browser/user_metrics.h"
 #import "extensions/common/extension.h"
 #import "ui/base/cocoa/menu_controller.h"
 #include "ui/base/material_design/material_design_controller.h"
 
 @implementation TabController
 
@@ skipping 118 matching lines @@
                       selector:@selector(themeChangedNotification:)
                           name:kBrowserThemeDidChangeNotification
                         object:nil];
 
     [self internalSetSelected:selected_];
   }
   return self;
 }
 
 - (void)dealloc {
-  [mediaIndicatorButton_ setAnimationDoneTarget:nil withAction:nil];
-  [mediaIndicatorButton_ setClickTarget:nil withAction:nil];
+  [alertIndicatorButton_ setAnimationDoneTarget:nil withAction:nil];
+  [alertIndicatorButton_ setClickTarget:nil withAction:nil];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [[self tabView] setController:nil];
   [super dealloc];
 }
 
 // The internals of |-setSelected:| and |-setActive:| but doesn't set the
 // backing variables. This updates the drawing state and marks self as needing
 // a re-draw.
 - (void)internalSetSelected:(BOOL)selected {
   TabView* tabView = [self tabView];
@@ skipping 25 matching lines @@
 - (void)toggleMute:(id)sender {
   if ([[self target] respondsToSelector:@selector(toggleMute:)]) {
     [[self target] performSelector:@selector(toggleMute:)
                         withObject:[self view]];
   }
 }
 
 - (void)closeTab:(id)sender {
   using base::UserMetricsAction;
 
-  if (mediaIndicatorButton_ && ![mediaIndicatorButton_ isHidden]) {
-    if ([mediaIndicatorButton_ isEnabled]) {
+  if (alertIndicatorButton_ && ![alertIndicatorButton_ isHidden]) {
+    if ([alertIndicatorButton_ isEnabled]) {
       content::RecordAction(UserMetricsAction("CloseTab_MuteToggleAvailable"));
-    } else if ([mediaIndicatorButton_ showingMediaState] ==
-                   TAB_MEDIA_STATE_AUDIO_PLAYING) {
+    } else if ([alertIndicatorButton_ showingAlertState] ==
+                   TabAlertState::AUDIO_PLAYING) {
       content::RecordAction(UserMetricsAction("CloseTab_AudioIndicator"));
     } else {
       content::RecordAction(UserMetricsAction("CloseTab_RecordingIndicator"));
     }
   } else {
-    content::RecordAction(UserMetricsAction("CloseTab_NoMediaIndicator"));
+    content::RecordAction(UserMetricsAction("CloseTab_NoAlertIndicator"));
   }
 
   if ([[self target] respondsToSelector:@selector(closeTab:)]) {
     [[self target] performSelector:@selector(closeTab:)
                         withObject:[self view]];
   }
 }
 
 - (void)selectTab:(id)sender {
   if ([[self tabView] isClosing])
@@ skipping 44 matching lines @@
 }
 
 - (void)setIconView:(SpriteView*)iconView {
   [iconView_ removeFromSuperview];
   iconView_.reset([iconView retain]);
 
   if (iconView_)
     [[self view] addSubview:iconView_];
 }
 
-- (MediaIndicatorButton*)mediaIndicatorButton {
-  return mediaIndicatorButton_;
+- (AlertIndicatorButton*)alertIndicatorButton {
+  return alertIndicatorButton_;
 }
 
-- (void)setMediaState:(TabMediaState)mediaState {
-  if (!mediaIndicatorButton_ && mediaState != TAB_MEDIA_STATE_NONE) {
-    mediaIndicatorButton_.reset([[MediaIndicatorButton alloc] init]);
+- (void)setAlertState:(TabAlertState)alertState {
+  if (!alertIndicatorButton_ && alertState != TabAlertState::NONE) {
+    alertIndicatorButton_.reset([[AlertIndicatorButton alloc] init]);
     [self updateVisibility];  // Do layout and visibility before adding subview.
-    [[self view] addSubview:mediaIndicatorButton_];
-    [mediaIndicatorButton_ setAnimationDoneTarget:self
+    [[self view] addSubview:alertIndicatorButton_];
+    [alertIndicatorButton_ setAnimationDoneTarget:self
                                        withAction:@selector(updateVisibility)];
-    [mediaIndicatorButton_ setClickTarget:self
+    [alertIndicatorButton_ setClickTarget:self
                                withAction:@selector(toggleMute:)];
   }
-  [mediaIndicatorButton_ transitionToMediaState:mediaState];
+  [alertIndicatorButton_ transitionToAlertState:alertState];
 }
 
 - (HoverCloseButton*)closeButton {
   return closeButton_;
 }
 
 - (NSString*)toolTip {
   return [[self tabView] toolTipText];
 }
 
@@ skipping 12 matching lines @@
   if (availableWidth >= widthPerIcon &&
       availableWidth < (widthPerIcon + kPaddingBetweenIcons)) {
     return 1;
   }
   return availableWidth / (widthPerIcon + kPaddingBetweenIcons);
 }
 
 - (BOOL)shouldShowIcon {
   return chrome::ShouldTabShowFavicon(
       [self iconCapacity], [self pinned], [self active], iconView_ != nil,
-      !mediaIndicatorButton_ ? TAB_MEDIA_STATE_NONE :
-          [mediaIndicatorButton_ showingMediaState]);
+      !alertIndicatorButton_ ? TabAlertState::NONE :
+          [alertIndicatorButton_ showingAlertState]);
 }
 
-- (BOOL)shouldShowMediaIndicator {
-  return chrome::ShouldTabShowMediaIndicator(
+- (BOOL)shouldShowAlertIndicator {
+  return chrome::ShouldTabShowAlertIndicator(
       [self iconCapacity], [self pinned], [self active], iconView_ != nil,
-      !mediaIndicatorButton_ ? TAB_MEDIA_STATE_NONE :
-          [mediaIndicatorButton_ showingMediaState]);
+      !alertIndicatorButton_ ? TabAlertState::NONE :
+          [alertIndicatorButton_ showingAlertState]);
 }
 
 - (BOOL)shouldShowCloseButton {
   return chrome::ShouldTabShowCloseButton(
       [self iconCapacity], [self pinned], [self active]);
 }
 
 - (void)setIconImage:(NSImage*)image {
   [self setIconImage:image withToastAnimation:NO];
 }
@@ skipping 36 matching lines @@
   isIconShowing_ = newShowIcon;
 
   // If the tab is a pinned-tab, hide the title.
   TabView* tabView = [self tabView];
   [tabView setTitleHidden:[self pinned]];
 
   BOOL newShowCloseButton = [self shouldShowCloseButton];
 
   [closeButton_ setHidden:!newShowCloseButton];
 
-  BOOL newShowMediaIndicator = [self shouldShowMediaIndicator];
+  BOOL newShowAlertIndicator = [self shouldShowAlertIndicator];
 
-  [mediaIndicatorButton_ setHidden:!newShowMediaIndicator];
+  [alertIndicatorButton_ setHidden:!newShowAlertIndicator];
 
-  if (newShowMediaIndicator) {
-    NSRect newFrame = [mediaIndicatorButton_ frame];
-    newFrame.size = [[mediaIndicatorButton_ image] size];
+  if (newShowAlertIndicator) {
+    NSRect newFrame = [alertIndicatorButton_ frame];
+    newFrame.size = [[alertIndicatorButton_ image] size];
     if ([self pinned]) {
-      // Tab is pinned: Position the media indicator in the center.
+      // Tab is pinned: Position the alert indicator in the center.
       const CGFloat tabWidth = [TabController pinnedTabWidth];
       newFrame.origin.x = std::floor((tabWidth - NSWidth(newFrame)) / 2);
       newFrame.origin.y = NSMinY(originalIconFrame_) -
           std::floor((NSHeight(newFrame) - NSHeight(originalIconFrame_)) / 2);
     } else {
-      // The Frame for the mediaIndicatorButton_ depends on whether iconView_
+      // The Frame for the alertIndicatorButton_ depends on whether iconView_
       // and/or closeButton_ are visible, and where they have been positioned.
       const NSRect closeButtonFrame = [closeButton_ frame];
       newFrame.origin.x = NSMinX(closeButtonFrame);
       // Position to the left of the close button when it is showing.
       if (newShowCloseButton)
         newFrame.origin.x -= NSWidth(newFrame);
-      // Media indicator is centered vertically, with respect to closeButton_.
+      // Alert indicator is centered vertically, with respect to closeButton_.
       newFrame.origin.y = NSMinY(closeButtonFrame) -
           std::floor((NSHeight(newFrame) - NSHeight(closeButtonFrame)) / 2);
     }
-    [mediaIndicatorButton_ setFrame:newFrame];
-    [mediaIndicatorButton_ updateEnabledForMuteToggle];
+    [alertIndicatorButton_ setFrame:newFrame];
+    [alertIndicatorButton_ updateEnabledForMuteToggle];
   }
 
   // Adjust the title view based on changes to the icon's and close button's
   // visibility.
   NSRect oldTitleFrame = [tabView titleFrame];
   NSRect newTitleFrame;
   newTitleFrame.size.height = oldTitleFrame.size.height;
   newTitleFrame.origin.y = oldTitleFrame.origin.y;
 
   if (newShowIcon) {
     newTitleFrame.origin.x = NSMaxX([iconView_ frame]) + 4;
 
     if (!ui::MaterialDesignController::IsModeMaterial()) {
       newTitleFrame.origin.x -= 4;
     }
   } else {
     newTitleFrame.origin.x = originalIconFrame_.origin.x;
   }
 
-  if (newShowMediaIndicator) {
-    newTitleFrame.size.width = NSMinX([mediaIndicatorButton_ frame]) -
+  if (newShowAlertIndicator) {
+    newTitleFrame.size.width = NSMinX([alertIndicatorButton_ frame]) -
                                newTitleFrame.origin.x;
   } else if (newShowCloseButton) {
     newTitleFrame.size.width = NSMinX([closeButton_ frame]) -
                                newTitleFrame.origin.x;
   } else {
     newTitleFrame.size.width = NSMaxX([closeButton_ frame]) -
                                newTitleFrame.origin.x;
   }
 
   [tabView setTitleFrame:newTitleFrame];
@@ skipping 21 matching lines @@
         YES : NO;
   }
   return NO;
 }
 
 - (void)maybeStartDrag:(NSEvent*)event forTab:(TabController*)tab {
   [[target_ dragController] maybeStartDrag:event forTab:tab];
 }
 
 @end