Remove pre-MD code from bookmark bar (Views).

chrome/browser/ui/views/bookmarks/bookmark_bar_view.cc

 // 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.
 
 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
-#include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/bookmarks/bookmark_bar_constants.h"
 #include "chrome/browser/ui/bookmarks/bookmark_drag_drop.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 #include "chrome/browser/ui/bookmarks/bookmark_utils.h"
 #include "chrome/browser/ui/bookmarks/bookmark_utils_desktop.h"
@@ skipping 18 matching lines @@
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/common/bookmark_pref_names.h"
 #include "components/bookmarks/managed/managed_bookmark_service.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/metrics/metrics_service.h"
 #include "components/omnibox/browser/omnibox_popup_model.h"
 #include "components/omnibox/browser/omnibox_view.h"
 #include "components/prefs/pref_service.h"
 #include "components/url_formatter/elide_url.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_source.h"
-#include "content/public/browser/page_navigator.h"
-#include "content/public/browser/render_view_host.h"
-#include "content/public/browser/render_widget_host_view.h"
 #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 "ui/accessibility/ax_view_state.h"
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/base/window_open_disposition.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/geometry/rect.h"
@@ skipping 30 matching lines @@
 using views::LabelButtonBorder;
 using views::MenuButton;
 using views::View;
 
 // How inset the bookmarks bar is when displayed on the new tab page.
 static const int kNewTabHorizontalPadding = 2;
 
 // Maximum size of buttons on the bookmark bar.
 static const int kMaxButtonWidth = 150;
 
-// The color gradient start value close to the edge of the divider.
-static const SkColor kEdgeDividerColor = SkColorSetRGB(222, 234, 248);
-
-// The color gradient value for the middle of the divider.
-static const SkColor kMiddleDividerColor = SkColorSetRGB(194, 205, 212);
-
 // Number of pixels the attached bookmark bar overlaps with the toolbar.
 static const int kToolbarAttachedBookmarkBarOverlap = 3;
 
 // Margins around the content.
 static const int kDetachedTopMargin = 1;  // When attached, we use 0 and let the
                                           // toolbar above serve as the margin.
 static const int kBottomMargin = 2;
-// The margin at the start and end of the bar, in dp, indexed by MD mode.
-static const int kHorizontalMargin[] = {1, 4, 4};
+static const int kHorizontalMargin = 4;
 
 // Padding between buttons.
 static const int kButtonPadding = 0;
 
-// Color of the drop indicator.
-static const SkColor kDropIndicatorColor = SK_ColorBLACK;
-
 // Width of the drop indicator.
 static const int kDropIndicatorWidth = 2;
 
 // Distance between the bottom of the bar and the separator.
 static const int kSeparatorMargin = 1;
 
 // Width of the separator between the recently bookmarked button and the
