Reland of [Mac][Material Design] Update bookmarks bar to Material Design.

chrome/browser/ui/cocoa/bookmarks/bookmark_bar_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/bookmarks/bookmark_bar_controller.h"
 
 #include <stddef.h>
 
 #import "base/mac/bundle_locations.h"
 #import "base/mac/foundation_util.h"
@@ skipping 49 matching lines @@
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "grit/theme_resources.h"
 #include "ui/base/clipboard/clipboard_util_mac.h"
 #import "ui/base/cocoa/cocoa_base_utils.h"
 #import "ui/base/cocoa/nsview_additions.h"
 #include "ui/base/l10n/l10n_util_mac.h"
+#include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/color_palette.h"
 #include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_skia_util_mac.h"
+#include "ui/gfx/paint_vector_icon.h"
+#include "ui/gfx/vector_icons_public.h"
 #include "ui/resources/grit/ui_resources.h"
 
 using base::UserMetricsAction;
 using bookmarks::BookmarkModel;
 using bookmarks::BookmarkNode;
 using bookmarks::BookmarkNodeData;
 using content::OpenURLParams;
 using content::Referrer;
 using content::WebContents;
 
@@ skipping 155 matching lines @@
 - (void)createOtherBookmarksButton;
 - (void)createAppsPageShortcutButton;
 - (void)openAppsPage:(id)sender;
 - (void)centerNoItemsLabel;
 - (void)positionRightSideButtons;
 - (void)watchForExitEvent:(BOOL)watch;
 - (void)resetAllButtonPositionsWithAnimation:(BOOL)animate;
 
 @end
 
+namespace bookmarks {
+
+CGFloat BookmarkHorizontalPadding() {
+  if (!ui::MaterialDesignController::IsModeMaterial()) {
+    return 1.0;
+  }
+  return 16.0;
+}
+
+CGFloat BookmarkVerticalPadding() {
+  if (!ui::MaterialDesignController::IsModeMaterial()) {
+    return 2.0;
+  }
+  return 4.0;
+}
+
+CGFloat BookmarkLeftMargin() {
+  if (!ui::MaterialDesignController::IsModeMaterial()) {
+    return 2.0;
+  }
+  return 10.0;
+}
+
+CGFloat BookmarkRightMargin() {
+  if (!ui::MaterialDesignController::IsModeMaterial()) {
+    return 2.0;
+  }
+  return 10.0;
+}
+
+}  // namespace bookmarks
+
 @implementation BookmarkBarController
 
 @synthesize currentState = currentState_;
 @synthesize lastState = lastState_;
 @synthesize isAnimationRunning = isAnimationRunning_;
 @synthesize delegate = delegate_;
 @synthesize stateAnimationsEnabled = stateAnimationsEnabled_;
 @synthesize innerContentAnimationsEnabled = innerContentAnimationsEnabled_;
 
 - (id)initWithBrowser:(Browser*)browser
@@ skipping 11 matching lines @@
         ManagedBookmarkServiceFactory::GetForProfile(browser_->profile());
     buttons_.reset([[NSMutableArray alloc] init]);
     delegate_ = delegate;
     folderTarget_.reset(
         [[BookmarkFolderTarget alloc] initWithController:self
                                                  profile:browser_->profile()]);
 
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     folderImage_.reset(
         rb.GetNativeImageNamed(IDR_BOOKMARK_BAR_FOLDER).CopyNSImage());
+    if (ui::MaterialDesignController::IsModeMaterial()) {
+      folderImageWhite_.reset(
+          rb.GetNativeImageNamed(IDR_BOOKMARK_BAR_FOLDER_WHITE).CopyNSImage());
+    }
     defaultImage_.reset(
         rb.GetNativeImageNamed(IDR_DEFAULT_FAVICON).CopyNSImage());
 
     innerContentAnimationsEnabled_ = YES;
     stateAnimationsEnabled_ = YES;
 
     // Register for theme changes, bookmark button pulsing, ...
     NSNotificationCenter* defaultCenter = [NSNotificationCenter defaultCenter];
     [defaultCenter addObserver:self
                       selector:@selector(themeDidChangeNotification:)
@@ skipping 130 matching lines @@
     return;
   }
 
   // We default to NOT open, which means height=0.
   DCHECK([[self view] isHidden]);  // Hidden so it's OK to change.
 
   // Set our initial height to zero, since that is what the superview
   // expects.  We will resize ourselves open later if needed.
   [[self view] setFrame:NSMakeRect(0, 0, initialWidth_, 0)];
 
+  const bool isModeMaterial = ui::MaterialDesignController::IsModeMaterial();
+
   // Complete init of the "off the side" button, as much as we can.
