[Extensions UI] Remove all traces of the chevron

chrome/browser/ui/cocoa/extensions/browser_actions_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/extensions/browser_actions_controller.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 20 matching lines @@
 #import "third_party/google_toolbox_for_mac/src/AppKit/GTMNSAnimation+Duration.h"
 #include "ui/base/cocoa/appkit_utils.h"
 #include "ui/base/cocoa/cocoa_base_utils.h"
 #include "ui/base/material_design/material_design_controller.h"
 
 NSString* const kBrowserActionVisibilityChangedNotification =
     @"BrowserActionVisibilityChangedNotification";
 
 namespace {
 
-const CGFloat kAnimationDuration = 0.2;
-
-const CGFloat kChevronWidth = 18;
-
 // How far to inset from the bottom of the view to get the top border
 // of the popup 2px below the bottom of the Omnibox.
 const CGFloat kBrowserActionBubbleYOffset = 3.0;
 
 }  // namespace
 
 @interface BrowserActionsController(Private)
 
 // Creates and adds a view for the given |action| at |index|.
 - (void)addViewForAction:(ToolbarActionViewController*)action
@@ skipping 33 matching lines @@
 // found.
 - (BrowserActionButton*)buttonForId:(const std::string&)id;
 
 // Returns the button at the given index. This is just a wrapper around
 // [NSArray objectAtIndex:], since that technically defaults to returning ids
 // (and can cause compile errors).
 - (BrowserActionButton*)buttonAtIndex:(NSUInteger)index;
 
 // Notification handlers for events registered by the class.
 
-// Updates each button's opacity, the cursor rects and chevron position.
+// Updates each button's opacity and the cursor rects.
 - (void)containerFrameChanged:(NSNotification*)notification;
 
-// Hides the chevron and unhides every hidden button so that dragging the
-// container out smoothly shows the Browser Action buttons.
+// Unhides every hidden button so that dragging the container out smoothly shows
+// the Browser Action buttons.
 - (void)containerDragStart:(NSNotification*)notification;
 
-// Determines which buttons need to be hidden based on the new size, hides them
-// and updates the chevron overflow menu. Also fires a notification to let the
-// toolbar know that the drag has finished.
+// Determines which buttons need to be hidden based on the new size and hides
+// them. Also fires a notification to let the toolbar know that the drag has
+// finished.
 - (void)containerDragFinished:(NSNotification*)notification;
 
 // Notifies the controlling ToolbarActionsBar that any running animation has
 // ended.
 - (void)containerAnimationEnded:(NSNotification*)notification;
 
 // Processes a key event from the container.
 - (void)containerKeyEvent:(NSNotification*)notification;
 
 // Adjusts the position of the surrounding action buttons depending on where the
@@ skipping 13 matching lines @@
                   withBounds:(NSRect)bounds;
 
 // Moves the given button both visually and within the toolbar model to the
 // specified index.
 - (void)moveButton:(BrowserActionButton*)button
            toIndex:(NSUInteger)index;
 
 // Handles clicks for BrowserActionButtons.
 - (BOOL)browserActionClicked:(BrowserActionButton*)button;
 
-// The reason |frame| is specified in these chevron functions is because the
-// container may be animating and the end frame of the animation should be
-// passed instead of the current frame (which may be off and cause the chevron
-// to jump at the end of its animation).
-
-// Shows the overflow chevron button depending on whether there are any hidden
-// extensions within the frame given.
-- (void)showChevronIfNecessaryInFrame:(NSRect)frame;
-
-// Moves the chevron to its correct position within |frame|.
-- (void)updateChevronPositionInFrame:(NSRect)frame;
-
-// Shows or hides the chevron in the given |frame|.
-- (void)setChevronHidden:(BOOL)hidden
-                 inFrame:(NSRect)frame;
-
-// Handles when a menu item within the chevron overflow menu is selected.
-- (void)chevronItemSelected:(id)menuItem;
-
 // Updates the container's grippy cursor based on the number of hidden buttons.
 - (void)updateGrippyCursors;
 
 // Returns the associated ToolbarController.
 - (ToolbarController*)toolbarController;
 
 // Creates a message bubble with the given |delegate|.
 - (void)createMessageBubble:
     (std::unique_ptr<ToolbarActionsBarBubbleDelegate>)delegate;
 
 // Called when the window for the active bubble is closing, and sets the active
 // bubble to nil.
 - (void)bubbleWindowClosing:(NSNotification*)notification;
 
 // Sets the current focused view. Should only be used for the overflow
 // container.
 - (void)setFocusedViewIndex:(NSInteger)index;
 
 @end
 
