Setting the touch wrench menu as default menu for ChromeOS

chrome/browser/tab_contents/render_view_context_menu.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 <algorithm>
 #include <set>
 #include <utility>
 
 #include "chrome/browser/tab_contents/render_view_context_menu.h"
 
@@ skipping 173 matching lines @@
       case WebMenuItem::CHECKABLE_OPTION:
         menu_model->AddCheckItem(
             items[i].action + IDC_CONTENT_CONTEXT_CUSTOM_FIRST,
             items[i].label);
         break;
       case WebMenuItem::GROUP:
         // TODO(viettrungluu): I don't know what this is supposed to do.
         NOTREACHED();
         break;
       case WebMenuItem::SEPARATOR:
-        menu_model->AddSeparator();
+        menu_model->AddSeparator(ui::NORMAL_SEPARATOR);
         break;
       case WebMenuItem::SUBMENU: {
         ui::SimpleMenuModel* submenu = new ui::SimpleMenuModel(delegate);
         AddCustomItemsToMenu(items[i].submenu, depth + 1, total_items, delegate,
                              submenu);
         menu_model->AddSubMenu(
             items[i].action + IDC_CONTENT_CONTEXT_CUSTOM_FIRST,
             items[i].label,
             submenu);
         break;
@@ skipping 178 matching lines @@
   bool can_cross_incognito = service->CanCrossIncognito(extension);
   MenuItem::List items =
       GetRelevantExtensionItems(*all_items, params_, profile_,
                                 can_cross_incognito);
   if (items.empty())
     return;
 
   // If this is the first extension-provided menu item, and there are other
   // items in the menu, add a separator.
   if (*index == 0 && menu_model_.GetItemCount())
-    menu_model_.AddSeparator();
+    menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
 
   int menu_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + (*index)++;
 
   // Extensions are only allowed one top-level slot (and it can't be a radio or
   // checkbox item because we are going to put the extension icon next to it).
   // If they have more than that, we automatically push them into a submenu.
   string16 title;
   MenuItem::List submenu_items;
   if (items.size() > 1 || items[0]->type() != MenuItem::NORMAL) {
     title = UTF8ToUTF16(extension->name());
@@ skipping 30 matching lines @@
   int radio_group_id = 1;
 
   for (MenuItem::List::const_iterator i = items.begin();
        i != items.end(); ++i) {
     MenuItem* item = *i;
 
     // If last item was of type radio but the current one isn't, auto-insert
     // a separator.  The converse case is handled below.
     if (last_type == MenuItem::RADIO &&
         item->type() != MenuItem::RADIO) {
-      menu_model->AddSeparator();
+      menu_model->AddSeparator(ui::NORMAL_SEPARATOR);
       last_type = MenuItem::SEPARATOR;
     }
 
     int menu_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + (*index)++;
     if (menu_id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST)
       return;
     extension_item_map_[menu_id] = item->id();
     string16 title = item->TitleWithReplacement(selection_text,
                                                 kMaxExtensionItemTitleLength);
     if (item->type() == MenuItem::NORMAL) {
@@ skipping 11 matching lines @@
       }
     } else if (item->type() == MenuItem::CHECKBOX) {
       menu_model->AddCheckItem(menu_id, title);
     } else if (item->type() == MenuItem::RADIO) {
       if (i != items.begin() &&
           last_type != MenuItem::RADIO) {
         radio_group_id++;
 
         // Auto-append a separator if needed.
         if (last_type != MenuItem::SEPARATOR)
-          menu_model->AddSeparator();
+          menu_model->AddSeparator(ui::NORMAL_SEPARATOR);
       }
 
       menu_model->AddRadioItem(menu_id, title, radio_group_id);
     } else if (item->type() == MenuItem::SEPARATOR) {
       if (i != items.begin() && last_type != MenuItem::SEPARATOR) {
-        menu_model->AddSeparator();
+        menu_model->AddSeparator(ui::NORMAL_SEPARATOR);
       }
     }
     last_type = item->type();
   }
 }
 
 void RenderViewContextMenu::SetExtensionIcon(const std::string& extension_id) {
   ExtensionService* service = profile_->GetExtensionService();
   MenuManager* menu_manager = service->menu_manager();
 
@@ skipping 54 matching lines @@
     return;
   }
 
   bool has_link = !params_.unfiltered_link_url.is_empty();
   bool has_selection = !params_.selection_text.empty();
 
   if (AppendCustomItems()) {
     // If there's a selection, don't early return when there are custom items,
     // but fall through to adding the normal ones after the custom ones.
     if (has_selection) {
-      menu_model_.AddSeparator();
+      menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
     } else {
       // Don't add items for Pepper menu.
       if (!params_.custom_context.is_pepper_menu)
         AppendDeveloperItems();
       return;
     }
   }
 
   // When no special node or text is selected and selection has no link,
   // show page items.
   if (params_.media_type == WebContextMenuData::MediaTypeNone &&
       !has_link &&
       !params_.is_editable &&
       !has_selection) {
     if (!params_.page_url.is_empty()) {
       bool is_devtools = IsDevToolsURL(params_.page_url);
       if (!is_devtools && !IsInternalResourcesURL(params_.page_url)) {
         AppendPageItems();
         // Merge in frame items if we clicked within a frame that needs them.
         if (!params_.frame_url.is_empty()) {
           is_devtools = IsDevToolsURL(params_.frame_url);
           if (!is_devtools && !IsInternalResourcesURL(params_.frame_url)) {
-            menu_model_.AddSeparator();
+            menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
             AppendFrameItems();
           }
         }
       }
     } else {
       DCHECK(params_.frame_url.is_empty());
     }
   }
 
   if (has_link) {
     AppendLinkItems();
     if (params_.media_type != WebContextMenuData::MediaTypeNone)
-      menu_model_.AddSeparator();
+      menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
   }
 
   switch (params_.media_type) {
     case WebContextMenuData::MediaTypeNone:
       break;
     case WebContextMenuData::MediaTypeImage:
       AppendImageItems();
       break;
     case WebContextMenuData::MediaTypeVideo:
       AppendVideoItems();
@@ skipping 77 matching lines @@
                                         const string16& title) {
   menu_model_.AddItem(command_id, title);
 }
 
 void RenderViewContextMenu::AddCheckItem(int command_id,
                                          const string16& title) {
   menu_model_.AddCheckItem(command_id, title);
 }
 
 void RenderViewContextMenu::AddSeparator() {
-  menu_model_.AddSeparator();
+  menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
 }
 
 void RenderViewContextMenu::AddSubMenu(int command_id,
                                        const string16& label,
                                        ui::MenuModel* model) {
   menu_model_.AddSubMenu(command_id, label, model);
 }
 
 void RenderViewContextMenu::UpdateMenuItem(int command_id,
                                            bool enabled,
@@ skipping 34 matching lines @@
 #if defined(DEBUG_DEVTOOLS)
   show_developer_items = true;
 #endif
 
   if (!show_developer_items)
     return;
 
   // In the DevTools popup menu, "developer items" is normally the only
   // section, so omit the separator there.
   if (menu_model_.GetItemCount() > 0)
-    menu_model_.AddSeparator();
+    menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_INSPECTELEMENT,
                                   IDS_CONTENT_CONTEXT_INSPECTELEMENT);
 }
 
 void RenderViewContextMenu::AppendLinkItems() {
   if (!params_.link_url.is_empty()) {
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_OPENLINKNEWTAB,
                                     IDS_CONTENT_CONTEXT_OPENLINKNEWTAB);
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_OPENLINKNEWWINDOW,
                                     IDS_CONTENT_CONTEXT_OPENLINKNEWWINDOW);
