chrome/browser/ui/bookmarks/bookmark_context_menu_controller.cc

   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/bookmarks/bookmark_context_menu_controller.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/prefs/pref_service.h"
  10 #include "chrome/app/chrome_command_ids.h"
  11 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  12 #include "chrome/browser/prefs/incognito_mode_prefs.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/browser/ui/bookmarks/bookmark_editor.h"
  15 #include "chrome/browser/ui/bookmarks/bookmark_utils.h"
  16 #include "chrome/browser/ui/browser.h"
  17 #include "chrome/browser/ui/chrome_pages.h"
  18 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  19 #include "chrome/browser/undo/bookmark_undo_service.h"
  20 #include "chrome/browser/undo/bookmark_undo_service_factory.h"
  21 #include "chrome/common/chrome_switches.h"
  22 #include "chrome/common/pref_names.h"
  23 #include "components/bookmarks/browser/bookmark_model.h"
  24 #include "components/bookmarks/browser/bookmark_utils.h"
  25 #include "content/public/browser/page_navigator.h"
  26 #include "content/public/browser/user_metrics.h"
  27 #include "grit/generated_resources.h"
  28 #include "ui/base/l10n/l10n_util.h"
  29
  30 using base::UserMetricsAction;
  31 using content::PageNavigator;
  32
  33 BookmarkContextMenuController::BookmarkContextMenuController(
  34     gfx::NativeWindow parent_window,
  35     BookmarkContextMenuControllerDelegate* delegate,
  36     Browser* browser,
  37     Profile* profile,
  38     PageNavigator* navigator,
  39     const BookmarkNode* parent,
  40     const std::vector<const BookmarkNode*>& selection)
  41     : parent_window_(parent_window),
  42       delegate_(delegate),
  43       browser_(browser),
  44       profile_(profile),
  45       navigator_(navigator),
  46       parent_(parent),
  47       selection_(selection),
  48       model_(BookmarkModelFactory::GetForProfile(profile)) {
  49   DCHECK(profile_);
  50   DCHECK(model_->loaded());
  51   menu_model_.reset(new ui::SimpleMenuModel(this));
  52   model_->AddObserver(this);
  53
  54   BuildMenu();
  55 }
  56
  57 BookmarkContextMenuController::~BookmarkContextMenuController() {
  58   if (model_)
  59     model_->RemoveObserver(this);
  60 }
  61
  62 void BookmarkContextMenuController::BuildMenu() {
  63   if (selection_.size() == 1 && selection_[0]->is_url()) {
  64     AddItem(IDC_BOOKMARK_BAR_OPEN_ALL,
  65             IDS_BOOKMARK_BAR_OPEN_IN_NEW_TAB);
  66     AddItem(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW,
  67             IDS_BOOKMARK_BAR_OPEN_IN_NEW_WINDOW);
  68     AddItem(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO,
  69             IDS_BOOKMARK_BAR_OPEN_INCOGNITO);
  70   } else {
  71     AddItem(IDC_BOOKMARK_BAR_OPEN_ALL, IDS_BOOKMARK_BAR_OPEN_ALL);
  72     AddItem(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW,
  73             IDS_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW);
  74     AddItem(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO,
  75             IDS_BOOKMARK_BAR_OPEN_ALL_INCOGNITO);
  76   }
  77
  78   AddSeparator();
  79   if (selection_.size() == 1 && selection_[0]->is_folder()) {
  80     AddItem(IDC_BOOKMARK_BAR_RENAME_FOLDER, IDS_BOOKMARK_BAR_RENAME_FOLDER);
  81   } else {
  82     AddItem(IDC_BOOKMARK_BAR_EDIT, IDS_BOOKMARK_BAR_EDIT);
  83   }
  84
  85   AddSeparator();
  86   AddItem(IDC_CUT, IDS_CUT);
  87   AddItem(IDC_COPY, IDS_COPY);
  88   AddItem(IDC_PASTE, IDS_PASTE);
  89
  90   AddSeparator();
  91   AddItem(IDC_BOOKMARK_BAR_REMOVE, IDS_BOOKMARK_BAR_REMOVE);
  92   if (CommandLine::ForCurrentProcess()->HasSwitch(
  93       switches::kEnableBookmarkUndo)) {
  94     AddItem(IDC_BOOKMARK_BAR_UNDO, IDS_BOOKMARK_BAR_UNDO);
  95     AddItem(IDC_BOOKMARK_BAR_REDO, IDS_BOOKMARK_BAR_REDO);
  96   }
  97
  98   AddSeparator();
  99   AddItem(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK, IDS_BOOKMARK_BAR_ADD_NEW_BOOKMARK);
 100   AddItem(IDC_BOOKMARK_BAR_NEW_FOLDER, IDS_BOOKMARK_BAR_NEW_FOLDER);
 101
 102   AddSeparator();
 103   AddItem(IDC_BOOKMARK_MANAGER, IDS_BOOKMARK_MANAGER);
 104   // Use the native host desktop type in tests.
 105   if (chrome::IsAppsShortcutEnabled(
 106           profile_,
 107           browser_ ? browser_->host_desktop_type()
 108                    : chrome::HOST_DESKTOP_TYPE_NATIVE)) {
 109     AddCheckboxItem(IDC_BOOKMARK_BAR_SHOW_APPS_SHORTCUT,
 110                     IDS_BOOKMARK_BAR_SHOW_APPS_SHORTCUT);
 111   }
 112   AddCheckboxItem(IDC_BOOKMARK_BAR_ALWAYS_SHOW, IDS_SHOW_BOOKMARK_BAR);
 113 }
 114
 115 void BookmarkContextMenuController::AddItem(int id, int localization_id) {
 116   menu_model_->AddItemWithStringId(id, localization_id);
 117 }
 118
 119 void BookmarkContextMenuController::AddSeparator() {
 120   menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
 121 }
 122
 123 void BookmarkContextMenuController::AddCheckboxItem(int id,
 124                                                     int localization_id) {
 125   menu_model_->AddCheckItemWithStringId(id, localization_id);
 126 }
 127
 128 void BookmarkContextMenuController::ExecuteCommand(int id, int event_flags) {
 129   if (delegate_)
 130     delegate_->WillExecuteCommand(id, selection_);
 131
 132   switch (id) {
 133     case IDC_BOOKMARK_BAR_OPEN_ALL:
 134     case IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO:
 135     case IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW: {
 136       WindowOpenDisposition initial_disposition;
 137       if (id == IDC_BOOKMARK_BAR_OPEN_ALL) {
 138         initial_disposition = NEW_BACKGROUND_TAB;
 139         content::RecordAction(
 140             UserMetricsAction("BookmarkBar_ContextMenu_OpenAll"));
 141       } else if (id == IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW) {
 142         initial_disposition = NEW_WINDOW;
 143         content::RecordAction(
 144             UserMetricsAction("BookmarkBar_ContextMenu_OpenAllInNewWindow"));
 145       } else {
 146         initial_disposition = OFF_THE_RECORD;
 147         content::RecordAction(
 148             UserMetricsAction("BookmarkBar_ContextMenu_OpenAllIncognito"));
 149       }
 150       chrome::OpenAll(parent_window_, navigator_, selection_,
 151                       initial_disposition, profile_);
 152       break;
 153     }
 154
 155     case IDC_BOOKMARK_BAR_RENAME_FOLDER:
 156     case IDC_BOOKMARK_BAR_EDIT:
 157       content::RecordAction(
 158           UserMetricsAction("BookmarkBar_ContextMenu_Edit"));
 159
 160       if (selection_.size() != 1) {
 161         NOTREACHED();
 162         break;
 163       }
 164
 165       BookmarkEditor::Show(
 166           parent_window_,
 167           profile_,
 168           BookmarkEditor::EditDetails::EditNode(selection_[0]),
 169           selection_[0]->is_url() ? BookmarkEditor::SHOW_TREE :
 170                                     BookmarkEditor::NO_TREE);
 171       break;
 172
 173     case IDC_BOOKMARK_BAR_UNDO: {
 174       content::RecordAction(
 175           UserMetricsAction("BookmarkBar_ContextMenu_Undo"));
 176       BookmarkUndoServiceFactory::GetForProfile(profile_)->undo_manager()->
 177           Undo();
 178       break;
 179     }
 180
 181     case IDC_BOOKMARK_BAR_REDO: {
 182       content::RecordAction(
 183           UserMetricsAction("BookmarkBar_ContextMenu_Redo"));
 184       BookmarkUndoServiceFactory::GetForProfile(profile_)->undo_manager()->
 185           Redo();
 186       break;
 187     }
 188
 189     case IDC_BOOKMARK_BAR_REMOVE: {
 190       content::RecordAction(
 191           UserMetricsAction("BookmarkBar_ContextMenu_Remove"));
 192
 193       for (size_t i = 0; i < selection_.size(); ++i) {
 194         int index = selection_[i]->parent()->GetIndexOf(selection_[i]);
 195         if (index > -1)
 196           model_->Remove(selection_[i]->parent(), index);
 197       }
 198       selection_.clear();
 199       break;
 200     }
 201
 202     case IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK: {
 203       content::RecordAction(
 204           UserMetricsAction("BookmarkBar_ContextMenu_Add"));
 205
 206       int index;
 207       const BookmarkNode* parent =
 208           bookmark_utils::GetParentForNewNodes(parent_, selection_, &index);
 209       GURL url;
 210       base::string16 title;
 211       chrome::GetURLAndTitleToBookmark(
 212           browser_->tab_strip_model()->GetActiveWebContents(),
 213           &url, &title);
 214       BookmarkEditor::Show(parent_window_,
 215                            profile_,
 216                            BookmarkEditor::EditDetails::AddNodeInFolder(
 217                                parent, index, url, title),
 218                            BookmarkEditor::SHOW_TREE);
 219       break;
 220     }
 221
 222     case IDC_BOOKMARK_BAR_NEW_FOLDER: {
 223       content::RecordAction(
 224           UserMetricsAction("BookmarkBar_ContextMenu_NewFolder"));
 225
 226       int index;
 227       const BookmarkNode* parent =
 228           bookmark_utils::GetParentForNewNodes(parent_, selection_, &index);
 229       BookmarkEditor::Show(
 230           parent_window_,
 231           profile_,
 232           BookmarkEditor::EditDetails::AddFolder(parent, index),
 233           BookmarkEditor::SHOW_TREE);
 234       break;
 235     }
 236
 237     case IDC_BOOKMARK_BAR_ALWAYS_SHOW:
 238       chrome::ToggleBookmarkBarWhenVisible(profile_);
 239       break;
 240
 241     case IDC_BOOKMARK_BAR_SHOW_APPS_SHORTCUT: {
 242       PrefService* prefs = profile_->GetPrefs();
 243       prefs->SetBoolean(
 244           prefs::kShowAppsShortcutInBookmarkBar,
 245           !prefs->GetBoolean(prefs::kShowAppsShortcutInBookmarkBar));
 246       break;
 247     }
 248
 249     case IDC_BOOKMARK_MANAGER: {
 250       content::RecordAction(UserMetricsAction("ShowBookmarkManager"));
 251       if (selection_.size() != 1)
 252         chrome::ShowBookmarkManager(browser_);
 253       else if (selection_[0]->is_folder())
 254         chrome::ShowBookmarkManagerForNode(browser_, selection_[0]->id());
 255       else if (parent_)
 256         chrome::ShowBookmarkManagerForNode(browser_, parent_->id());
 257       else
 258         chrome::ShowBookmarkManager(browser_);
 259       break;
 260     }
 261
 262     case IDC_CUT:
 263       bookmark_utils::CopyToClipboard(model_, selection_, true);
 264       break;
 265
 266     case IDC_COPY:
 267       bookmark_utils::CopyToClipboard(model_, selection_, false);
 268       break;
 269
 270     case IDC_PASTE: {
 271       int index;
 272       const BookmarkNode* paste_target =
 273           bookmark_utils::GetParentForNewNodes(parent_, selection_, &index);
 274       if (!paste_target)
 275         return;
 276
 277       bookmark_utils::PasteFromClipboard(model_, paste_target, index);
 278       break;
 279     }
 280
 281     default:
 282       NOTREACHED();
 283   }
 284
 285   if (delegate_)
 286     delegate_->DidExecuteCommand(id);
 287 }
 288
 289 bool BookmarkContextMenuController::IsItemForCommandIdDynamic(int command_id)
 290     const {
 291   return command_id == IDC_BOOKMARK_BAR_UNDO ||
 292          command_id == IDC_BOOKMARK_BAR_REDO;
 293 }
 294
 295 base::string16 BookmarkContextMenuController::GetLabelForCommandId(
 296     int command_id) const {
 297   if (command_id == IDC_BOOKMARK_BAR_UNDO) {
 298     return BookmarkUndoServiceFactory::GetForProfile(profile_)->
 299         undo_manager()->GetUndoLabel();
 300   }
 301   if (command_id == IDC_BOOKMARK_BAR_REDO) {
 302     return BookmarkUndoServiceFactory::GetForProfile(profile_)->
 303         undo_manager()->GetRedoLabel();
 304   }
 305
 306   NOTREACHED();
 307   return base::string16();
 308 }
 309
 310 bool BookmarkContextMenuController::IsCommandIdChecked(int command_id) const {
 311   PrefService* prefs = profile_->GetPrefs();
 312   if (command_id == IDC_BOOKMARK_BAR_ALWAYS_SHOW)
 313     return prefs->GetBoolean(prefs::kShowBookmarkBar);
 314
 315   DCHECK_EQ(IDC_BOOKMARK_BAR_SHOW_APPS_SHORTCUT, command_id);
 316   return prefs->GetBoolean(prefs::kShowAppsShortcutInBookmarkBar);
 317 }
 318
 319 bool BookmarkContextMenuController::IsCommandIdEnabled(int command_id) const {
 320   PrefService* prefs = profile_->GetPrefs();
 321
 322   bool is_root_node = selection_.size() == 1 &&
 323                       selection_[0]->parent() == model_->root_node();
 324   bool can_edit = prefs->GetBoolean(prefs::kEditBookmarksEnabled);
 325   IncognitoModePrefs::Availability incognito_avail =
 326       IncognitoModePrefs::GetAvailability(prefs);
 327   switch (command_id) {
 328     case IDC_BOOKMARK_BAR_OPEN_INCOGNITO:
 329       return !profile_->IsOffTheRecord() &&
 330              incognito_avail != IncognitoModePrefs::DISABLED;
 331
 332     case IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO:
 333       return chrome::HasBookmarkURLsAllowedInIncognitoMode(selection_, profile_)
 334              &&
 335              !profile_->IsOffTheRecord() &&
 336              incognito_avail != IncognitoModePrefs::DISABLED;
 337
 338     case IDC_BOOKMARK_BAR_OPEN_ALL:
 339       return chrome::HasBookmarkURLs(selection_);
 340     case IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW:
 341       return chrome::HasBookmarkURLs(selection_) &&
 342              incognito_avail != IncognitoModePrefs::FORCED;
 343
 344     case IDC_BOOKMARK_BAR_RENAME_FOLDER:
 345     case IDC_BOOKMARK_BAR_EDIT:
 346       return selection_.size() == 1 && !is_root_node && can_edit;
 347
 348     case IDC_BOOKMARK_BAR_UNDO:
 349       return can_edit &&
 350           BookmarkUndoServiceFactory::GetForProfile(profile_)->
 351               undo_manager()->undo_count() > 0;
 352
 353     case IDC_BOOKMARK_BAR_REDO:
 354       return can_edit &&
 355           BookmarkUndoServiceFactory::GetForProfile(profile_)->
 356               undo_manager()->redo_count() > 0;
 357
 358     case IDC_BOOKMARK_BAR_REMOVE:
 359       return !selection_.empty() && !is_root_node && can_edit;
 360
 361     case IDC_BOOKMARK_BAR_NEW_FOLDER:
 362     case IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK:
 363       return can_edit && bookmark_utils::GetParentForNewNodes(
 364           parent_, selection_, NULL) != NULL;
 365
 366     case IDC_BOOKMARK_BAR_ALWAYS_SHOW:
 367       return !prefs->IsManagedPreference(prefs::kShowBookmarkBar);
 368
 369     case IDC_BOOKMARK_BAR_SHOW_APPS_SHORTCUT:
 370       return !prefs->IsManagedPreference(prefs::kShowAppsShortcutInBookmarkBar);
 371
 372     case IDC_COPY:
 373     case IDC_CUT:
 374       return !selection_.empty() && !is_root_node &&
 375              (command_id == IDC_COPY || can_edit);
 376
 377     case IDC_PASTE:
 378       // Paste to selection from the Bookmark Bar, to parent_ everywhere else
 379       return can_edit &&
 380              ((!selection_.empty() &&
 381                bookmark_utils::CanPasteFromClipboard(selection_[0])) ||
 382               bookmark_utils::CanPasteFromClipboard(parent_));
 383   }
 384   return true;
 385 }
 386
 387 bool BookmarkContextMenuController::GetAcceleratorForCommandId(
 388     int command_id,
 389     ui::Accelerator* accelerator) {
 390   return false;
 391 }
 392
 393 void BookmarkContextMenuController::BookmarkModelChanged() {
 394   if (delegate_)
 395     delegate_->CloseMenu();
 396 }