-// A subclass of MenuButton that draws the chevron button in MD style.
-@interface ChevronMenuButton : MenuButton
-@end
-
-@implementation ChevronMenuButton
-
-- (gfx::VectorIconId)vectorIconId {
-  return gfx::VectorIconId::OVERFLOW_CHEVRON;
-}
-
-@end
-
 namespace {
 
 // A bridge between the ToolbarActionsBar and the BrowserActionsController.
 class ToolbarActionsBarBridge : public ToolbarActionsBarDelegate {
  public:
   explicit ToolbarActionsBarBridge(BrowserActionsController* controller);
   ~ToolbarActionsBarBridge() override;
 
   BrowserActionsController* controller_for_test() { return controller_; }
 
  private:
   // ToolbarActionsBarDelegate:
   void AddViewForAction(ToolbarActionViewController* action,
                         size_t index) override;
   void RemoveViewForAction(ToolbarActionViewController* action) override;
   void RemoveAllViews() override;
   void Redraw(bool order_changed) override;
   void ResizeAndAnimate(gfx::Tween::Type tween_type,
-                        int target_width,
-                        bool suppress_chevron) override;
-  void SetChevronVisibility(bool chevron_visible) override;
+                        int target_width) override;
   int GetWidth(GetWidthTime get_width_time) const override;
   bool IsAnimating() const override;
   void StopAnimating() override;
-  int GetChevronWidth() const override;
   void ShowToolbarActionBubble(
       std::unique_ptr<ToolbarActionsBarBubbleDelegate> bubble) override;
 
   // The owning BrowserActionsController; weak.
   BrowserActionsController* controller_;
 
   DISALLOW_COPY_AND_ASSIGN(ToolbarActionsBarBridge);
 };
 
 ToolbarActionsBarBridge::ToolbarActionsBarBridge(
@@ skipping 18 matching lines @@
 
 void ToolbarActionsBarBridge::RemoveAllViews() {
   [controller_ removeAllViews];
 }
 
 void ToolbarActionsBarBridge::Redraw(bool order_changed) {
   [controller_ redraw];
 }
 
 void ToolbarActionsBarBridge::ResizeAndAnimate(gfx::Tween::Type tween_type,
-                                               int target_width,
-                                               bool suppress_chevron) {
+                                               int target_width) {
   [controller_ resizeContainerToWidth:target_width];
 }
 
-void ToolbarActionsBarBridge::SetChevronVisibility(bool chevron_visible) {
-  [controller_ setChevronHidden:!chevron_visible
-                        inFrame:[[controller_ containerView] frame]];
-}
-
 int ToolbarActionsBarBridge::GetWidth(GetWidthTime get_width_time) const {
   NSRect frame =
       get_width_time == ToolbarActionsBarDelegate::GET_WIDTH_AFTER_ANIMATION
           ? [[controller_ containerView] animationEndFrame]
           : [[controller_ containerView] frame];
   return NSWidth(frame);
 }
 
 bool ToolbarActionsBarBridge::IsAnimating() const {
   return [[controller_ containerView] isAnimating];
 }
 
 void ToolbarActionsBarBridge::StopAnimating() {
   // Unfortunately, animating the browser actions container affects neighboring
   // views (like the omnibox), which could also be animating. Because of this,
   // instead of just ending the animation, the cleanest way to terminate is to
   // "animate" to the current frame.
   [controller_ resizeContainerToWidth:
       NSWidth([[controller_ containerView] frame])];
 }
 
-int ToolbarActionsBarBridge::GetChevronWidth() const {
-  return kChevronWidth;
-}
-
 void ToolbarActionsBarBridge::ShowToolbarActionBubble(
     std::unique_ptr<ToolbarActionsBarBubbleDelegate> bubble) {
   [controller_ createMessageBubble:std::move(bubble)];
 }
 
 }  // namespace
 
 @implementation BrowserActionsController
 
 @synthesize containerView = containerView_;