@@ skipping 22 matching lines @@
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_COPYIMAGELOCATION,
                                   IDS_CONTENT_CONTEXT_COPYIMAGELOCATION);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_COPYIMAGE,
                                   IDS_CONTENT_CONTEXT_COPYIMAGE);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_OPENIMAGENEWTAB,
                                   IDS_CONTENT_CONTEXT_OPENIMAGENEWTAB);
 }
 
 void RenderViewContextMenu::AppendAudioItems() {
   AppendMediaItems();
-  menu_model_.AddSeparator();
+  menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_SAVEAVAS,
                                   IDS_CONTENT_CONTEXT_SAVEAUDIOAS);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_COPYAVLOCATION,
                                   IDS_CONTENT_CONTEXT_COPYAUDIOLOCATION);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_OPENAVNEWTAB,
                                   IDS_CONTENT_CONTEXT_OPENAUDIONEWTAB);
 }
 
 void RenderViewContextMenu::AppendVideoItems() {
   AppendMediaItems();
-  menu_model_.AddSeparator();
+  menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_SAVEAVAS,
                                   IDS_CONTENT_CONTEXT_SAVEVIDEOAS);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_COPYAVLOCATION,
                                   IDS_CONTENT_CONTEXT_COPYVIDEOLOCATION);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_OPENAVNEWTAB,
                                   IDS_CONTENT_CONTEXT_OPENVIDEONEWTAB);
 }
 
 void RenderViewContextMenu::AppendMediaItems() {
   int media_flags = params_.media_flags;
@@ skipping 22 matching lines @@
     if (params_.link_url.is_empty() && params_.selection_text.empty())
       AppendPageItems();
   } else {
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_SAVEAVAS,
                                     IDS_CONTENT_CONTEXT_SAVEPAGEAS);
     menu_model_.AddItemWithStringId(IDC_PRINT, IDS_CONTENT_CONTEXT_PRINT);
   }
 
   if (params_.media_flags & WebContextMenuData::MediaCanRotate) {
     if (menu_model_.GetItemCount() > 0)
-      menu_model_.AddSeparator();
+      menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_ROTATECW,
                                     IDS_CONTENT_CONTEXT_ROTATECW);
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_ROTATECCW,
                                     IDS_CONTENT_CONTEXT_ROTATECCW);
   }
 }
 
 void RenderViewContextMenu::AppendPageItems() {
   menu_model_.AddItemWithStringId(IDC_BACK, IDS_CONTENT_CONTEXT_BACK);
   menu_model_.AddItemWithStringId(IDC_FORWARD, IDS_CONTENT_CONTEXT_FORWARD);
   menu_model_.AddItemWithStringId(IDC_RELOAD, IDS_CONTENT_CONTEXT_RELOAD);
-  menu_model_.AddSeparator();
+  menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
   menu_model_.AddItemWithStringId(IDC_SAVE_PAGE,
                                   IDS_CONTENT_CONTEXT_SAVEPAGEAS);
   menu_model_.AddItemWithStringId(IDC_PRINT, IDS_CONTENT_CONTEXT_PRINT);
 
   if (ShouldShowTranslateItem(params_.page_url)) {
     std::string locale = g_browser_process->GetApplicationLocale();
     locale = TranslateManager::GetLanguageCode(locale);
     string16 language = l10n_util::GetDisplayNameForLocale(locale, locale,
                                                            true);
     menu_model_.AddItem(
@@ skipping 81 matching lines @@
   }
 }
 
 void RenderViewContextMenu::AppendEditableItems() {
   AppendSpellingSuggestionsSubMenu();
 
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_UNDO,
                                   IDS_CONTENT_CONTEXT_UNDO);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_REDO,
                                   IDS_CONTENT_CONTEXT_REDO);
