Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/ui/views/extensions/browser_action_overflow_menu_controller.h"
      6 
      7 #include "base/message_loop/message_loop.h"
      8 #include "base/strings/utf_string_conversions.h"
      9 #include "chrome/browser/extensions/extension_action.h"
     10 #include "chrome/browser/extensions/extension_context_menu_model.h"
     11 #include "chrome/browser/extensions/extension_toolbar_model.h"
     12 #include "chrome/browser/profiles/profile.h"
     13 #include "chrome/browser/ui/browser.h"
     14 #include "chrome/browser/ui/browser_list.h"
     15 #include "chrome/browser/ui/views/extensions/browser_action_drag_data.h"
     16 #include "chrome/browser/ui/views/toolbar/browser_action_view.h"
     17 #include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
     18 #include "extensions/browser/extension_registry.h"
     19 #include "extensions/common/extension.h"
     20 #include "extensions/common/extension_set.h"
     21 #include "ui/views/controls/menu/menu_item_view.h"
     22 #include "ui/views/controls/menu/menu_runner.h"
     23 
     24 // In the browser actions container's chevron menu, a menu item view's icon
     25 // comes from BrowserActionView::GetIconWithBadge() when the menu item view is
     26 // created. But, the browser action's icon may not be loaded in time because it
     27 // is read from file system in another thread.
     28 // The IconUpdater will update the menu item view's icon when the browser
     29 // action's icon has been updated.
     30 class IconUpdater : public BrowserActionView::IconObserver {
     31  public:
     32   IconUpdater(views::MenuItemView* menu_item_view, BrowserActionView* view)
     33       : menu_item_view_(menu_item_view),
     34         view_(view) {
     35     DCHECK(menu_item_view);
     36     DCHECK(view);
     37     view->set_icon_observer(this);
     38   }
     39   virtual ~IconUpdater() {
     40     view_->set_icon_observer(NULL);
     41   }
     42 
     43   // Overridden from BrowserActionView::IconObserver:
     44   virtual void OnIconUpdated(const gfx::ImageSkia& icon) OVERRIDE {
     45     menu_item_view_->SetIcon(icon);
     46   }
     47 
     48  private:
     49   // The menu item view whose icon might be updated.
     50   views::MenuItemView* menu_item_view_;
     51 
     52   // The view to be observed. When its icon changes, update the corresponding
     53   // menu item view's icon.
     54   BrowserActionView* view_;
     55 
     56   DISALLOW_COPY_AND_ASSIGN(IconUpdater);
     57 };
     58 
     59 BrowserActionOverflowMenuController::BrowserActionOverflowMenuController(
     60     BrowserActionsContainer* owner,
     61     Browser* browser,
     62     views::MenuButton* menu_button,
     63     const std::vector<BrowserActionView*>& views,
     64     int start_index,
     65     bool for_drop)
     66     : owner_(owner),
     67       browser_(browser),
     68       observer_(NULL),
     69       menu_button_(menu_button),
     70       menu_(NULL),
     71       views_(views),
     72       start_index_(start_index),
     73       for_drop_(for_drop) {
     74   menu_ = new views::MenuItemView(this);
     75   menu_runner_.reset(new views::MenuRunner(
     76       menu_, for_drop_ ? views::MenuRunner::FOR_DROP : 0));
     77   menu_->set_has_icons(true);
     78 
     79   size_t command_id = 1;  // Menu id 0 is reserved, start with 1.
     80   for (size_t i = start_index; i < views_.size(); ++i) {
     81     BrowserActionView* view = views_[i];
     82     views::MenuItemView* menu_item = menu_->AppendMenuItemWithIcon(
     83         command_id,
     84         base::UTF8ToUTF16(view->extension()->name()),
     85         view->GetIconWithBadge());
     86 
     87     // Set the tooltip for this item.
     88     base::string16 tooltip = base::UTF8ToUTF16(
     89         view->extension_action()->GetTitle(
     90             view->view_controller()->GetCurrentTabId()));
     91     menu_->SetTooltip(tooltip, command_id);
     92 
     93     icon_updaters_.push_back(new IconUpdater(menu_item, view));
     94 
     95     ++command_id;
     96   }
     97 }
     98 
     99 BrowserActionOverflowMenuController::~BrowserActionOverflowMenuController() {
    100   if (observer_)
    101     observer_->NotifyMenuDeleted(this);
    102 }
    103 
    104 bool BrowserActionOverflowMenuController::RunMenu(views::Widget* window) {
    105   gfx::Rect bounds = menu_button_->bounds();
    106   gfx::Point screen_loc;
    107   views::View::ConvertPointToScreen(menu_button_, &screen_loc);
    108   bounds.set_x(screen_loc.x());
    109   bounds.set_y(screen_loc.y());
    110 
    111   views::MenuAnchorPosition anchor = views::MENU_ANCHOR_TOPRIGHT;
    112   // As we maintain our own lifetime we can safely ignore the result.
    113   ignore_result(menu_runner_->RunMenuAt(
    114       window, menu_button_, bounds, anchor, ui::MENU_SOURCE_NONE));
    115   if (!for_drop_) {
    116     // Give the context menu (if any) a chance to execute the user-selected
    117     // command.
    118     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
    119   }
    120   return true;
    121 }
    122 
    123 void BrowserActionOverflowMenuController::CancelMenu() {
    124   menu_->Cancel();
    125 }
    126 
    127 void BrowserActionOverflowMenuController::NotifyBrowserActionViewsDeleting() {
    128   icon_updaters_.clear();
    129 }
    130 
    131 bool BrowserActionOverflowMenuController::IsCommandEnabled(int id) const {
    132   BrowserActionView* view = views_[start_index_ + id - 1];
    133   return view->IsEnabled(view->view_controller()->GetCurrentTabId());
    134 }
    135 
    136 void BrowserActionOverflowMenuController::ExecuteCommand(int id) {
    137   views_[start_index_ + id - 1]->view_controller()->ExecuteActionByUser();
    138 }
    139 
    140 bool BrowserActionOverflowMenuController::ShowContextMenu(
    141     views::MenuItemView* source,
    142     int id,
    143     const gfx::Point& p,
    144     ui::MenuSourceType source_type) {
    145   BrowserActionView* view = views_[start_index_ + id - 1];
    146   if (!view->extension()->ShowConfigureContextMenus())
    147     return false;
    148 
    149   scoped_refptr<ExtensionContextMenuModel> context_menu_contents =
    150       new ExtensionContextMenuModel(
    151           view->extension(), browser_, view->view_controller());
    152   views::MenuRunner context_menu_runner(context_menu_contents.get(),
    153                                         views::MenuRunner::HAS_MNEMONICS |
    154                                             views::MenuRunner::IS_NESTED |
    155                                             views::MenuRunner::CONTEXT_MENU);
    156 
    157   // We can ignore the result as we delete ourself.
    158   // This blocks until the user choses something or dismisses the menu.
    159   ignore_result(context_menu_runner.RunMenuAt(menu_button_->GetWidget(),
    160                                               NULL,
    161                                               gfx::Rect(p, gfx::Size()),
    162                                               views::MENU_ANCHOR_TOPLEFT,
    163                                               source_type));
    164 
    165   // The user is done with the context menu, so we can close the underlying
    166   // menu.
    167   menu_->Cancel();
    168 
    169   return true;
    170 }
    171 
    172 void BrowserActionOverflowMenuController::DropMenuClosed(
    173     views::MenuItemView* menu) {
    174   delete this;
    175 }
    176 
    177 bool BrowserActionOverflowMenuController::GetDropFormats(
    178     views::MenuItemView* menu,
    179     int* formats,
    180     std::set<OSExchangeData::CustomFormat>* custom_formats) {
    181   return BrowserActionDragData::GetDropFormats(custom_formats);
    182 }
    183 
    184 bool BrowserActionOverflowMenuController::AreDropTypesRequired(
    185     views::MenuItemView* menu) {
    186   return BrowserActionDragData::AreDropTypesRequired();
    187 }
    188 
    189 bool BrowserActionOverflowMenuController::CanDrop(
    190     views::MenuItemView* menu, const OSExchangeData& data) {
    191   return BrowserActionDragData::CanDrop(data, owner_->profile());
    192 }
    193 
    194 int BrowserActionOverflowMenuController::GetDropOperation(
    195     views::MenuItemView* item,
    196     const ui::DropTargetEvent& event,
    197     DropPosition* position) {
    198   // Don't allow dropping from the BrowserActionContainer into slot 0 of the
    199   // overflow menu since once the move has taken place the item you are dragging
    200   // falls right out of the menu again once the user releases the button
    201   // (because we don't shrink the BrowserActionContainer when you do this).
    202   if ((item->GetCommand() == 0) && (*position == DROP_BEFORE)) {
    203     BrowserActionDragData drop_data;
    204     if (!drop_data.Read(event.data()))
    205       return ui::DragDropTypes::DRAG_NONE;
    206 
    207     if (drop_data.index() < owner_->VisibleBrowserActions())
    208       return ui::DragDropTypes::DRAG_NONE;
    209   }
    210 
    211   return ui::DragDropTypes::DRAG_MOVE;
    212 }
    213 
    214 int BrowserActionOverflowMenuController::OnPerformDrop(
    215     views::MenuItemView* menu,
    216     DropPosition position,
    217     const ui::DropTargetEvent& event) {
    218   BrowserActionDragData drop_data;
    219   if (!drop_data.Read(event.data()))
    220     return ui::DragDropTypes::DRAG_NONE;
    221 
    222   size_t drop_index = IndexForId(menu->GetCommand());
    223 
    224   // When not dragging within the overflow menu (dragging an icon into the menu)
    225   // subtract one to get the right index.
    226   if (position == DROP_BEFORE &&
    227       drop_data.index() < owner_->VisibleBrowserActions())
    228     --drop_index;
    229 
    230   // Move the extension in the model.
    231   const extensions::Extension* extension =
    232       extensions::ExtensionRegistry::Get(browser_->profile())->
    233           enabled_extensions().GetByID(drop_data.id());
    234   extensions::ExtensionToolbarModel* toolbar_model =
    235       extensions::ExtensionToolbarModel::Get(browser_->profile());
    236   if (browser_->profile()->IsOffTheRecord())
    237     drop_index = toolbar_model->IncognitoIndexToOriginal(drop_index);
    238   toolbar_model->MoveExtensionIcon(extension, drop_index);
    239 
    240   // If the extension was moved to the overflow menu from the main bar, notify
    241   // the owner.
    242   if (drop_data.index() < owner_->VisibleBrowserActions())
    243     owner_->NotifyActionMovedToOverflow();
    244 
    245   if (for_drop_)
    246     delete this;
    247   return ui::DragDropTypes::DRAG_MOVE;
    248 }
    249 
    250 bool BrowserActionOverflowMenuController::CanDrag(views::MenuItemView* menu) {
    251   return true;
    252 }
    253 
    254 void BrowserActionOverflowMenuController::WriteDragData(
    255     views::MenuItemView* sender, OSExchangeData* data) {
    256   size_t drag_index = IndexForId(sender->GetCommand());
    257   const extensions::Extension* extension = views_[drag_index]->extension();
    258   BrowserActionDragData drag_data(extension->id(), drag_index);
    259   drag_data.Write(owner_->profile(), data);
    260 }
    261 
    262 int BrowserActionOverflowMenuController::GetDragOperations(
    263     views::MenuItemView* sender) {
    264   return ui::DragDropTypes::DRAG_MOVE;
    265 }
    266 
    267 size_t BrowserActionOverflowMenuController::IndexForId(int id) const {
    268   // The index of the view being dragged (GetCommand gives a 1-based index into
    269   // the overflow menu).
    270   DCHECK_GT(owner_->VisibleBrowserActions() + id, 0u);
    271   return owner_->VisibleBrowserActions() + id - 1;
    272 }
    273