@@ skipping 49 matching lines @@
                name:kBrowserActionsContainerReceivedKeyEvent
              object:containerView_];
     // Listen for a finished drag from any button to make sure each open window
     // stays in sync.
     [[NSNotificationCenter defaultCenter]
       addObserver:self
          selector:@selector(actionButtonDragFinished:)
              name:kBrowserActionButtonDragEndNotification
            object:nil];
 
-    suppressChevron_ = NO;
-    if (toolbarActionsBar_->platform_settings().chevron_enabled) {
-      chevronAnimation_.reset([[NSViewAnimation alloc] init]);
-      [chevronAnimation_ gtm_setDuration:kAnimationDuration
-                               eventMask:NSLeftMouseUpMask];
-      [chevronAnimation_ setAnimationBlockingMode:NSAnimationNonblocking];
-    }
-
     if (isOverflow_)
       toolbarActionsBar_->SetOverflowRowWidth(NSWidth([containerView_ frame]));
 
     buttons_.reset([[NSMutableArray alloc] init]);
     toolbarActionsBar_->CreateActions();
-    [self showChevronIfNecessaryInFrame:[containerView_ frame]];
     [self updateGrippyCursors];
     [container setIsOverflow:isOverflow_];
 
     focusedViewIndex_ = -1;
   }
 
   return self;
 }
 
 - (void)dealloc {
   [self browserWillBeDestroyed];
   [super dealloc];
 }
 
 - (void)browserWillBeDestroyed {
-  [overflowMenu_ setDelegate:nil];
   // Explicitly destroy the ToolbarActionsBar so all buttons get removed with a
   // valid BrowserActionsController, and so we can verify state before
   // destruction.
   if (toolbarActionsBar_.get()) {
     toolbarActionsBar_->DeleteActions();
     toolbarActionsBar_.reset();
   }
   DCHECK_EQ(0u, [buttons_ count]);
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   browser_ = nullptr;
@@ skipping 19 matching lines @@
 }
 
 - (NSPoint)popupPointForId:(const std::string&)id {
   BrowserActionButton* button = [self buttonForId:id];
   if (!button)
     return NSZeroPoint;
 
   NSRect bounds;
   NSView* referenceButton = button;
   if ([button superview] != containerView_ || isOverflow_) {
-    referenceButton = toolbarActionsBar_->platform_settings().chevron_enabled ?
-         chevronMenuButton_.get() : [[self toolbarController] appMenuButton];
-    bounds = [referenceButton bounds];
+    bounds = [[[self toolbarController] appMenuButton] bounds];
   } else {
     bounds = [button convertRect:[button frameAfterAnimation]
                         fromView:[button superview]];
   }
 
   return [self popupPointForView:referenceButton withBounds:bounds];
 }
 
-- (BOOL)chevronIsHidden {
-  if (!chevronMenuButton_.get())
-    return YES;
-
-  if (![chevronAnimation_ isAnimating])
-    return [chevronMenuButton_ isHidden];
-
-  DCHECK([[chevronAnimation_ viewAnimations] count] > 0);
-
-  // The chevron is animating in or out. Determine which one and have the return
-  // value reflect where the animation is headed.
-  NSString* effect = [[[chevronAnimation_ viewAnimations] objectAtIndex:0]
-      valueForKey:NSViewAnimationEffectKey];
-  if (effect == NSViewAnimationFadeInEffect) {
-    return NO;
-  } else if (effect == NSViewAnimationFadeOutEffect) {
-    return YES;
-  }
-
-  NOTREACHED();
-  return YES;
-}
-
 - (content::WebContents*)currentWebContents {
   return browser_->tab_strip_model()->GetActiveWebContents();
 }
 
 - (BrowserActionButton*)mainButtonForId:(const std::string&)id {
   BrowserActionsController* mainController = isOverflow_ ?
       [[self toolbarController] browserActionsController] : self;
   return [mainController buttonForId:id];
 }
 
 - (ToolbarActionsBar*)toolbarActionsBar {
   return toolbarActionsBar_.get();
 }
 
 - (void)setFocusedInOverflow:(BOOL)focused {
   BOOL isFocused = focusedViewIndex_ != -1;
   if (isFocused != focused) {
     int index = focused ?
         [buttons_ count] - toolbarActionsBar_->GetIconCount() : -1;
     [self setFocusedViewIndex:index];
   }
 }
 
 - (gfx::Size)sizeForOverflowWidth:(int)maxWidth {
   toolbarActionsBar_->SetOverflowRowWidth(maxWidth);
   return [self preferredSize];
 }
 