-  menu_model_.AddSeparator();
+  menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_CUT,
                                   IDS_CONTENT_CONTEXT_CUT);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_COPY,
                                   IDS_CONTENT_CONTEXT_COPY);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_PASTE,
                                   IDS_CONTENT_CONTEXT_PASTE);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_PASTE_AND_MATCH_STYLE,
                                   IDS_CONTENT_CONTEXT_PASTE_AND_MATCH_STYLE);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_DELETE,
                                   IDS_CONTENT_CONTEXT_DELETE);
-  menu_model_.AddSeparator();
+  menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
 
   if (!params_.keyword_url.is_empty()) {
     menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_ADDSEARCHENGINE,
                                     IDS_CONTENT_CONTEXT_ADDSEARCHENGINE);
-    menu_model_.AddSeparator();
+    menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
   }
 
   AppendSpellcheckOptionsSubMenu();
   AppendSpeechInputOptionsSubMenu();
 
 #if defined(OS_MACOSX)
   // OS X provides a contextual menu to set writing direction for BiDi
   // languages.
   // This functionality is exposed as a keyboard shortcut on Windows & Linux.
   AppendBidiSubMenu();
 #endif  // OS_MACOSX
 
-  menu_model_.AddSeparator();
+  menu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
   menu_model_.AddItemWithStringId(IDC_CONTENT_CONTEXT_SELECTALL,
                                   IDS_CONTENT_CONTEXT_SELECTALL);
 }
 
 void RenderViewContextMenu::AppendSpellingSuggestionsSubMenu() {
   if (!spelling_menu_observer_.get())
     spelling_menu_observer_.reset(new SpellingMenuObserver(this));
   observers_.AddObserver(spelling_menu_observer_.get());
   spelling_menu_observer_->InitMenu(params_);
 }
@@ skipping 46 matching lines @@
       GetHandlersForLinkUrl();
   if (handlers.empty())
     return;
   size_t max = IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_LAST -
       IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST;
   for (size_t i = 0; i < handlers.size() && i <= max; i++) {
     protocol_handler_submenu_model_.AddItem(
         IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST + i,
         handlers[i].title());
   }
-  protocol_handler_submenu_model_.AddSeparator();
+  protocol_handler_submenu_model_.AddSeparator(ui::NORMAL_SEPARATOR);
   protocol_handler_submenu_model_.AddItem(
       IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_SETTINGS,
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_OPENLINKWITH_CONFIGURE));
 
   menu_model_.AddSubMenu(
       IDC_CONTENT_CONTEXT_OPENLINKWITH,
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_OPENLINKWITH),
       &protocol_handler_submenu_model_);
 }
 
@@ skipping 945 matching lines @@
   source_web_contents_->GetRenderViewHost()->
       ExecuteMediaPlayerActionAtLocation(location, action);
 }
 
 void RenderViewContextMenu::PluginActionAt(
     const gfx::Point& location,
     const WebPluginAction& action) {
   source_web_contents_->GetRenderViewHost()->
       ExecutePluginActionAtLocation(location, action);
 }