-  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  [offTheSideButton_ setImage:
-        rb.GetNativeImageNamed(IDR_BOOKMARK_BAR_CHEVRONS).ToNSImage()];
-  [offTheSideButton_.draggableButton setDraggable:NO];
-  [offTheSideButton_.draggableButton setActsOnMouseDown:YES];
+  if (isModeMaterial) {
+    [offTheSideButton_ setImage:[self offTheSideButtonImage:NO]];
+    BookmarkButtonCell* offTheSideCell = [offTheSideButton_ cell];
+    [offTheSideCell setTag:kMaterialStandardButtonTypeWithLimitedClickFeedback];
+    [offTheSideCell setImagePosition:NSImageOnly];
+  } else {
+    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+    [offTheSideButton_ setImage:
+          rb.GetNativeImageNamed(IDR_BOOKMARK_BAR_CHEVRONS).ToNSImage()];
+    [offTheSideButton_.draggableButton setDraggable:NO];
+    [offTheSideButton_.draggableButton setActsOnMouseDown:YES];
+  }
 
   // We are enabled by default.
   barIsEnabled_ = YES;
 
   // Remember the original sizes of the 'no items' and 'import bookmarks'
   // fields to aid in resizing when the window frame changes.
   originalNoItemsRect_ = [[buttonView_ noItemTextfield] frame];
   originalImportBookmarksRect_ = [[buttonView_ importBookmarksButton] frame];
+  if (isModeMaterial) {
+    // Bookmark buttons are shorter and start farther from the bookmark bar's
+    // left edge so adjust the positions of the noItems and importBookmarks
+    // textfields.
+    const CGFloat kMaterialBookmarksTextfieldOffsetX = 14;
+    const CGFloat kMaterialBookmarksTextfieldOffsetY = -2;
+    originalNoItemsRect_.origin =
+        NSOffsetRect(originalNoItemsRect_,
+                     kMaterialBookmarksTextfieldOffsetX,
+                     kMaterialBookmarksTextfieldOffsetY).origin;
+    [[buttonView_ noItemTextfield] setFrame:originalNoItemsRect_];
+
+    originalImportBookmarksRect_.origin =
+        NSOffsetRect(originalImportBookmarksRect_,
+                     kMaterialBookmarksTextfieldOffsetX,
+                     kMaterialBookmarksTextfieldOffsetY).origin;
+    [[buttonView_ importBookmarksButton] setFrame:originalImportBookmarksRect_];
+  }
 
   // To make life happier when the bookmark bar is floating, the chevron is a
   // child of the button view.
   [offTheSideButton_ removeFromSuperview];
   [buttonView_ addSubview:offTheSideButton_];
 
   // When resized we may need to add new buttons, or remove them (if
   // no longer visible), or add/remove the "off the side" menu.
   [[self view] setPostsFrameChangedNotifications:YES];
   [[NSNotificationCenter defaultCenter]
@@ skipping 74 matching lines @@
 
 // Change the layout of the bookmark bar's subviews in response to a visibility
 // change (e.g., show or hide the bar) or style change (attached or floating).
 - (void)layoutSubviews {
   NSRect frame = [[self view] frame];
   NSRect buttonViewFrame = NSMakeRect(0, 0, NSWidth(frame), NSHeight(frame));
 
   // Add padding to the detached bookmark bar.
   // The state of our morph (if any); 1 is total bubble, 0 is the regular bar.
   CGFloat morph = [self detachedMorphProgress];
-  CGFloat padding = bookmarks::kNTPBookmarkBarPadding;
+  CGFloat padding = 0;
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    padding = bookmarks::kMaterialNTPBookmarkBarPadding;
+  } else {
+    padding = bookmarks::kNTPBookmarkBarPadding;
+  }
   buttonViewFrame =
       NSInsetRect(buttonViewFrame, morph * padding, morph * padding);
 
   [buttonView_ setFrame:buttonViewFrame];
 
   // Update bookmark button backgrounds.
   if ([self isAnimationRunning]) {
     for (NSButton* button in buttons_.get())
       [button setNeedsDisplay:YES];
     // Update the apps and other buttons explicitly, since they are not in the
@@ skipping 76 matching lines @@
                              andState:BookmarkBar::DETACHED])
       return static_cast<CGFloat>([self detachedMorphProgress]);
 
     // If we ever need any other animation cases, code would go here.
   }
 
   // In general, only show the divider when it's in the normal showing state.
   return [self isInState:BookmarkBar::SHOW] ? 0 : 1;
 }
 