-#pragma mark -
-#pragma mark NSMenuDelegate
-
-- (void)menuNeedsUpdate:(NSMenu*)menu {
-  [menu removeAllItems];
-
-  // See menu_button.h for documentation on why this is needed.
-  [menu addItemWithTitle:@"" action:nil keyEquivalent:@""];
-
-  NSUInteger iconCount = toolbarActionsBar_->GetIconCount();
-  NSRange hiddenButtonRange =
-      NSMakeRange(iconCount, [buttons_ count] - iconCount);
-  for (BrowserActionButton* button in
-           [buttons_ subarrayWithRange:hiddenButtonRange]) {
-    NSString* name =
-        base::SysUTF16ToNSString([button viewController]->GetActionName());
-    NSMenuItem* item =
-        [menu addItemWithTitle:name
-                        action:@selector(chevronItemSelected:)
-                 keyEquivalent:@""];
-    [item setRepresentedObject:button];
-    [item setImage:[button compositedImage]];
-    [item setTarget:self];
-    [item setEnabled:[button isEnabled]];
-  }
-}
-
-#pragma mark -
-#pragma mark Private Methods
-
 - (void)addViewForAction:(ToolbarActionViewController*)action
                withIndex:(NSUInteger)index {
   NSRect buttonFrame = NSMakeRect(NSMaxX([containerView_ bounds]),
                                   0,
                                   ToolbarActionsBar::IconWidth(false),
                                   ToolbarActionsBar::IconHeight());
   BrowserActionButton* newButton =
       [[[BrowserActionButton alloc]
          initWithFrame:buttonFrame
         viewController:action
@@ skipping 38 matching lines @@
         ToolbarActionViewController* other_controller =
             [[self buttonAtIndex:j] viewController];
         if (other_controller == toolbar_actions[i])
           break;
         ++j;
       }
       [buttons_ exchangeObjectAtIndex:i withObjectAtIndex:j];
     }
   }
 
