Get rid of some lingering MD-specific raster assets.

chrome/browser/ui/views/toolbar/chevron_menu_button.cc

-// Copyright 2014 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/toolbar/chevron_menu_button.h"
-
-#include <stddef.h>
-
-#include "base/location.h"
-#include "base/macros.h"
-#include "base/memory/scoped_vector.h"
-#include "base/single_thread_task_runner.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/thread_task_runner_handle.h"
-#include "chrome/browser/extensions/extension_action.h"
-#include "chrome/browser/extensions/extension_action_icon_factory.h"
-#include "chrome/browser/extensions/extension_context_menu_model.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/extensions/extension_action_view_controller.h"
-#include "chrome/browser/ui/views/extensions/browser_action_drag_data.h"
-#include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
-#include "chrome/browser/ui/views/toolbar/toolbar_action_view.h"
-#include "extensions/common/extension.h"
-#include "ui/views/border.h"
-#include "ui/views/controls/button/label_button_border.h"
-#include "ui/views/controls/menu/menu_delegate.h"
-#include "ui/views/controls/menu/menu_item_view.h"
-#include "ui/views/controls/menu/menu_runner.h"
-#include "ui/views/metrics.h"
-
-namespace {
-
-// In the browser actions container's chevron menu, a menu item view's icon
-// comes from ToolbarActionView::GetIconWithBadge() when the menu item view is
-// created. But, the browser action's icon may not be loaded in time because it
-// is read from file system in another thread.
-// The IconUpdater will update the menu item view's icon when the browser
-// action's icon has been updated.
-class IconUpdater : public ExtensionActionIconFactory::Observer {
- public:
-  IconUpdater(views::MenuItemView* menu_item_view,
-              ToolbarActionView* represented_view)
-      : menu_item_view_(menu_item_view),
-        represented_view_(represented_view) {
-    DCHECK(menu_item_view);
-    DCHECK(represented_view);
-    view_controller()->set_icon_observer(this);

[Devlin, 2016/05/11 00:01:02]

I think ExtensionActionViewController::set_icon_observer (and icon_observer_)
can be removed now.

[Evan Stade, 2016/05/11 21:05:35]

Done.

-  }
-  ~IconUpdater() override { view_controller()->set_icon_observer(nullptr); }
-
-  // ExtensionActionIconFactory::Observer:
-  void OnIconUpdated() override {
-    menu_item_view_->SetIcon(
-        represented_view_->GetImage(views::Button::STATE_NORMAL));
-  }
-
- private:
-  ExtensionActionViewController* view_controller() {
-    // Since the chevron overflow menu is only used in a world where toolbar
-    // actions are only extensions, this cast is safe.
-    return static_cast<ExtensionActionViewController*>(
-        represented_view_->view_controller());
-  }
-
-  // The menu item view whose icon might be updated.
-  views::MenuItemView* menu_item_view_;
-
-  // The view this icon updater is helping represent in the chevron overflow
-  // menu. When its icon changes, this updates the corresponding menu item
-  // view's icon.
-  ToolbarActionView* represented_view_;
-
-  DISALLOW_COPY_AND_ASSIGN(IconUpdater);
-};
-
-}  // namespace
-
-// This class handles the overflow menu for browser actions.
-class ChevronMenuButton::MenuController : public views::MenuDelegate {
- public:
-  MenuController(ChevronMenuButton* owner,
-                 BrowserActionsContainer* browser_actions_container,
-                 bool for_drop);
-  ~MenuController() override;
-
-  // Shows the overflow menu.
-  void RunMenu(views::Widget* widget);
-
-  // Closes the overflow menu (and its context menu if open as well).
-  void CloseMenu();
-
- private:
-  // views::MenuDelegate:
-  bool IsCommandEnabled(int id) const override;
-  void ExecuteCommand(int id) override;
-  bool ShowContextMenu(views::MenuItemView* source,
-                       int id,
-                       const gfx::Point& p,
-                       ui::MenuSourceType source_type) override;
-  // These drag functions offer support for dragging icons into the overflow
-  // menu.
-  bool GetDropFormats(
-      views::MenuItemView* menu,
-      int* formats,
-      std::set<ui::Clipboard::FormatType>* format_types) override;
-  bool AreDropTypesRequired(views::MenuItemView* menu) override;
-  bool CanDrop(views::MenuItemView* menu,
-               const ui::OSExchangeData& data) override;
-  int GetDropOperation(views::MenuItemView* item,
-                       const ui::DropTargetEvent& event,
-                       DropPosition* position) override;
-  int OnPerformDrop(views::MenuItemView* menu,
-                    DropPosition position,
-                    const ui::DropTargetEvent& event) override;
-  void OnMenuClosed(views::MenuItemView* menu,
-                    views::MenuRunner::RunResult result) override;
-  // These three drag functions offer support for dragging icons out of the
-  // overflow menu.
-  bool CanDrag(views::MenuItemView* menu) override;
-  void WriteDragData(views::MenuItemView* sender,
-                     ui::OSExchangeData* data) override;
-  int GetDragOperations(views::MenuItemView* sender) override;
-
-  // Returns the offset into |views_| for the given |id|.
-  size_t IndexForId(int id) const;
-
-  // The owning ChevronMenuButton.
-  ChevronMenuButton* owner_;
-
-  // A pointer to the browser action container.
-  BrowserActionsContainer* browser_actions_container_;
-
-  // The overflow menu for the menu button. Owned by |menu_runner_|.
-  views::MenuItemView* menu_;
-
-  // Resposible for running the menu.
-  std::unique_ptr<views::MenuRunner> menu_runner_;
-
-  // The index into the ToolbarActionView vector, indicating where to start
-  // picking browser actions to draw.
-  int start_index_;
-
-  // Whether this controller is being used for drop.
-  bool for_drop_;
-
-  // The vector keeps all icon updaters associated with menu item views in the
-  // controller. The icon updater will update the menu item view's icon when
-  // the browser action view's icon has been updated.
-  ScopedVector<IconUpdater> icon_updaters_;
-
-  DISALLOW_COPY_AND_ASSIGN(MenuController);
-};
-
-ChevronMenuButton::MenuController::MenuController(
-    ChevronMenuButton* owner,
-    BrowserActionsContainer* browser_actions_container,
-    bool for_drop)
-    : owner_(owner),
-      browser_actions_container_(browser_actions_container),
-      menu_(NULL),
-      start_index_(
-          browser_actions_container_->VisibleBrowserActionsAfterAnimation()),
-      for_drop_(for_drop) {
-  menu_ = new views::MenuItemView(this);
-  menu_runner_.reset(new views::MenuRunner(
-      menu_, for_drop_ ? views::MenuRunner::FOR_DROP : 0));
-  menu_->set_has_icons(true);
-
-  size_t command_id = 1;  // Menu id 0 is reserved, start with 1.
-  for (size_t i = start_index_;
-       i < browser_actions_container_->num_toolbar_actions(); ++i) {
-    ToolbarActionView* view =
-        browser_actions_container_->GetToolbarActionViewAt(i);
-    views::MenuItemView* menu_item = menu_->AppendMenuItemWithIcon(
-        command_id,
-        view->view_controller()->GetActionName(),
-        view->GetImage(views::Button::STATE_NORMAL));
-
-    // Set the tooltip for this item.
-    menu_->SetTooltip(
-        view->view_controller()->GetTooltip(view->GetCurrentWebContents()),
-        command_id);
-
-    icon_updaters_.push_back(new IconUpdater(menu_item, view));
-
-    ++command_id;
-  }
-}
-
-ChevronMenuButton::MenuController::~MenuController() {
-}
-
-void ChevronMenuButton::MenuController::RunMenu(views::Widget* window) {
-  gfx::Rect bounds = owner_->bounds();
-  gfx::Point screen_loc;
-  views::View::ConvertPointToScreen(owner_, &screen_loc);
-  bounds.set_x(screen_loc.x());
-  bounds.set_y(screen_loc.y());
-  ignore_result(menu_runner_->RunMenuAt(window, owner_, bounds,
-                                        views::MENU_ANCHOR_TOPRIGHT,
-                                        ui::MENU_SOURCE_NONE));
-}
-
-void ChevronMenuButton::MenuController::CloseMenu() {
-  icon_updaters_.clear();
-  menu_->Cancel();
-}
-
-bool ChevronMenuButton::MenuController::IsCommandEnabled(int id) const {
-  ToolbarActionView* view =
-      browser_actions_container_->GetToolbarActionViewAt(start_index_ + id - 1);
-  return view->view_controller()->IsEnabled(view->GetCurrentWebContents());
-}
-
-void ChevronMenuButton::MenuController::ExecuteCommand(int id) {
-  browser_actions_container_->GetToolbarActionViewAt(start_index_ + id - 1)->
-      view_controller()->ExecuteAction(true);
-}
-
-bool ChevronMenuButton::MenuController::ShowContextMenu(
-    views::MenuItemView* source,
-    int id,
-    const gfx::Point& p,
-    ui::MenuSourceType source_type) {
-  ToolbarActionView* view = browser_actions_container_->GetToolbarActionViewAt(
-      start_index_ + id - 1);
-  ExtensionActionViewController* view_controller =
-      static_cast<ExtensionActionViewController*>(view->view_controller());
-  if (!view_controller->extension()->ShowConfigureContextMenus())
-    return false;
-
-  std::unique_ptr<extensions::ExtensionContextMenuModel> context_menu_contents(
-      new extensions::ExtensionContextMenuModel(
-          view_controller->extension(), view_controller->browser(),
-          extensions::ExtensionContextMenuModel::OVERFLOWED, view_controller));
-  views::MenuRunner context_menu_runner(context_menu_contents.get(),
-                                        views::MenuRunner::HAS_MNEMONICS |
-                                            views::MenuRunner::IS_NESTED |
-                                            views::MenuRunner::CONTEXT_MENU);
-
-  // We can ignore the result as we delete ourself.
-  // This blocks until the user chooses something or dismisses the menu.
-  if (context_menu_runner.RunMenuAt(owner_->GetWidget(),
-                                    NULL,
-                                    gfx::Rect(p, gfx::Size()),
-                                    views::MENU_ANCHOR_TOPLEFT,
-                                    source_type) ==
-          views::MenuRunner::MENU_DELETED)
-    return true;
-
-  // The user is done with the context menu, so we can close the underlying
-  // menu.
-  menu_->Cancel();
-
-  return true;
-}
-
-bool ChevronMenuButton::MenuController::GetDropFormats(
-    views::MenuItemView* menu,
-    int* formats,
-    std::set<ui::Clipboard::FormatType>* format_types) {
-  return BrowserActionDragData::GetDropFormats(format_types);
-}
-
-bool ChevronMenuButton::MenuController::AreDropTypesRequired(
-    views::MenuItemView* menu) {
-  return BrowserActionDragData::AreDropTypesRequired();
-}
-
-bool ChevronMenuButton::MenuController::CanDrop(
-    views::MenuItemView* menu, const OSExchangeData& data) {
-  return BrowserActionDragData::CanDrop(
-      data, browser_actions_container_->browser()->profile());
-}
-
-int ChevronMenuButton::MenuController::GetDropOperation(
-    views::MenuItemView* item,
-    const ui::DropTargetEvent& event,
-    DropPosition* position) {
-  // Don't allow dropping from the BrowserActionContainer into slot 0 of the
-  // overflow menu since once the move has taken place the item you are dragging
-  // falls right out of the menu again once the user releases the button
-  // (because we don't shrink the BrowserActionContainer when you do this).
-  if ((item->GetCommand() == 0) && (*position == DROP_BEFORE)) {
-    BrowserActionDragData drop_data;
-    if (!drop_data.Read(event.data()))
-      return ui::DragDropTypes::DRAG_NONE;
-
-    if (drop_data.index() < browser_actions_container_->VisibleBrowserActions())
-      return ui::DragDropTypes::DRAG_NONE;
-  }
-
-  return ui::DragDropTypes::DRAG_MOVE;
-}
-
-int ChevronMenuButton::MenuController::OnPerformDrop(
-    views::MenuItemView* menu,
-    DropPosition position,
-    const ui::DropTargetEvent& event) {
-  BrowserActionDragData drop_data;
-  if (!drop_data.Read(event.data()))
-    return ui::DragDropTypes::DRAG_NONE;
-
-  size_t drop_index = IndexForId(menu->GetCommand());
-
-  // When not dragging within the overflow menu (dragging an icon into the menu)
-  // subtract one to get the right index.
-  if (position == DROP_BEFORE &&
-      drop_data.index() < browser_actions_container_->VisibleBrowserActions())
-    --drop_index;
-
-  ToolbarActionsBar::DragType drag_type =
-      drop_data.index() < browser_actions_container_->VisibleBrowserActions() ?
-          ToolbarActionsBar::DRAG_TO_OVERFLOW :
-          ToolbarActionsBar::DRAG_TO_SAME;
-  browser_actions_container_->toolbar_actions_bar()->OnDragDrop(
-      drop_data.index(), drop_index, drag_type);
-
-  if (for_drop_)
-    owner_->MenuDone();
-  return ui::DragDropTypes::DRAG_MOVE;
-}
-
-void ChevronMenuButton::MenuController::OnMenuClosed(
-    views::MenuItemView* menu,
-    views::MenuRunner::RunResult result) {
-  if (result == views::MenuRunner::MENU_DELETED)
-    return;
-
-  // Give the context menu (if any) a chance to execute the user-selected
-  // command.
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&ChevronMenuButton::MenuDone,
-                            owner_->weak_factory_.GetWeakPtr()));
-}
-
-bool ChevronMenuButton::MenuController::CanDrag(views::MenuItemView* menu) {
-  return true;
-}
-
-void ChevronMenuButton::MenuController::WriteDragData(
-    views::MenuItemView* sender, OSExchangeData* data) {
-  size_t drag_index = IndexForId(sender->GetCommand());
-  BrowserActionDragData drag_data(
-      browser_actions_container_->GetIdAt(drag_index), drag_index);
-  drag_data.Write(browser_actions_container_->browser()->profile(), data);
-}
-
-int ChevronMenuButton::MenuController::GetDragOperations(
-    views::MenuItemView* sender) {
-  return ui::DragDropTypes::DRAG_MOVE;
-}
-
-size_t ChevronMenuButton::MenuController::IndexForId(int id) const {
-  // The index of the view being dragged (GetCommand gives a 1-based index into
-  // the overflow menu).
-  DCHECK_GT(browser_actions_container_->VisibleBrowserActions() + id, 0u);
-  return browser_actions_container_->VisibleBrowserActions() + id - 1;
-}
-
-ChevronMenuButton::ChevronMenuButton(
-    BrowserActionsContainer* browser_actions_container)
-    : views::MenuButton(base::string16(), this, false),
-      browser_actions_container_(browser_actions_container),
-      weak_factory_(this) {
-  // Set the border explicitly, because otherwise the native theme manager takes
-  // over and reassigns the insets we set in CreateDefaultBorder().
-  SetBorder(CreateDefaultBorder());
-}
-
-ChevronMenuButton::~ChevronMenuButton() {
-}
-
-void ChevronMenuButton::CloseMenu() {
-  if (menu_controller_)
-    menu_controller_->CloseMenu();
-}
-
-std::unique_ptr<views::LabelButtonBorder>
-ChevronMenuButton::CreateDefaultBorder() const {
-  // The chevron resource was designed to not have any insets.
-  std::unique_ptr<views::LabelButtonBorder> border =
-      views::MenuButton::CreateDefaultBorder();
-  border->set_insets(gfx::Insets());
-  return border;
-}
-
-bool ChevronMenuButton::GetDropFormats(
-    int* formats,
-    std::set<ui::Clipboard::FormatType>* format_types) {
-  return BrowserActionDragData::GetDropFormats(format_types);
-}
-
-bool ChevronMenuButton::AreDropTypesRequired() {
-  return BrowserActionDragData::AreDropTypesRequired();
-}
-
-bool ChevronMenuButton::CanDrop(const OSExchangeData& data) {
-  return BrowserActionDragData::CanDrop(
-      data, browser_actions_container_->browser()->profile());
-}
-
-void ChevronMenuButton::OnDragEntered(const ui::DropTargetEvent& event) {
-  DCHECK(!weak_factory_.HasWeakPtrs());
-  if (!menu_controller_) {
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE, base::Bind(&ChevronMenuButton::ShowOverflowMenu,
-                              weak_factory_.GetWeakPtr(), true),
-        base::TimeDelta::FromMilliseconds(views::GetMenuShowDelay()));
-  }
-}
-
-int ChevronMenuButton::OnDragUpdated(const ui::DropTargetEvent& event) {
-  return ui::DragDropTypes::DRAG_MOVE;
-}
-
-void ChevronMenuButton::OnDragExited() {
-  weak_factory_.InvalidateWeakPtrs();
-}
-
-int ChevronMenuButton::OnPerformDrop(const ui::DropTargetEvent& event) {
-  weak_factory_.InvalidateWeakPtrs();
-  return ui::DragDropTypes::DRAG_MOVE;
-}
-
-void ChevronMenuButton::OnMenuButtonClicked(views::MenuButton* source,
-                                            const gfx::Point& point,
-                                            const ui::Event* event) {
-  DCHECK_EQ(this, source);
-  // The menu could already be open if a user dragged an item over it but
-  // ultimately dropped elsewhere (as in that case the menu will close on a
-  // timer). In this case, the click should close the open menu.
-  if (menu_controller_)
-    menu_controller_->CloseMenu();
-  else
-    ShowOverflowMenu(false);
-}
-
-void ChevronMenuButton::ShowOverflowMenu(bool for_drop) {
-  // We should never try to show an overflow menu when one is already visible.
-  DCHECK(!menu_controller_);
-  menu_controller_.reset(new MenuController(
-      this, browser_actions_container_, for_drop));
-  menu_controller_->RunMenu(GetWidget());
-}
-
-void ChevronMenuButton::MenuDone() {
-  menu_controller_.reset();
-}