<webview>: Context menu API implementation CL.

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/strings/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_util.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 10 matching lines @@
 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 MenuItem::ExtensionKey& extension_key,
     const base::string16& selection_text,
     int* index) {
   DCHECK_GE(*index, 0);
   int max_index =
       IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST - IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST;
   if (*index >= max_index)
     return;
 
   const Extension* extension = NULL;
   MenuItem::List items;
   bool can_cross_incognito;
-  if (!GetRelevantExtensionTopLevelItems(extension_id, &extension,
-                                         &can_cross_incognito, items))
+  if (!GetRelevantExtensionTopLevelItems(
+          extension_key, &extension, &can_cross_incognito, items))
     return;
 
   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);
 
@@ skipping 24 matching lines @@
     // Now add our item(s) to the menu_model_.
     if (submenu_items.empty()) {
       menu_model_->AddItem(menu_id, title);
     } else {
       ui::SimpleMenuModel* submenu = new ui::SimpleMenuModel(delegate_);
       extension_menu_models_.push_back(submenu);
       menu_model_->AddSubMenu(menu_id, title, submenu);
       RecursivelyAppendExtensionItems(submenu_items, can_cross_incognito,
                                       selection_text, submenu, index);
     }
-    SetExtensionIcon(extension_id);
+    SetExtensionIcon(extension_key.extension_id);
   }
 }
 
 void ContextMenuMatcher::Clear() {
   extension_item_map_.clear();
   extension_menu_models_.clear();
 }
 
 base::string16 ContextMenuMatcher::GetTopLevelContextMenuTitle(
-    const std::string& extension_id,
+    const MenuItem::ExtensionKey& extension_key,
     const base::string16& selection_text) {
   const Extension* extension = NULL;
   MenuItem::List items;
   bool can_cross_incognito;
-  GetRelevantExtensionTopLevelItems(extension_id, &extension,
-      &can_cross_incognito, items);
+  GetRelevantExtensionTopLevelItems(
+      extension_key, &extension, &can_cross_incognito, items);
 
   base::string16 title;
 
   if (items.empty() ||
       items.size() > 1 ||
       items[0]->type() != MenuItem::NORMAL) {
     title = base::UTF8ToUTF16(extension->name());
   } else {
     MenuItem* item = items[0];
     title = item->TitleWithReplacement(
@@ skipping 21 matching lines @@
     const content::ContextMenuParams& params) {
   MenuItem* item = GetExtensionMenuItem(command_id);
   if (!item)
     return;
 
   MenuManager* manager = MenuManager::Get(profile_);
   manager->ExecuteCommand(profile_, web_contents, params, item->id());
 }
 
 bool ContextMenuMatcher::GetRelevantExtensionTopLevelItems(
-    const std::string& extension_id,
+    const MenuItem::ExtensionKey& extension_key,
     const Extension** extension,
     bool* can_cross_incognito,
     MenuItem::List& items) {
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
-  *extension = service->GetExtensionById(extension_id, false);
+  *extension = service->GetExtensionById(extension_key.extension_id, false);
 
   if (!*extension)
     return false;
 
   // Find matching items.
   MenuManager* manager = MenuManager::Get(profile_);
-  const MenuItem::List* all_items = manager->MenuItems(extension_id);
+  const MenuItem::List* all_items = manager->MenuItems(extension_key);
   if (!all_items || all_items->empty())
     return false;
 
   *can_cross_incognito = util::CanCrossIncognito(*extension, profile_);
   items = GetRelevantExtensionItems(*all_items,
                                     *can_cross_incognito);
 
   return true;
 }
 
@@ skipping 93 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