-  [self showChevronIfNecessaryInFrame:[containerView_ frame]];
   NSUInteger startIndex = toolbarActionsBar_->GetStartIndexInBounds();
   NSUInteger endIndex = toolbarActionsBar_->GetEndIndexInBounds();
   for (NSUInteger i = 0; i < [buttons_ count]; ++i) {
     BrowserActionButton* button = [buttons_ objectAtIndex:i];
     if ([button isBeingDragged])
       continue;
 
     [self moveButton:[buttons_ objectAtIndex:i] toIndex:i];
 
     if (i >= startIndex && i < endIndex) {
@@ skipping 46 matching lines @@
   // Cocoa goes a little crazy if we try and change animations while adjusting
   // child frames (i.e., the buttons). If the toolbar is already animating,
   // just jump to the new frame. (This typically only happens if someone is
   // "spamming" a button to add/remove an action.) If the window isn't visible
   // (for example it's in the process of being created), don't bother animating.
   BOOL animate = !toolbarActionsBar_->suppress_animation() &&
       ![containerView_ isAnimating] && [[containerView_ window] isVisible];
   [self updateContainerVisibility];
   [containerView_ resizeToWidth:width
                         animate:animate];
-  NSRect frame = animate ? [containerView_ animationEndFrame] :
-                           [containerView_ frame];
-
-  [self showChevronIfNecessaryInFrame:frame];
-
   [containerView_ setNeedsDisplay:YES];
 
   if (!animate) {
     [[NSNotificationCenter defaultCenter]
         postNotificationName:kBrowserActionVisibilityChangedNotification
                       object:self];
   }
   [self redraw];
   [self updateGrippyCursors];
 }
@@ skipping 58 matching lines @@
 }
 
 - (BrowserActionButton*)buttonAtIndex:(NSUInteger)index {
   return static_cast<BrowserActionButton*>([buttons_ objectAtIndex:index]);
 }
 
 - (void)containerFrameChanged:(NSNotification*)notification {
   [self updateButtonPositions];
   [self updateButtonOpacity];
   [[containerView_ window] invalidateCursorRectsForView:containerView_];
-  [self updateChevronPositionInFrame:[containerView_ frame]];
 }
 
 - (void)containerDragStart:(NSNotification*)notification {
-  [self setChevronHidden:YES inFrame:[containerView_ frame]];
   for (BrowserActionButton* button in buttons_.get()) {
     if ([button superview] != containerView_) {
       [button setAlphaValue:1.0];
       [containerView_ addSubview:button];
     }
   }
 }
 
 - (void)containerDragFinished:(NSNotification*)notification {
   for (BrowserActionButton* button in buttons_.get()) {
@@ skipping 49 matching lines @@
         [focusedButton performClick:focusedButton];
       }
       break;
     }
     case BROWSER_ACTIONS_INVALID_KEY_ACTION:
       NOTREACHED();
   }
 }
 
 - (void)actionButtonDragging:(NSNotification*)notification {
-  suppressChevron_ = YES;
-  if (![self chevronIsHidden])
-    [self setChevronHidden:YES inFrame:[containerView_ frame]];
-
   // Determine what index the dragged button should lie in, alter the model and
   // reposition the buttons.
   BrowserActionButton* draggedButton = [notification object];
   NSRect draggedButtonFrame = [draggedButton frame];
   // Find the mid-point. We flip the y-coordinates so that y = 0 is at the
   // top of the container to make row calculation more logical.
   NSPoint midPoint =
       NSMakePoint(NSMidX(draggedButtonFrame),
                   NSMaxY([containerView_ bounds]) - NSMidY(draggedButtonFrame));
 
@@ skipping 13 matching lines @@
       [buttons_ count] - toolbarActionsBar_->GetIconCount() : 0;
   NSInteger index =
       std::min(maxIndex, offset + rowIndex * icons_per_row + indexInRow);
 
   toolbarActionsBar_->OnDragDrop([buttons_ indexOfObject:draggedButton],
                                  index,
                                  ToolbarActionsBar::DRAG_TO_SAME);
 }
 
 - (void)actionButtonDragFinished:(NSNotification*)notification {
-  suppressChevron_ = NO;
   [self redraw];
 }
 
 - (NSRect)frameForIndex:(NSUInteger)index {
   gfx::Rect frameRect = toolbarActionsBar_->GetFrameForIndex(index);
   int iconWidth = ToolbarActionsBar::IconWidth(false);
   // The toolbar actions bar will return an empty rect if the index is for an
   // action that is before range we show (i.e., is for a button that's on the
   // main bar, and this is the overflow). Set the frame to be outside the bounds
   // of the view.
@@ skipping 51 matching lines @@
   if (!NSEqualRects(buttonFrame, [button frameAfterAnimation])) {
     [button setFrame:buttonFrame
              animate:!toolbarActionsBar_->suppress_animation() && !isOverflow_];
   }
 }
 
 - (BOOL)browserActionClicked:(BrowserActionButton*)button {
   return [button viewController]->ExecuteAction(true);
 }
 