-// overflow indicator, indexed by MD mode.
-static const int kSeparatorWidth[] = {4, 9, 9};
-
-// Starting x-coordinate of the separator line within a separator.
-static const int kSeparatorStartX = 2;
+// overflow indicator.
+static const int kSeparatorWidth = 9;
 
 // Left-padding for the instructional text.
 static const int kInstructionsPadding = 6;
 
 // Tag for the 'Apps Shortcut' button.
 static const int kAppsShortcutButtonTag = 2;
 
 // Preferred padding between text and edge.
 static const int kButtonPaddingHorizontal = 6;
 static const int kButtonPaddingVertical = 5;
 
 static const gfx::ElideBehavior kElideBehavior = gfx::FADE_TAIL;
 
 namespace {
 
 // To enable/disable BookmarkBar animations during testing. In production
 // animations are enabled by default.
 bool animations_enabled = true;
 
 gfx::ImageSkia* GetImageSkiaNamed(int id) {
   return ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(id);
 }
 
-int GetHorizontalMargin() {
-  return kHorizontalMargin[ui::MaterialDesignController::GetMode()];
-}
-
 gfx::Rect CalculateInkDropBounds(const gfx::Size& size) {
   gfx::Rect ink_drop_bounds(size);
   ink_drop_bounds.Inset(0, 1);
   return ink_drop_bounds;
 }
 
 // BookmarkButtonBase -----------------------------------------------
 
 // Base class for non-menu hosting buttons used on the bookmark bar.
 
 class BookmarkButtonBase : public views::LabelButton {
  public:
   BookmarkButtonBase(views::ButtonListener* listener,
                      const base::string16& title)
       : LabelButton(listener, title) {
     SetElideBehavior(kElideBehavior);
-    if (ui::MaterialDesignController::IsModeMaterial()) {
-      SetInkDropMode(InkDropMode::ON);
-      set_has_ink_drop_action_on_click(true);
-      SetFocusPainter(nullptr);
-    }
+    SetInkDropMode(InkDropMode::ON);
+    set_has_ink_drop_action_on_click(true);
+    SetFocusPainter(nullptr);
     show_animation_.reset(new gfx::SlideAnimation(this));
     if (!animations_enabled) {
       // For some reason during testing the events generated by animating
       // throw off the test. So, don't animate while testing.
       show_animation_->Reset(1);
     } else {
       show_animation_->Show();
     }
   }
 
   View* GetTooltipHandlerForPoint(const gfx::Point& point) override {
-    return HitTestPoint(point) && CanProcessEventsWithinSubtree() ? this : NULL;
+    return HitTestPoint(point) && CanProcessEventsWithinSubtree() ? this
+                                                                  : nullptr;
   }
 
   std::unique_ptr<LabelButtonBorder> CreateDefaultBorder() const override {
     std::unique_ptr<LabelButtonBorder> border =
         LabelButton::CreateDefaultBorder();
     border->set_insets(gfx::Insets(kButtonPaddingVertical,
                                    kButtonPaddingHorizontal,
                                    kButtonPaddingVertical,
                                    kButtonPaddingHorizontal));
     return border;
@@ skipping 93 matching lines @@
 
 // BookmarkMenuButtonBase -----------------------------------------------------
 
 // Base class for menu hosting buttons used on the bookmark bar.
 class BookmarkMenuButtonBase : public views::MenuButton {
  public:
   BookmarkMenuButtonBase(const base::string16& title,
                          views::MenuButtonListener* menu_button_listener,
                          bool show_menu_marker)
       : MenuButton(title, menu_button_listener, show_menu_marker) {
-    if (ui::MaterialDesignController::IsModeMaterial()) {
-      SetInkDropMode(InkDropMode::ON);
-      SetFocusPainter(nullptr);
-    }
+    SetInkDropMode(InkDropMode::ON);
+    SetFocusPainter(nullptr);
   }
 
   std::unique_ptr<views::InkDropRipple> CreateInkDropRipple() const override {
     return base::MakeUnique<views::FloodFillInkDropRipple>(
         CalculateInkDropBounds(size()), GetInkDropCenterBasedOnLastEvent(),
         GetInkDropBaseColor(), ink_drop_visible_opacity());
   }
 
   std::unique_ptr<views::InkDropHighlight> CreateInkDropHighlight()
       const override {
@@ skipping 151 matching lines @@
   int y;
 
   // DropData for the drop.
   BookmarkNodeData data;
 
   DropLocation location;
 };
 
 // ButtonSeparatorView  --------------------------------------------------------
 
-// Paints a themed gradient divider at location |x|. |height| is the full
-// height of the view you want to paint the divider into, not the height of
-// the divider. The height of the divider will become:
-//   |height| - 2 * |vertical_padding|.
-// The color of the divider is a gradient starting with |top_color| at the
-// top, and changing into |middle_color| and then over to |bottom_color| as
-// you go further down.
-void PaintVerticalDivider(gfx::Canvas* canvas,
-                          int x,
-                          int height,
-                          int vertical_padding,
-                          SkColor top_color,
-                          SkColor middle_color,
-                          SkColor bottom_color) {
-  // Draw the upper half of the divider.
-  SkPaint paint;
-  paint.setShader(gfx::CreateGradientShader(
-      vertical_padding + 1, height / 2, top_color, middle_color));
-  SkRect rc = { SkIntToScalar(x),
-                SkIntToScalar(vertical_padding + 1),
-                SkIntToScalar(x + 1),
-                SkIntToScalar(height / 2) };
-  canvas->sk_canvas()->drawRect(rc, paint);
-
-  // Draw the lower half of the divider.
-  SkPaint paint_down;
-  paint_down.setShader(gfx::CreateGradientShader(
-      height / 2, height - vertical_padding, middle_color, bottom_color));
-  SkRect rc_down = { SkIntToScalar(x),
-                     SkIntToScalar(height / 2),
-                     SkIntToScalar(x + 1),
-                     SkIntToScalar(height - vertical_padding) };
-  canvas->sk_canvas()->drawRect(rc_down, paint_down);
-}
-
 class BookmarkBarView::ButtonSeparatorView : public views::View {
  public:
   ButtonSeparatorView() {}
   ~ButtonSeparatorView() override {}
 
   void OnPaint(gfx::Canvas* canvas) override {
-    if (ui::MaterialDesignController::IsModeMaterial()) {
-      gfx::ScopedCanvas scoped_canvas(canvas);
-      // 1px wide at all scale factors. If there is an uneven amount of padding
-      // left over, place the extra pixel on the outside, i.e. away from the
-      // "Other bookmarks" folder.
-      const float scale = canvas->UndoDeviceScaleFactor();
-      const gfx::RectF scaled_bounds =
-          gfx::ScaleRect(gfx::RectF(bounds()), scale);
+    gfx::ScopedCanvas scoped_canvas(canvas);
+    // 1px wide at all scale factors. If there is an uneven amount of padding
+    // left over, place the extra pixel on the outside, i.e. away from the
+    // "Other bookmarks" folder.
+    const float scale = canvas->UndoDeviceScaleFactor();
+    const gfx::RectF scaled_bounds =
+        gfx::ScaleRect(gfx::RectF(bounds()), scale);
 
-      const int kLineThickness = 1;
-      const float fractional_x = (scaled_bounds.width() - kLineThickness) / 2.f;
-      const int x = base::i18n::IsRTL() ? std::floor(fractional_x)
-                                        : std::ceil(fractional_x);
+    const int kLineThickness = 1;
+    const float fractional_x = (scaled_bounds.width() - kLineThickness) / 2.f;
+    const int x = base::i18n::IsRTL() ? std::floor(fractional_x)
+                                      : std::ceil(fractional_x);
 
-      const int height = gfx::kFaviconSize * scale;
-      const int top_y = (scaled_bounds.height() - height) / 2;
-      canvas->DrawLine(gfx::Point(x, top_y), gfx::Point(x, top_y + height),
-                       GetThemeProvider()->GetColor(
-                           ThemeProperties::COLOR_TOOLBAR_VERTICAL_SEPARATOR));
-    } else {
-      PaintVerticalDivider(
-          canvas, kSeparatorStartX, height(), 1, kEdgeDividerColor,
-          kMiddleDividerColor,
-          GetThemeProvider()->GetColor(ThemeProperties::COLOR_TOOLBAR));
-    }
+    const int height = gfx::kFaviconSize * scale;
+    const int top_y = (scaled_bounds.height() - height) / 2;
+    canvas->DrawLine(gfx::Point(x, top_y), gfx::Point(x, top_y + height),
+                     GetThemeProvider()->GetColor(
+                         ThemeProperties::COLOR_TOOLBAR_VERTICAL_SEPARATOR));
   }
 
   gfx::Size GetPreferredSize() const override {
     // We get the full height of the bookmark bar, so that the height returned
     // here doesn't matter.
-    return gfx::Size(kSeparatorWidth[ui::MaterialDesignController::GetMode()],
-                     1);
+    return gfx::Size(kSeparatorWidth, 1);
   }
 
   void GetAccessibleState(ui::AXViewState* state) override {
     state->name = l10n_util::GetStringUTF16(IDS_ACCNAME_SEPARATOR);
     state->role = ui::AX_ROLE_SPLITTER;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ButtonSeparatorView);
 };
 
 // BookmarkBarView ------------------------------------------------------------
 
 // static
 const char BookmarkBarView::kViewClassName[] = "BookmarkBarView";
 
 BookmarkBarView::BookmarkBarView(Browser* browser, BrowserView* browser_view)
-    : page_navigator_(NULL),
-      managed_(NULL),
-      bookmark_menu_(NULL),
-      bookmark_drop_menu_(NULL),
-      other_bookmarks_button_(NULL),
-      managed_bookmarks_button_(NULL),
-      supervised_bookmarks_button_(NULL),
-      apps_page_shortcut_(NULL),
-      overflow_button_(NULL),
-      instructions_(NULL),
-      bookmarks_separator_view_(NULL),
+    : page_navigator_(nullptr),
+      managed_(nullptr),
+      bookmark_menu_(nullptr),
+      bookmark_drop_menu_(nullptr),
+      other_bookmarks_button_(nullptr),
+      managed_bookmarks_button_(nullptr),
+      supervised_bookmarks_button_(nullptr),
+      apps_page_shortcut_(nullptr),
+      overflow_button_(nullptr),
+      instructions_(nullptr),
+      bookmarks_separator_view_(nullptr),
       browser_(browser),
       browser_view_(browser_view),
       infobar_visible_(false),
       size_animation_(this),
-      throbbing_view_(NULL),
+      throbbing_view_(nullptr),
       bookmark_bar_state_(BookmarkBar::SHOW),
       animating_detached_(false),
       show_folder_method_factory_(this) {
   set_id(VIEW_ID_BOOKMARK_BAR);
   Init();
 
-  if (ui::MaterialDesignController::IsModeMaterial()) {
-    // Don't let the bookmarks show on top of the location bar while animating.
-    SetPaintToLayer(true);
-    layer()->SetMasksToBounds(true);
-    layer()->SetFillsBoundsOpaquely(false);
-  }
+  // Don't let the bookmarks show on top of the location bar while animating.
+  SetPaintToLayer(true);
+  layer()->SetMasksToBounds(true);
+  layer()->SetFillsBoundsOpaquely(false);
 
   size_animation_.Reset(1);
 }
 
 BookmarkBarView::~BookmarkBarView() {
   if (model_)
     model_->RemoveObserver(this);
 
   // It's possible for the menu to outlive us, reset the observer to make sure
   // it doesn't have a reference to us.
   if (bookmark_menu_) {
-    bookmark_menu_->set_observer(NULL);
-    bookmark_menu_->SetPageNavigator(NULL);
+    bookmark_menu_->set_observer(nullptr);
+    bookmark_menu_->SetPageNavigator(nullptr);
     bookmark_menu_->clear_bookmark_bar();
   }
   if (context_menu_.get())
-    context_menu_->SetPageNavigator(NULL);
+    context_menu_->SetPageNavigator(nullptr);
 
   StopShowFolderDropMenuTimer();
 }
 
 // static
 void BookmarkBarView::DisableAnimationsForTesting(bool disabled) {
   animations_enabled = !disabled;
 }
 
 void BookmarkBarView::AddObserver(BookmarkBarViewObserver* observer) {
@@ skipping 28 matching lines @@
   }
   bookmark_bar_state_ = state;
 }
 
 const BookmarkNode* BookmarkBarView::GetNodeForButtonAtModelIndex(
     const gfx::Point& loc,
     int* model_start_index) {
   *model_start_index = 0;
 
   if (loc.x() < 0 || loc.x() >= width() || loc.y() < 0 || loc.y() >= height())
-    return NULL;
+    return nullptr;
 
   gfx::Point adjusted_loc(GetMirroredXInView(loc.x()), loc.y());
 
   // Check the managed button first.
   if (managed_bookmarks_button_->visible() &&
       managed_bookmarks_button_->bounds().Contains(adjusted_loc)) {
     return managed_->managed_node();
   }
 
   // Then check the supervised button.
@@ skipping 17 matching lines @@
     *model_start_index = GetFirstHiddenNodeIndex();
     return model_->bookmark_bar_node();
   }
 
   // And finally the other folder.
   if (other_bookmarks_button_->visible() &&
       other_bookmarks_button_->bounds().Contains(adjusted_loc)) {
     return model_->other_node();
   }
 
-  return NULL;
+  return nullptr;
 }
 
 views::MenuButton* BookmarkBarView::GetMenuButtonForNode(
     const BookmarkNode* node) {
   if (node == managed_->managed_node())
     return managed_bookmarks_button_;
   if (node == managed_->supervised_node())
     return supervised_bookmarks_button_;
   if (node == model_->other_node())
     return other_bookmarks_button_;
   if (node == model_->bookmark_bar_node())
     return overflow_button_;
   int index = model_->bookmark_bar_node()->GetIndexOf(node);
   if (index == -1 || !node->is_folder())
-    return NULL;
+    return nullptr;
   return static_cast<views::MenuButton*>(child_at(index));
 }
 
 void BookmarkBarView::GetAnchorPositionForButton(
     views::MenuButton* button,
     views::MenuAnchorPosition* anchor) {
   if (button == other_bookmarks_button_ || button == overflow_button_)
     *anchor = views::MENU_ANCHOR_TOPRIGHT;
   else
     *anchor = views::MENU_ANCHOR_TOPLEFT;
 }
 
 views::MenuItemView* BookmarkBarView::GetMenu() {
-  return bookmark_menu_ ? bookmark_menu_->menu() : NULL;
+  return bookmark_menu_ ? bookmark_menu_->menu() : nullptr;
 }
 
 views::MenuItemView* BookmarkBarView::GetContextMenu() {
-  return bookmark_menu_ ? bookmark_menu_->context_menu() : NULL;
+  return bookmark_menu_ ? bookmark_menu_->context_menu() : nullptr;
 }
 
 views::MenuItemView* BookmarkBarView::GetDropMenu() {
-  return bookmark_drop_menu_ ? bookmark_drop_menu_->menu() : NULL;
+  return bookmark_drop_menu_ ? bookmark_drop_menu_->menu() : nullptr;
 }
 
 void BookmarkBarView::StopThrobbing(bool immediate) {
   if (!throbbing_view_)
     return;
 
   // If not immediate, cycle through 2 more complete cycles.
   throbbing_view_->StartThrobbing(immediate ? 0 : 4);
-  throbbing_view_ = NULL;
+  throbbing_view_ = nullptr;
 }
 
 // static
 base::string16 BookmarkBarView::CreateToolTipForURLAndTitle(
     const views::Widget* widget,
     const gfx::Point& screen_loc,
     const GURL& url,
     const base::string16& title) {
   const views::TooltipManager* tooltip_manager = widget->GetTooltipManager();
   int max_width = tooltip_manager->GetMaxWidth(screen_loc);
@@ skipping 89 matching lines @@
   }
   return true;
 }
 
 gfx::Size BookmarkBarView::GetMinimumSize() const {
   // The minimum width of the bookmark bar should at least contain the overflow
   // button, by which one can access all the Bookmark Bar items, and the "Other
   // Bookmarks" folder, along with appropriate margins and button padding.
   // It should also contain the Managed and/or Supervised Bookmarks folders,
   // if they are visible.
-  int width = GetHorizontalMargin();
+  int width = kHorizontalMargin;
 
   int height = GetPreferredHeight();
   if (IsDetached()) {
     double current_state = 1 - size_animation_.GetCurrentValue();
     width += 2 * static_cast<int>(kNewTabHorizontalPadding * current_state);
     height += static_cast<int>((chrome::kNTPBookmarkBarHeight - height) *
                                current_state);
   }
 
   if (managed_bookmarks_button_->visible()) {
@@ skipping 22 matching lines @@
   }
 
   return gfx::Size(width, height);
 }
 
 void BookmarkBarView::Layout() {
   // Skip layout during destruction, when no model exists.
   if (!model_)
     return;
 
-  int x = GetHorizontalMargin();
+  int x = kHorizontalMargin;
   int top_margin = IsDetached() ? kDetachedTopMargin : 0;
   int y = top_margin;
-  int width = View::width() - 2 * GetHorizontalMargin();
+  int width = View::width() - 2 * kHorizontalMargin;
   int preferred_height = GetPreferredHeight();
   int height = preferred_height - kBottomMargin;
   int separator_margin = kSeparatorMargin;
 
   if (IsDetached()) {
     double current_state = 1 - size_animation_.GetCurrentValue();
     x += static_cast<int>(kNewTabHorizontalPadding * current_state);
     y += (View::height() - preferred_height) / 2;
     width -= static_cast<int>(kNewTabHorizontalPadding * current_state);
     separator_margin -= static_cast<int>(kSeparatorMargin * current_state);
@@ skipping 135 matching lines @@
       drop_info_->location.operation != 0 && drop_info_->location.index != -1 &&
       drop_info_->location.button_type != DROP_OVERFLOW &&
       !drop_info_->location.on) {
     int index = drop_info_->location.index;
     DCHECK(index <= GetBookmarkButtonCount());
     int x = 0;
     int y = 0;
     int h = height();
     if (index == GetBookmarkButtonCount()) {
       if (index == 0) {
-        x = GetHorizontalMargin();
+        x = kHorizontalMargin;
       } else {
         x = GetBookmarkButton(index - 1)->x() +
             GetBookmarkButton(index - 1)->width();
       }
     } else {
       x = GetBookmarkButton(index)->x();
     }
     if (GetBookmarkButtonCount() > 0 && GetBookmarkButton(0)->visible()) {
       y = GetBookmarkButton(0)->y();
       h = GetBookmarkButton(0)->height();
     }
 
     // Since the drop indicator is painted directly onto the canvas, we must
     // make sure it is painted in the right location if the locale is RTL.
     gfx::Rect indicator_bounds(x - kDropIndicatorWidth / 2,
                                y,
                                kDropIndicatorWidth,
                                h);
     indicator_bounds.set_x(GetMirroredXForRect(indicator_bounds));
 
     ui::PaintRecorder recorder(context, size());
     // TODO(sky/glen): make me pretty!
-    recorder.canvas()->FillRect(indicator_bounds, kDropIndicatorColor);
+    recorder.canvas()->FillRect(
+        indicator_bounds,
+        GetThemeProvider()->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT));
   }
 }
 
 bool BookmarkBarView::GetDropFormats(
     int* formats,
     std::set<ui::Clipboard::FormatType>* format_types) {
   if (!model_ || !model_->loaded())
     return false;
   *formats = ui::OSExchangeData::URL;
   format_types->insert(BookmarkNodeData::GetBookmarkFormatType());
@@ skipping 140 matching lines @@
                       OnBookmarkBarVisibilityChanged());
   }
 }
 
 void BookmarkBarView::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_TOOLBAR;
   state->name = l10n_util::GetStringUTF16(IDS_ACCNAME_BOOKMARKS);
 }
 
 void BookmarkBarView::AnimationProgressed(const gfx::Animation* animation) {
-  // |browser_view_| can be NULL during tests.
+  // |browser_view_| can be nullptr during tests.

[Peter Kasting, 2016/09/22 03:23:27]

Nit: Prefer "null" to "nullptr" in comments, it just reads a little more nicely
(multiple places)

[Evan Stade, 2016/09/22 14:35:27]

Done.

   if (browser_view_)
     browser_view_->ToolbarSizeChanged(true);
 }
 
 void BookmarkBarView::AnimationEnded(const gfx::Animation* animation) {
-  // |browser_view_| can be NULL during tests.
+  // |browser_view_| can be nullptr during tests.
   if (browser_view_) {
     browser_view_->ToolbarSizeChanged(false);
     SchedulePaint();
   }
 }
 
 void BookmarkBarView::BookmarkMenuControllerDeleted(
     BookmarkMenuController* controller) {
   if (controller == bookmark_menu_)
-    bookmark_menu_ = NULL;
+    bookmark_menu_ = nullptr;
   else if (controller == bookmark_drop_menu_)
-    bookmark_drop_menu_ = NULL;
+    bookmark_drop_menu_ = nullptr;
 }
 
 void BookmarkBarView::OnImportBookmarks() {
   int64_t install_time = g_browser_process->metrics_service()->GetInstallDate();
   int64_t time_from_install = base::Time::Now().ToTimeT() - install_time;
   if (bookmark_bar_state_ == BookmarkBar::SHOW) {
     UMA_HISTOGRAM_COUNTS("Import.ShowDialog.FromBookmarkBarView",
                          time_from_install);
   } else if (bookmark_bar_state_ == BookmarkBar::DETACHED) {
     UMA_HISTOGRAM_COUNTS("Import.ShowDialog.FromFloatingBookmarkBarView",
@@ skipping 35 matching lines @@
   other_bookmarks_button_->SetEnabled(true);
   managed_bookmarks_button_->SetEnabled(true);
   supervised_bookmarks_button_->SetEnabled(true);
   LayoutAndPaint();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   NOTREACHED();
   // Do minimal cleanup, presumably we'll be deleted shortly.
   model_->RemoveObserver(this);
-  model_ = NULL;
+  model_ = nullptr;
 }
 
 void BookmarkBarView::BookmarkNodeMoved(BookmarkModel* model,
                                         const BookmarkNode* old_parent,
                                         int old_index,
                                         const BookmarkNode* new_parent,
                                         int new_index) {
   bool was_throbbing = throbbing_view_ &&
       throbbing_view_ == DetermineViewToThrobFromRemove(old_parent, old_index);
   if (was_throbbing)
@@ skipping 255 matching lines @@
 
   context_menu_.reset(new BookmarkContextMenu(
       GetWidget(), browser_, browser_->profile(),
       browser_->tab_strip_model()->GetActiveWebContents(),
       parent, nodes, close_on_remove));
   context_menu_->RunMenuAt(point, source_type);
 }
 
 void BookmarkBarView::Init() {
   // Note that at this point we're not in a hierarchy so GetThemeProvider() will
-  // return NULL.  When we're inserted into a hierarchy, we'll call
+  // return nullptr.  When we're inserted into a hierarchy, we'll call
   // UpdateAppearanceForTheme(), which will set the appropriate colors for all
-  // the objects
-  // added in this function.
+  // the objects added in this function.
 
   // Child views are traversed in the order they are added. Make sure the order
   // they are added matches the visual order.
   overflow_button_ = CreateOverflowButton();
   AddChildView(overflow_button_);
 
   other_bookmarks_button_ = CreateOtherBookmarksButton();
   // We'll re-enable when the model is loaded.
   other_bookmarks_button_->SetEnabled(false);
   AddChildView(other_bookmarks_button_);
@@ skipping 546 matching lines @@
     return;
   apps_page_shortcut_->SetVisible(visible);
   UpdateBookmarksSeparatorVisibility();
   LayoutAndPaint();
 }
 
 void BookmarkBarView::OnShowManagedBookmarksPrefChanged() {
   if (UpdateOtherAndManagedButtonsVisibility())
     LayoutAndPaint();
 }