#include "base/message_loop/message_loop.h"
#include "base/strings/utf_string_conversions.h"
#include "chrome/browser/extensions/extension_action.h"
-#include "chrome/browser/extensions/extension_action_manager.h"
#include "chrome/browser/extensions/extension_context_menu_model.h"
+#include "chrome/browser/extensions/extension_toolbar_model.h"
#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_list.h"
#include "chrome/browser/ui/views/extensions/browser_action_drag_data.h"
#include "chrome/browser/ui/views/toolbar/browser_action_view.h"
#include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
+#include "extensions/browser/extension_registry.h"
#include "extensions/common/extension.h"
-#include "ui/gfx/canvas.h"
+#include "extensions/common/extension_set.h"
#include "ui/views/controls/menu/menu_item_view.h"
#include "ui/views/controls/menu/menu_runner.h"
-#include "ui/views/controls/menu/submenu_view.h"
-#include "ui/views/widget/widget.h"
+
+// In the browser actions container's chevron menu, a menu item view's icon
+// comes from BrowserActionView::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 BrowserActionView::IconObserver {
+ public:
+ IconUpdater(views::MenuItemView* menu_item_view, BrowserActionView* view)
+ : menu_item_view_(menu_item_view),
+ view_(view) {
+ DCHECK(menu_item_view);
+ DCHECK(view);
+ view->set_icon_observer(this);
+ }
+ virtual ~IconUpdater() {
+ view_->set_icon_observer(NULL);
+ }
+
+ // Overridden from BrowserActionView::IconObserver:
+ virtual void OnIconUpdated(const gfx::ImageSkia& icon) OVERRIDE {
+ menu_item_view_->SetIcon(icon);
+ }
+
+ private:
+ // The menu item view whose icon might be updated.
+ views::MenuItemView* menu_item_view_;
+
+ // The view to be observed. When its icon changes, update the corresponding
+ // menu item view's icon.
+ BrowserActionView* view_;
+
+ DISALLOW_COPY_AND_ASSIGN(IconUpdater);
+};
BrowserActionOverflowMenuController::BrowserActionOverflowMenuController(
BrowserActionsContainer* owner,
Browser* browser,
views::MenuButton* menu_button,
const std::vector<BrowserActionView*>& views,
- int start_index)
+ int start_index,
+ bool for_drop)
: owner_(owner),
browser_(browser),
observer_(NULL),
menu_button_(menu_button),
menu_(NULL),
- views_(&views),
+ views_(views),
start_index_(start_index),
- for_drop_(false) {
+ for_drop_(for_drop) {
menu_ = new views::MenuItemView(this);
- menu_runner_.reset(new views::MenuRunner(menu_));
+ 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 < views_->size(); ++i) {
- BrowserActionView* view = (*views_)[i];
- menu_->AppendMenuItemWithIcon(
+ for (size_t i = start_index; i < views_.size(); ++i) {
+ BrowserActionView* view = views_[i];
+ views::MenuItemView* menu_item = menu_->AppendMenuItemWithIcon(
command_id,
- base::UTF8ToUTF16(view->button()->extension()->name()),
+ base::UTF8ToUTF16(view->extension()->name()),
view->GetIconWithBadge());
// Set the tooltip for this item.
base::string16 tooltip = base::UTF8ToUTF16(
- extensions::ExtensionActionManager::Get(owner_->profile())->
- GetBrowserAction(*view->button()->extension())->
- GetTitle(owner_->GetCurrentTabId()));
+ view->extension_action()->GetTitle(
+ view->view_controller()->GetCurrentTabId()));
menu_->SetTooltip(tooltip, command_id);
+ icon_updaters_.push_back(new IconUpdater(menu_item, view));
+
++command_id;
}
}
observer_->NotifyMenuDeleted(this);
}
-bool BrowserActionOverflowMenuController::RunMenu(views::Widget* window,
- bool for_drop) {
- for_drop_ = for_drop;
-
+bool BrowserActionOverflowMenuController::RunMenu(views::Widget* window) {
gfx::Rect bounds = menu_button_->bounds();
gfx::Point screen_loc;
views::View::ConvertPointToScreen(menu_button_, &screen_loc);
bounds.set_x(screen_loc.x());
bounds.set_y(screen_loc.y());
- views::MenuItemView::AnchorPosition anchor = views::MenuItemView::TOPRIGHT;
+ views::MenuAnchorPosition anchor = views::MENU_ANCHOR_TOPRIGHT;
// As we maintain our own lifetime we can safely ignore the result.
- ignore_result(menu_runner_->RunMenuAt(window, menu_button_, bounds, anchor,
- ui::MENU_SOURCE_NONE, for_drop_ ? views::MenuRunner::FOR_DROP : 0));
+ ignore_result(menu_runner_->RunMenuAt(
+ window, menu_button_, bounds, anchor, ui::MENU_SOURCE_NONE));
if (!for_drop_) {
// Give the context menu (if any) a chance to execute the user-selected
// command.
menu_->Cancel();
}
+void BrowserActionOverflowMenuController::NotifyBrowserActionViewsDeleting() {
+ icon_updaters_.clear();
+}
+
bool BrowserActionOverflowMenuController::IsCommandEnabled(int id) const {
- BrowserActionView* view = (*views_)[start_index_ + id - 1];
- return view->button()->IsEnabled(owner_->GetCurrentTabId());
+ BrowserActionView* view = views_[start_index_ + id - 1];
+ return view->IsEnabled(view->view_controller()->GetCurrentTabId());
}
void BrowserActionOverflowMenuController::ExecuteCommand(int id) {
- BrowserActionView* view = (*views_)[start_index_ + id - 1];
- owner_->OnBrowserActionExecuted(view->button());
+ views_[start_index_ + id - 1]->view_controller()->ExecuteActionByUser();
}
bool BrowserActionOverflowMenuController::ShowContextMenu(
int id,
const gfx::Point& p,
ui::MenuSourceType source_type) {
- const extensions::Extension* extension =
- (*views_)[start_index_ + id - 1]->button()->extension();
- if (!extension->ShowConfigureContextMenus())
+ BrowserActionView* view = views_[start_index_ + id - 1];
+ if (!view->extension()->ShowConfigureContextMenus())
return false;
scoped_refptr<ExtensionContextMenuModel> context_menu_contents =
- new ExtensionContextMenuModel(extension, browser_, owner_);
- views::MenuRunner context_menu_runner(context_menu_contents.get());
+ new ExtensionContextMenuModel(
+ view->extension(), browser_, view->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 choses something or dismisses the menu.
ignore_result(context_menu_runner.RunMenuAt(menu_button_->GetWidget(),
- NULL, gfx::Rect(p, gfx::Size()), views::MenuItemView::TOPLEFT,
- source_type,
- views::MenuRunner::HAS_MNEMONICS | views::MenuRunner::IS_NESTED |
- views::MenuRunner::CONTEXT_MENU));
+ NULL,
+ gfx::Rect(p, gfx::Size()),
+ views::MENU_ANCHOR_TOPLEFT,
+ source_type));
// The user is done with the context menu, so we can close the underlying
// menu.
views::MenuItemView* menu,
int* formats,
std::set<OSExchangeData::CustomFormat>* custom_formats) {
- custom_formats->insert(BrowserActionDragData::GetBrowserActionCustomFormat());
- return true;
+ return BrowserActionDragData::GetDropFormats(custom_formats);
}
bool BrowserActionOverflowMenuController::AreDropTypesRequired(
views::MenuItemView* menu) {
- return true;
+ return BrowserActionDragData::AreDropTypesRequired();
}
bool BrowserActionOverflowMenuController::CanDrop(
views::MenuItemView* menu, const OSExchangeData& data) {
- BrowserActionDragData drop_data;
- if (!drop_data.Read(data))
- return false;
- return drop_data.IsFromProfile(owner_->profile());
+ return BrowserActionDragData::CanDrop(data, owner_->profile());
}
int BrowserActionOverflowMenuController::GetDropOperation(
if (!drop_data.Read(event.data()))
return ui::DragDropTypes::DRAG_NONE;
- size_t drop_index;
- ViewForId(menu->GetCommand(), &drop_index);
+ 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.
drop_data.index() < owner_->VisibleBrowserActions())
--drop_index;
- owner_->MoveBrowserAction(drop_data.id(), drop_index);
+ // Move the extension in the model.
+ const extensions::Extension* extension =
+ extensions::ExtensionRegistry::Get(browser_->profile())->
+ enabled_extensions().GetByID(drop_data.id());
+ extensions::ExtensionToolbarModel* toolbar_model =
+ extensions::ExtensionToolbarModel::Get(browser_->profile());
+ if (browser_->profile()->IsOffTheRecord())
+ drop_index = toolbar_model->IncognitoIndexToOriginal(drop_index);
+ toolbar_model->MoveExtensionIcon(extension, drop_index);
+
+ // If the extension was moved to the overflow menu from the main bar, notify
+ // the owner.
+ if (drop_data.index() < owner_->VisibleBrowserActions())
+ owner_->NotifyActionMovedToOverflow();
if (for_drop_)
delete this;
void BrowserActionOverflowMenuController::WriteDragData(
views::MenuItemView* sender, OSExchangeData* data) {
- size_t drag_index;
- BrowserActionView* view = ViewForId(sender->GetCommand(), &drag_index);
- std::string id = view->button()->extension()->id();
-
- BrowserActionDragData drag_data(id, drag_index);
+ size_t drag_index = IndexForId(sender->GetCommand());
+ const extensions::Extension* extension = views_[drag_index]->extension();
+ BrowserActionDragData drag_data(extension->id(), drag_index);
drag_data.Write(owner_->profile(), data);
}
return ui::DragDropTypes::DRAG_MOVE;
}
-BrowserActionView* BrowserActionOverflowMenuController::ViewForId(
- int id, size_t* index) {
+size_t BrowserActionOverflowMenuController::IndexForId(int id) const {
// The index of the view being dragged (GetCommand gives a 1-based index into
// the overflow menu).
- size_t view_index = owner_->VisibleBrowserActions() + id - 1;
- if (index)
- *index = view_index;
- return owner_->GetBrowserActionViewAt(view_index);
+ DCHECK_GT(owner_->VisibleBrowserActions() + id, 0u);
+ return owner_->VisibleBrowserActions() + id - 1;
}
projects / platform / framework / web / crosswalk.git / blobdiff