-- (void)showChevronIfNecessaryInFrame:(NSRect)frame {
-  if (!toolbarActionsBar_->platform_settings().chevron_enabled)
-    return;
-  bool hidden = suppressChevron_ ||
-      toolbarActionsBar_->GetIconCount() == [self buttonCount];
-  [self setChevronHidden:hidden inFrame:frame];
-}
-
-- (void)updateChevronPositionInFrame:(NSRect)frame {
-  CGFloat xPos = NSWidth(frame) - kChevronWidth -
-      toolbarActionsBar_->platform_settings().item_spacing;
-  NSRect buttonFrame = NSMakeRect(xPos,
-                                  0,
-                                  kChevronWidth,
-                                  ToolbarActionsBar::IconHeight());
-  [chevronAnimation_ stopAnimation];
-  [chevronMenuButton_ setFrame:buttonFrame];
-}
-
-- (void)setChevronHidden:(BOOL)hidden
-                 inFrame:(NSRect)frame {
-  if (!toolbarActionsBar_->platform_settings().chevron_enabled ||
-      hidden == [self chevronIsHidden])
-    return;
-
-  if (!chevronMenuButton_.get()) {
-    bool isModeMaterial = ui::MaterialDesignController::IsModeMaterial();
-    if (isModeMaterial) {
-      chevronMenuButton_.reset([[ChevronMenuButton alloc] init]);
-    } else {
-      chevronMenuButton_.reset([[MenuButton alloc] init]);
-    }
-    [chevronMenuButton_ setOpenMenuOnClick:YES];
-    [chevronMenuButton_ setBordered:NO];
-    [chevronMenuButton_ setShowsBorderOnlyWhileMouseInside:YES];
-
-    if (!isModeMaterial) {
-      [[chevronMenuButton_ cell] setImageID:IDR_BROWSER_ACTIONS_OVERFLOW
-                             forButtonState:image_button_cell::kDefaultState];
-      [[chevronMenuButton_ cell] setImageID:IDR_BROWSER_ACTIONS_OVERFLOW_H
-                             forButtonState:image_button_cell::kHoverState];
-      [[chevronMenuButton_ cell] setImageID:IDR_BROWSER_ACTIONS_OVERFLOW_P
-                             forButtonState:image_button_cell::kPressedState];
-    }
-    overflowMenu_.reset([[NSMenu alloc] initWithTitle:@""]);
-    [overflowMenu_ setAutoenablesItems:NO];
-    [overflowMenu_ setDelegate:self];
-    [chevronMenuButton_ setAttachedMenu:overflowMenu_];
-
-    [containerView_ addSubview:chevronMenuButton_];
-  }
-
-  [self updateChevronPositionInFrame:frame];
-
-  // Stop any running animation.
-  [chevronAnimation_ stopAnimation];
-
-  if (toolbarActionsBar_->suppress_animation()) {
-    [chevronMenuButton_ setHidden:hidden];
-    return;
-  }
-
-  NSString* animationEffect;
-  if (hidden) {
-    animationEffect = NSViewAnimationFadeOutEffect;
-  } else {
-    [chevronMenuButton_ setHidden:NO];
-    animationEffect = NSViewAnimationFadeInEffect;
-  }
-  NSDictionary* animationDictionary = @{
-      NSViewAnimationTargetKey : chevronMenuButton_.get(),
-      NSViewAnimationEffectKey : animationEffect
-  };
-  [chevronAnimation_ setViewAnimations:
-      [NSArray arrayWithObject:animationDictionary]];
-  [chevronAnimation_ startAnimation];
-}
-
-- (void)chevronItemSelected:(id)menuItem {
-  [self browserActionClicked:[menuItem representedObject]];
-}
-
 - (void)updateGrippyCursors {
   [containerView_
       setCanDragLeft:toolbarActionsBar_->GetIconCount() != [buttons_ count]];
   [containerView_ setCanDragRight:[self visibleButtonCount] > 0];
   [[containerView_ window] invalidateCursorRectsForView:containerView_];
 }
 
 - (ToolbarController*)toolbarController {
   return [[BrowserWindowController browserWindowControllerForWindow:
              browser_->window()->GetNativeWindow()] toolbarController];
@@ skipping 45 matching lines @@
 }
 
 #pragma mark -
 #pragma mark Testing Methods
 
 - (BrowserActionButton*)buttonWithIndex:(NSUInteger)index {
   return index < [buttons_ count] ? [buttons_ objectAtIndex:index] : nil;
 }
 
 @end