-- (NSImage*)faviconForNode:(const BookmarkNode*)node {
+- (NSImage*)faviconForNode:(const BookmarkNode*)node
+             forADarkTheme:(BOOL)forADarkTheme {
   if (!node)
     return defaultImage_;
 
-  if (node == managedBookmarkService_->managed_node()) {
-    // Most users never see this node, so the image is only loaded if needed.
-    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-    return rb.GetNativeImageNamed(IDR_BOOKMARK_BAR_FOLDER_MANAGED).ToNSImage();
+  if (forADarkTheme && ui::MaterialDesignController::IsModeMaterial()) {
+    if (node == managedBookmarkService_->managed_node()) {
+      ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+      return rb.GetNativeImageNamed(
+          IDR_BOOKMARK_BAR_FOLDER_MANAGED_WHITE).ToNSImage();
+    }
+
+    if (node == managedBookmarkService_->supervised_node()) {
+      ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+      return rb.GetNativeImageNamed(
+          IDR_BOOKMARK_BAR_FOLDER_SUPERVISED_WHITE).ToNSImage();
+    }
+
+    if (node->is_folder())
+      return folderImageWhite_;
+  } else {
+    if (node == managedBookmarkService_->managed_node()) {
+      // Most users never see this node, so the image is only loaded if needed.
+      ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+      return rb.GetNativeImageNamed(
+          IDR_BOOKMARK_BAR_FOLDER_MANAGED).ToNSImage();
+    }
+
+    if (node == managedBookmarkService_->supervised_node()) {
+      // Most users never see this node, so the image is only loaded if needed.
+      ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+      return rb.GetNativeImageNamed(
+          IDR_BOOKMARK_BAR_FOLDER_SUPERVISED).ToNSImage();
+    }
+
+    if (node->is_folder())
+      return folderImage_;
   }
 
-  if (node == managedBookmarkService_->supervised_node()) {
-    // Most users never see this node, so the image is only loaded if needed.
-    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-    return rb.GetNativeImageNamed(
-        IDR_BOOKMARK_BAR_FOLDER_SUPERVISED).ToNSImage();
-  }
-
-  if (node->is_folder())
-    return folderImage_;
-
   const gfx::Image& favicon = bookmarkModel_->GetFavicon(node);
   if (!favicon.IsEmpty())
     return favicon.ToNSImage();
 
   return defaultImage_;
 }
 
 - (void)closeFolderAndStopTrackingMenus {
   showFolderMenus_ = NO;
   [self closeAllBookmarkFolders];
@@ skipping 141 matching lines @@
 // Click on the "off the side" button (chevron), which opens like a folder
 // button but isn't exactly a parent folder.
 - (IBAction)openOffTheSideFolderFromButton:(id)sender {
   [self openBookmarkFolder:sender];
 }
 
 - (IBAction)importBookmarks:(id)sender {
   chrome::ShowImportDialog(browser_);
 }
 
+- (NSButton*)offTheSideButton {
+  return offTheSideButton_;
+}
+
+- (NSImage*)offTheSideButtonImage:(BOOL)forDarkMode {
+  const int kIconSize = 16;
+  SkColor vectorIconColor = forDarkMode ? SkColorSetA(SK_ColorWHITE, 0xCC)
+                                        : gfx::kChromeIconGrey;
+  return NSImageFromImageSkia(
+      gfx::CreateVectorIcon(gfx::VectorIconId::OVERFLOW_CHEVRON,
+                            kIconSize,
+                            vectorIconColor));
+}
+
 #pragma mark Private Methods
 
 // Called after a theme change took place, possibly for a different profile.
 - (void)themeDidChangeNotification:(NSNotification*)notification {
   [self updateTheme:[[[self view] window] themeProvider]];
 }
 
 - (BookmarkLaunchLocation)bookmarkLaunchLocation {
   return currentState_ == BookmarkBar::DETACHED ?
       BOOKMARK_LAUNCH_LOCATION_DETACHED_BAR :
       BOOKMARK_LAUNCH_LOCATION_ATTACHED_BAR;
 }
 
 // Position the right-side buttons including the off-the-side chevron.
 - (void)positionRightSideButtons {
   int maxX = NSMaxX([[self buttonView] bounds]) -
-      bookmarks::kBookmarkHorizontalPadding;
+      bookmarks::BookmarkHorizontalPadding();
   int right = maxX;
 
   int ignored = 0;
   NSRect frame = [self frameForBookmarkButtonFromCell:
       [otherBookmarksButton_ cell] xOffset:&ignored];
   if (![otherBookmarksButton_ isHidden]) {
     right -= NSWidth(frame);
     frame.origin.x = right;
   } else {
     frame.origin.x = maxX - NSWidth(frame);
@@ skipping 204 matching lines @@
 }
 
 // Recursively add the given bookmark node and all its children to
 // menu, one menu item per node.
 - (void)addNode:(const BookmarkNode*)child toMenu:(NSMenu*)menu {
   NSString* title = [BookmarkMenuCocoaController menuTitleForNode:child];
   NSMenuItem* item = [[[NSMenuItem alloc] initWithTitle:title
                                                  action:nil
                                           keyEquivalent:@""] autorelease];
   [menu addItem:item];
-  [item setImage:[self faviconForNode:child]];
+  [item setImage:[self faviconForNode:child forADarkTheme:NO]];
   if (child->is_folder()) {
     NSMenu* submenu = [[[NSMenu alloc] initWithTitle:title] autorelease];
     [menu setSubmenu:submenu forItem:item];
     if (!child->empty()) {
       [self addFolderNode:child toMenu:submenu];  // potentially recursive
     } else {
       [self tagEmptyMenu:submenu];
     }
   } else {
     [item setTarget:self];
@@ skipping 65 matching lines @@
 }
 
 // TODO(jrg): write a "build bar" so there is a nice spot for things
 // like the contextual menu which is invoked when not over a
 // bookmark.  On Safari that menu has a "new folder" option.
 - (void)addNodesToButtonList:(const BookmarkNode*)node {
   [self showOrHideNoItemContainerForNode:node];
 
   CGFloat maxViewX = NSMaxX([[self view] bounds]);
   int xOffset =
-      bookmarks::kBookmarkLeftMargin - bookmarks::kBookmarkHorizontalPadding;
+      bookmarks::BookmarkLeftMargin() - bookmarks::BookmarkHorizontalPadding();
 
   // Draw the apps bookmark if needed.
   if (![appsPageShortcutButton_ isHidden]) {
     NSRect frame =
         [self frameForBookmarkButtonFromCell:[appsPageShortcutButton_ cell]
                                      xOffset:&xOffset];
     [appsPageShortcutButton_ setFrame:frame];
   }
 
   // Draw the managed bookmark folder if needed.
   if (![managedBookmarksButton_ isHidden]) {
-    xOffset += bookmarks::kBookmarkHorizontalPadding;
+    xOffset += bookmarks::BookmarkHorizontalPadding();
     NSRect frame =
         [self frameForBookmarkButtonFromCell:[managedBookmarksButton_ cell]
                                      xOffset:&xOffset];
     [managedBookmarksButton_ setFrame:frame];
   }
 
   // Draw the supervised bookmark folder if needed.
   if (![supervisedBookmarksButton_ isHidden]) {
-    xOffset += bookmarks::kBookmarkHorizontalPadding;
+    xOffset += bookmarks::BookmarkHorizontalPadding();
     NSRect frame =
         [self frameForBookmarkButtonFromCell:[supervisedBookmarksButton_ cell]
                                      xOffset:&xOffset];
     [supervisedBookmarksButton_ setFrame:frame];
   }
 
   for (int i = 0; i < node->child_count(); i++) {
     const BookmarkNode* child = node->GetChild(i);
     BookmarkButton* button = [self buttonForNode:child xOffset:&xOffset];
     if (NSMinX([button frame]) >= maxViewX) {
@@ skipping 56 matching lines @@
 }
 
 // Add bookmark buttons to the view only if they are completely
 // visible and don't overlap the "other bookmarks".  Remove buttons
 // which are clipped.  Called when building the bookmark bar the first time.
 - (void)addButtonsToView {
   displayedButtonCount_ = 0;
   NSMutableArray* buttons = [self buttons];
   for (NSButton* button in buttons) {
     if (NSMaxX([button frame]) > (NSMinX([offTheSideButton_ frame]) -
-                                  bookmarks::kBookmarkHorizontalPadding))
+                                  bookmarks::BookmarkHorizontalPadding()))
       break;
     [buttonView_ addSubview:button];
     ++displayedButtonCount_;
   }
   NSUInteger removalCount =
       [buttons count] - (NSUInteger)displayedButtonCount_;
   if (removalCount > 0) {
     NSRange removalRange = NSMakeRange(displayedButtonCount_, removalCount);
     [buttons removeObjectsInRange:removalRange];
   }
@@ skipping 363 matching lines @@
       [self shrinkOrHideView:noItemTextfield forMaxX:maxViewX];
   }
 }
 
 // Scans through all buttons from left to right, calculating from scratch where
 // they should be based on the preceding widths, until it finds the one
 // requested.
 // Returns NSZeroRect if there is no such button in the bookmark bar.
 // Enables you to work out where a button will end up when it is done animating.
 - (NSRect)finalRectOfButton:(BookmarkButton*)wantedButton {
-  CGFloat left = bookmarks::kBookmarkLeftMargin;
+  CGFloat left = bookmarks::BookmarkLeftMargin();
   NSRect buttonFrame = NSZeroRect;
 
   // Draw the apps bookmark if needed.
   if (![appsPageShortcutButton_ isHidden]) {
     left = NSMaxX([appsPageShortcutButton_ frame]) +
-        bookmarks::kBookmarkHorizontalPadding;
+        bookmarks::BookmarkHorizontalPadding();
   }
 
   // Draw the managed bookmarks folder if needed.
   if (![managedBookmarksButton_ isHidden]) {
     left = NSMaxX([managedBookmarksButton_ frame]) +
-        bookmarks::kBookmarkHorizontalPadding;
+        bookmarks::BookmarkHorizontalPadding();
   }
 
   // Draw the supervised bookmarks folder if needed.
   if (![supervisedBookmarksButton_ isHidden]) {
     left = NSMaxX([supervisedBookmarksButton_ frame]) +
-        bookmarks::kBookmarkHorizontalPadding;
+        bookmarks::BookmarkHorizontalPadding();
   }
 
   for (NSButton* button in buttons_.get()) {
     // Hidden buttons get no space.
     if ([button isHidden])
       continue;
     buttonFrame = [button frame];
     buttonFrame.origin.x = left;
-    left += buttonFrame.size.width + bookmarks::kBookmarkHorizontalPadding;
+    left += buttonFrame.size.width + bookmarks::BookmarkHorizontalPadding();
     if (button == wantedButton)
       return buttonFrame;
   }
   return NSZeroRect;
 }
 
 // Calculates the final position of the last button in the bar.
 // We can't just use [[self buttons] lastObject] frame] because the button
 // may be animating currently.
 - (NSRect)finalRectOfLastButton {
   return [self finalRectOfButton:[[self buttons] lastObject]];
 }
 
 - (CGFloat)buttonViewMaxXWithOffTheSideButtonIsVisible:(BOOL)visible {
   CGFloat maxViewX = NSMaxX([buttonView_ bounds]);
   // If necessary, pull in the width to account for the Other Bookmarks button.
   if ([self setOtherBookmarksButtonVisibility]) {
     maxViewX = [otherBookmarksButton_ frame].origin.x -
-        bookmarks::kBookmarkRightMargin;
+        bookmarks::BookmarkRightMargin();
   }
 
   [self positionRightSideButtons];
   // If we're already overflowing, then we need to account for the chevron.
   if (visible) {
     maxViewX =
-        [offTheSideButton_ frame].origin.x - bookmarks::kBookmarkRightMargin;
+        [offTheSideButton_ frame].origin.x - bookmarks::BookmarkRightMargin();
   }
 
   return maxViewX;
 }
 
 - (void)redistributeButtonsOnBarAsNeeded {
   const BookmarkNode* node = bookmarkModel_->bookmark_bar_node();
   NSInteger barCount = node->child_count();
 
   // Determine the current maximum extent of the visible buttons.
@@ skipping 17 matching lines @@
     if (!offTheSideButtonVisible) {
       offTheSideButtonVisible = YES;
       maxViewX = [self buttonViewMaxXWithOffTheSideButtonIsVisible:YES];
     }
   }
 
   // As a result of cutting, deleting and dragging, the bar may now have room
   // for more buttons.
   int xOffset;
   if (displayedButtonCount_ > 0) {
-    xOffset = NSMaxX([self finalRectOfLastButton]) +
-        bookmarks::kBookmarkHorizontalPadding;
+    xOffset = NSMaxX([self finalRectOfLastButton]);
+
+    // Adding the padding here causes the distance between button 1 and 2 to
+    // be twice the padding instead of 1x. Pre-Material Design the padding was
+    // 1pt, so this bug was not noticeable. With MD's padding, this error puts
+    // 32pts of space between buttons.
+    if (!ui::MaterialDesignController::IsModeMaterial()) {
+      xOffset += bookmarks::BookmarkHorizontalPadding();
+    }
   } else if (![managedBookmarksButton_ isHidden]) {
     xOffset = NSMaxX([managedBookmarksButton_ frame]) +
-        bookmarks::kBookmarkHorizontalPadding;
+        bookmarks::BookmarkHorizontalPadding();
   } else if (![supervisedBookmarksButton_ isHidden]) {
     xOffset = NSMaxX([supervisedBookmarksButton_ frame]) +
-        bookmarks::kBookmarkHorizontalPadding;
+        bookmarks::BookmarkHorizontalPadding();
   } else if (![appsPageShortcutButton_ isHidden]) {
     xOffset = NSMaxX([appsPageShortcutButton_ frame]) +
-        bookmarks::kBookmarkHorizontalPadding;
+        bookmarks::BookmarkHorizontalPadding();
   } else {
-    xOffset = bookmarks::kBookmarkLeftMargin -
-        bookmarks::kBookmarkHorizontalPadding;
+    xOffset = bookmarks::BookmarkLeftMargin() -
+        bookmarks::BookmarkHorizontalPadding();
   }
   for (int i = displayedButtonCount_; i < barCount; ++i) {
     const BookmarkNode* child = node->GetChild(i);
     BookmarkButton* button = [self buttonForNode:child xOffset:&xOffset];
     // If we're testing against the last possible button then account
     // for the chevron no longer needing to be shown.
     if (i == barCount - 1)
       maxViewX = [self buttonViewMaxXWithOffTheSideButtonIsVisible:NO];
     if (NSMaxX([button frame]) > maxViewX) {
       [button setDelegate:nil];
@@ skipping 13 matching lines @@
 #pragma mark Private Methods Exposed for Testing
 
 - (BookmarkBarView*)buttonView {
   return buttonView_;
 }
 
 - (NSMutableArray*)buttons {
   return buttons_.get();
 }
 
-- (NSButton*)offTheSideButton {
-  return offTheSideButton_;
-}
-
 - (NSButton*)appsPageShortcutButton {
   return appsPageShortcutButton_;
 }
 
 - (BOOL)offTheSideButtonIsHidden {
   return [offTheSideButton_ isHidden];
 }
 
 - (BOOL)appsPageShortcutButtonIsHidden {
   return [appsPageShortcutButton_ isHidden];
@@ skipping 31 matching lines @@
   // can be important if a bookmark is deleted (via bookmark sync)
   // while in the middle of a drag.  The "drag completed" code
   // (e.g. [BookmarkBarView performDragOperationForBookmarkButton:]) is
   // careful enough to bail if there is no data found at "drop" time.
   [[NSPasteboard pasteboardWithName:NSDragPboard] clearContents];
 }
 
 // Return an autoreleased NSCell suitable for a bookmark button.
 // TODO(jrg): move much of the cell config into the BookmarkButtonCell class.
 - (BookmarkButtonCell*)cellForBookmarkNode:(const BookmarkNode*)node {
-  NSImage* image = node ? [self faviconForNode:node] : nil;
+  BOOL darkTheme = [[[self view] window] hasDarkTheme];
+  NSImage* image = node ? [self faviconForNode:node forADarkTheme:darkTheme]
+                        : nil;
   BookmarkButtonCell* cell =
       [BookmarkButtonCell buttonCellForNode:node
                                        text:nil
                                       image:image
                              menuController:contextMenuController_];
-  [cell setTag:kStandardButtonTypeWithLimitedClickFeedback];
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    [cell setTag:kMaterialStandardButtonTypeWithLimitedClickFeedback];
+  } else {
+    [cell setTag:kStandardButtonTypeWithLimitedClickFeedback];
+  }
 
   // Note: a quirk of setting a cell's text color is that it won't work
   // until the cell is associated with a button, so we can't theme the cell yet.
 
   return cell;
 }
 
 // Return an autoreleased NSCell suitable for a special button displayed on the
 // bookmark bar that is not attached to any bookmark node.
 // TODO(jrg): move much of the cell config into the BookmarkButtonCell class.
 - (BookmarkButtonCell*)cellForCustomButtonWithText:(NSString*)text
                                              image:(NSImage*)image {
   BookmarkButtonCell* cell =
       [BookmarkButtonCell buttonCellWithText:text
                                        image:image
                               menuController:contextMenuController_];
-  [cell setTag:kStandardButtonTypeWithLimitedClickFeedback];
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    [cell setTag:kMaterialStandardButtonTypeWithLimitedClickFeedback];
+  } else {
+    [cell setTag:kStandardButtonTypeWithLimitedClickFeedback];
+  }
 
   // Note: a quirk of setting a cell's text color is that it won't work
   // until the cell is associated with a button, so we can't theme the cell yet.
 
   return cell;
 }
 
 // Returns a frame appropriate for the given bookmark cell, suitable
 // for creating an NSButton that will contain it.  |xOffset| is the X
 // offset for the frame; it is increased to be an appropriate X offset
 // for the next button.
 - (NSRect)frameForBookmarkButtonFromCell:(NSCell*)cell
                                  xOffset:(int*)xOffset {
   DCHECK(xOffset);
   NSRect bounds = [buttonView_ bounds];
-  bounds.size.height = bookmarks::kBookmarkButtonHeight;
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    bounds.size.height = bookmarks::kMaterialBookmarkButtonHeight;
+  } else {
+    bounds.size.height = bookmarks::kBookmarkButtonHeight;
+  }
 
   NSRect frame = NSInsetRect(bounds,
-                             bookmarks::kBookmarkHorizontalPadding,
-                             bookmarks::kBookmarkVerticalPadding);
+                             bookmarks::BookmarkHorizontalPadding(),
+                             bookmarks::BookmarkVerticalPadding());
   frame.size.width = [self widthForBookmarkButtonCell:cell];
 
   // Add an X offset based on what we've already done
   frame.origin.x += *xOffset;
 
   // And up the X offset for next time.
   *xOffset = NSMaxX(frame);
 
   return frame;
 }
@@ skipping 282 matching lines @@
 // Set insertionPos_ and hasInsertionPos_, and make insertion space for a
 // hypothetical drop with the new button having a left edge of |where|.
 // Gets called only by our view.
 - (void)setDropInsertionPos:(CGFloat)where {
   if (!hasInsertionPos_ || where != insertionPos_) {
     insertionPos_ = where;
     hasInsertionPos_ = YES;
     CGFloat left;
     if (![supervisedBookmarksButton_ isHidden]) {
       left = NSMaxX([supervisedBookmarksButton_ frame]) +
-             bookmarks::kBookmarkHorizontalPadding;
+             bookmarks::BookmarkHorizontalPadding();
     } else if (![managedBookmarksButton_ isHidden]) {
       left = NSMaxX([managedBookmarksButton_ frame]) +
-             bookmarks::kBookmarkHorizontalPadding;
+             bookmarks::BookmarkHorizontalPadding();
     } else if (![appsPageShortcutButton_ isHidden]) {
       left = NSMaxX([appsPageShortcutButton_ frame]) +
-             bookmarks::kBookmarkHorizontalPadding;
+             bookmarks::BookmarkHorizontalPadding();
     } else {
-      left = bookmarks::kBookmarkLeftMargin;
+      left = bookmarks::BookmarkLeftMargin();
     }
     CGFloat paddingWidth = bookmarks::kDefaultBookmarkWidth;
     BookmarkButton* draggedButton = [BookmarkButton draggedButton];
     if (draggedButton) {
       paddingWidth = std::min(bookmarks::kDefaultBookmarkWidth,
                               NSWidth([draggedButton frame]));
     }
     // Put all the buttons where they belong, with all buttons to the right
     // of the insertion point shuffling right to make space for it.
     [NSAnimationContext beginGrouping];
     [[NSAnimationContext currentContext]
         setDuration:kDragAndDropAnimationDuration];
     for (NSButton* button in buttons_.get()) {
       // Hidden buttons get no space.
       if ([button isHidden])
         continue;
       NSRect buttonFrame = [button frame];
       buttonFrame.origin.x = left;
       // Update "left" for next time around.
       left += buttonFrame.size.width;
       if (left > insertionPos_)
         buttonFrame.origin.x += paddingWidth;
-      left += bookmarks::kBookmarkHorizontalPadding;
+      left += bookmarks::BookmarkHorizontalPadding();
       if (innerContentAnimationsEnabled_)
         [[button animator] setFrame:buttonFrame];
       else
         [button setFrame:buttonFrame];
     }
     [NSAnimationContext endGrouping];
   }
 }
 
 // Put all visible bookmark bar buttons in their normal locations, either with
 // or without animation according to the |animate| flag.
 // This is generally useful, so is called from various places internally.
 - (void)resetAllButtonPositionsWithAnimation:(BOOL)animate {
 
   // Position the apps bookmark if needed.
-  CGFloat left = bookmarks::kBookmarkLeftMargin;
+  CGFloat left = bookmarks::BookmarkLeftMargin();
   if (![appsPageShortcutButton_ isHidden]) {
-    int xOffset =
-        bookmarks::kBookmarkLeftMargin - bookmarks::kBookmarkHorizontalPadding;
+    int xOffset = bookmarks::BookmarkLeftMargin() -
+            bookmarks::BookmarkHorizontalPadding();
     NSRect frame =
         [self frameForBookmarkButtonFromCell:[appsPageShortcutButton_ cell]
                                      xOffset:&xOffset];
     [appsPageShortcutButton_ setFrame:frame];
-    left = xOffset + bookmarks::kBookmarkHorizontalPadding;
+    left = xOffset + bookmarks::BookmarkHorizontalPadding();
   }
 
   // Position the managed bookmarks folder if needed.
   if (![managedBookmarksButton_ isHidden]) {
     int xOffset = left;
     NSRect frame =
         [self frameForBookmarkButtonFromCell:[managedBookmarksButton_ cell]
                                      xOffset:&xOffset];
     [managedBookmarksButton_ setFrame:frame];
-    left = xOffset + bookmarks::kBookmarkHorizontalPadding;
+    left = xOffset + bookmarks::BookmarkHorizontalPadding();
   }
 
   // Position the supervised bookmarks folder if needed.
   if (![supervisedBookmarksButton_ isHidden]) {
     int xOffset = left;
     NSRect frame =
         [self frameForBookmarkButtonFromCell:[supervisedBookmarksButton_ cell]
                                      xOffset:&xOffset];
     [supervisedBookmarksButton_ setFrame:frame];
-    left = xOffset + bookmarks::kBookmarkHorizontalPadding;
+    left = xOffset + bookmarks::BookmarkHorizontalPadding();
   }
 
   animate &= innerContentAnimationsEnabled_;
 
   for (NSButton* button in buttons_.get()) {
     // Hidden buttons get no space.
     if ([button isHidden])
       continue;
     NSRect buttonFrame = [button frame];
     buttonFrame.origin.x = left;
-    left += buttonFrame.size.width + bookmarks::kBookmarkHorizontalPadding;
+    left += buttonFrame.size.width + bookmarks::BookmarkHorizontalPadding();
     if (animate)
       [[button animator] setFrame:buttonFrame];
     else
       [button setFrame:buttonFrame];
   }
 }
 
 // Clear insertion flag, remove insertion space and put all visible bookmark
 // bar buttons in their normal locations.
 // Gets called only by our view.
@@ skipping 108 matching lines @@
 // TODO(jrg): if the bookmark bar is open on launch, we see the
 // buttons all placed, then "scooted over" as the favicons load.  If
 // this looks bad I may need to change widthForBookmarkButtonCell to
 // add space for an image even if not there on the assumption that
 // favicons will eventually load.
 - (void)nodeFaviconLoaded:(BookmarkModel*)model
                      node:(const BookmarkNode*)node {
   for (BookmarkButton* button in buttons_.get()) {
     const BookmarkNode* cellnode = [button bookmarkNode];
     if (cellnode == node) {
+      BOOL darkTheme = [[[self view] window] hasDarkTheme];
+      NSImage* theImage = [self faviconForNode:node forADarkTheme:darkTheme];
       [[button cell] setBookmarkCellText:[button title]
-                                   image:[self faviconForNode:node]];
+                                   image:theImage];
       // Adding an image means we might need more room for the
       // bookmark.  Test for it by growing the button (if needed)
       // and shifting everything else over.
       [self checkForBookmarkButtonGrowth:button];
       return;
     }
   }
 
   if (folderController_)
     [folderController_ faviconLoadedForNode:node];
@@ skipping 142 matching lines @@
   [self resetAllButtonPositionsWithAnimation:YES];
 }
 
 
 #pragma mark BookmarkButtonControllerProtocol
 
 // Close all bookmark folders.  "Folder" here is the fake menu for
 // bookmark folders, not a button context menu.
 - (void)closeAllBookmarkFolders {
   [self watchForExitEvent:NO];
+
+  // Grab the parent button under Material Design to make sure that the
+  // highlighting that was applied while revealing the menu is turned off.
+  BookmarkButton* parentButton = nil;
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    parentButton = [folderController_ parentButton];
+  }
   [folderController_ close];
+  [[parentButton cell] setHighlighted:NO];
+  [parentButton setNeedsDisplay:YES];
   folderController_ = nil;
 }
 
 - (void)closeBookmarkFolder:(id)sender {
   // We're the top level, so close one means close them all.
   [self closeAllBookmarkFolders];
 }
 
 - (BookmarkModel*)bookmarkModel {
   return bookmarkModel_;
@@ skipping 122 matching lines @@
 }
 
 // Return YES if we should show the drop indicator, else NO.
 - (BOOL)shouldShowIndicatorShownForPoint:(NSPoint)point {
   return ![self buttonForDroppingOnAtPoint:point];
 }
 
 // Return the x position for a drop indicator.
 - (CGFloat)indicatorPosForDragToPoint:(NSPoint)point {
   CGFloat x = 0;
-  CGFloat halfHorizontalPadding = 0.5 * bookmarks::kBookmarkHorizontalPadding;
+  CGFloat halfHorizontalPadding = 0.5 * bookmarks::BookmarkHorizontalPadding();
   int destIndex = [self indexForDragToPoint:point];
   int numButtons = displayedButtonCount_;
 
   CGFloat leftmostX;
   if (![supervisedBookmarksButton_ isHidden]) {
     leftmostX =
         NSMaxX([supervisedBookmarksButton_ frame]) + halfHorizontalPadding;
   } else if (![managedBookmarksButton_ isHidden]) {
     leftmostX = NSMaxX([managedBookmarksButton_ frame]) + halfHorizontalPadding;
   } else if (![appsPageShortcutButton_ isHidden]) {
     leftmostX = NSMaxX([appsPageShortcutButton_ frame]) + halfHorizontalPadding;
   } else {
-    leftmostX = bookmarks::kBookmarkLeftMargin - halfHorizontalPadding;
+    leftmostX = bookmarks::BookmarkLeftMargin() - halfHorizontalPadding;
   }
 
   // If it's a drop strictly between existing buttons ...
   if (destIndex == 0) {
     x = leftmostX;
   } else if (destIndex > 0 && destIndex < numButtons) {
     // ... put the indicator right between the buttons.
     BookmarkButton* button =
         [buttons_ objectAtIndex:static_cast<NSUInteger>(destIndex-1)];
     DCHECK(button);
@@ skipping 82 matching lines @@
 - (void)openAll:(const BookmarkNode*)node
     disposition:(WindowOpenDisposition)disposition {
   [self closeFolderAndStopTrackingMenus];
   chrome::OpenAll([[self view] window], browser_, node, disposition,
                   browser_->profile());
 }
 
 - (void)addButtonForNode:(const BookmarkNode*)node
                  atIndex:(NSInteger)buttonIndex {
   int newOffset =
-      bookmarks::kBookmarkLeftMargin - bookmarks::kBookmarkHorizontalPadding;
+      bookmarks::BookmarkLeftMargin() - bookmarks::BookmarkHorizontalPadding();
   if (buttonIndex == -1)
     buttonIndex = [buttons_ count];  // New button goes at the end.
   if (buttonIndex <= (NSInteger)[buttons_ count]) {
     if (buttonIndex) {
       BookmarkButton* targetButton = [buttons_ objectAtIndex:buttonIndex - 1];
       NSRect targetFrame = [targetButton frame];
       newOffset = targetFrame.origin.x + NSWidth(targetFrame) +
-          bookmarks::kBookmarkHorizontalPadding;
+          bookmarks::BookmarkHorizontalPadding();
     }
     BookmarkButton* newButton = [self buttonForNode:node xOffset:&newOffset];
     ++displayedButtonCount_;
     [buttons_ insertObject:newButton atIndex:buttonIndex];
     [buttonView_ addSubview:newButton];
     [self resetAllButtonPositionsWithAnimation:NO];
     // See if any buttons need to be pushed off to or brought in from the side.
     [self reconfigureBookmarkBar];
   } else  {
     // A button from somewhere else (not the bar) is being moved to the
@@ skipping 121 matching lines @@
 - (id<BookmarkButtonControllerProtocol>)controllerForNode:
     (const BookmarkNode*)node {
   // See if it's in the bar, then if it is in the hierarchy of visible
   // folder menus.
   if (bookmarkModel_->bookmark_bar_node() == node)
     return self;
   return [folderController_ controllerForNode:node];
 }
 
 @end