Fix top-level context menus sorting by name

chrome/browser/extensions/context_menu_matcher.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 "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/extensions/context_menu_matcher.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/common/context_menu_params.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image.h"
 
 namespace extensions {
 
 // static
 const size_t ContextMenuMatcher::kMaxExtensionItemTitleLength = 75;
 
 ContextMenuMatcher::ContextMenuMatcher(
     Profile* profile,
     ui::SimpleMenuModel::Delegate* delegate,
     ui::SimpleMenuModel* menu_model,
     const base::Callback<bool(const MenuItem*)>& filter)
     : profile_(profile), menu_model_(menu_model), delegate_(delegate),
       filter_(filter) {
 }
-
 void ContextMenuMatcher::AppendExtensionItems(const std::string& extension_id,
                                               const string16& selection_text,
                                               int* index)
 {
-  ExtensionService* service =
-      extensions::ExtensionSystem::Get(profile_)->extension_service();
-  MenuManager* manager = service->menu_manager();
-  const Extension* extension = service->GetExtensionById(extension_id, false);
   DCHECK_GE(*index, 0);
   int max_index =
       IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST - IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST;
-  if (!extension || *index >= max_index)
+  if (*index >= max_index)
     return;
 
-  // Find matching items.
-  const MenuItem::List* all_items = manager->MenuItems(extension_id);
-  if (!all_items || all_items->empty())
+  const Extension* extension = NULL;
+  MenuItem::List items;
+  bool can_cross_incognito;
+  if (!GetRelevantExtensionTopLevelItems(extension_id, &extension,
+                                         &can_cross_incognito, items))
     return;
-  bool can_cross_incognito = service->CanCrossIncognito(extension);
-  MenuItem::List items = GetRelevantExtensionItems(*all_items,
-                                                   can_cross_incognito);
 
   if (items.empty())
     return;
 
   // If this is the first extension-provided menu item, and there are other
   // items in the menu, and the last item is not a separator add a separator.
   if (*index == 0 && menu_model_->GetItemCount())
     menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
 
   // Extensions (other than platform apps) are only allowed one top-level slot
@@ skipping 32 matching lines @@
     }
     SetExtensionIcon(extension_id);
   }
 }
 
 void ContextMenuMatcher::Clear() {
   extension_item_map_.clear();
   extension_menu_models_.clear();
 }
 
+std::string ContextMenuMatcher::GetTopLevelContextMenuTitle(
+    const std::string& extension_id,
+    const string16& selection_text) {
+  const Extension* extension = NULL;
+  MenuItem::List items;
+  bool can_cross_incognito;
+  GetRelevantExtensionTopLevelItems(extension_id, &extension,
+      &can_cross_incognito, items);
+
+  std::string title;
+
+  if (items.empty() ||
+      items.size() > 1 ||
+      items[0]->type() != MenuItem::NORMAL) {
+    title = extension->name();
+  } else {
+    MenuItem* item = items[0];
+    title = UTF16ToUTF8(item->TitleWithReplacement(

[Avi (use Gerrit), 2013/06/05 14:34:10]

MenuItem properly follows the rule of UI strings being string16s. Don't pass
utf8 around.

[François Beaufort, 2013/06/06 09:07:37]

Title is a string and not tied to the MenuItem here. Is that ok to let it UTF*
since it won't be used in the UI?

On 2013/06/05 14:34:10, Avi wrote:

+        selection_text, kMaxExtensionItemTitleLength));
+  }
+  return title;
+}
+
 bool ContextMenuMatcher::IsCommandIdChecked(int command_id) const {
   MenuItem* item = GetExtensionMenuItem(command_id);
   if (!item)
     return false;
   return item->checked();
 }
 
 bool ContextMenuMatcher::IsCommandIdEnabled(int command_id) const {
   MenuItem* item = GetExtensionMenuItem(command_id);
   if (!item)
     return true;
   return item->enabled();
 }
 
 void ContextMenuMatcher::ExecuteCommand(int command_id,
     content::WebContents* web_contents,
     const content::ContextMenuParams& params) {
   MenuManager* manager = extensions::ExtensionSystem::Get(profile_)->
       extension_service()->menu_manager();
   MenuItem* item = GetExtensionMenuItem(command_id);
   if (!item)
     return;
 
   manager->ExecuteCommand(profile_, web_contents, params, item->id());
 }
 
+bool ContextMenuMatcher::GetRelevantExtensionTopLevelItems(
+    const std::string& extension_id,
+    const Extension** extension,
+    bool* can_cross_incognito,
+    MenuItem::List& items) {
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
+  MenuManager* manager = service->menu_manager();
+  *extension = service->GetExtensionById(extension_id, false);
+
+  if (!*extension)
+    return false;
+
+  // Find matching items.
+  const MenuItem::List* all_items = manager->MenuItems(extension_id);
+  CHECK(all_items && !all_items->empty());
+  *can_cross_incognito = service->CanCrossIncognito(*extension);
+  items = GetRelevantExtensionItems(*all_items,
+                                    can_cross_incognito);
+
+  return true;
+}
+
 MenuItem::List ContextMenuMatcher::GetRelevantExtensionItems(
     const MenuItem::List& items,
     bool can_cross_incognito) {
   MenuItem::List result;
   for (MenuItem::List::const_iterator i = items.begin();
        i != items.end(); ++i) {
     const MenuItem* item = *i;
 
     if (!filter_.Run(item))
       continue;
@@ skipping 86 matching lines @@
   DCHECK_GE(index, 0);
 
   const SkBitmap& icon = menu_manager->GetIconForExtension(extension_id);
   DCHECK(icon.width() == gfx::kFaviconSize);
   DCHECK(icon.height() == gfx::kFaviconSize);
 
   menu_model_->SetIcon(index, gfx::Image::CreateFrom1xBitmap(icon));
 }
 
 }  // namespace extensions