<webview>: Context menu API implementation CL.

chrome/browser/extensions/menu_manager.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 "chrome/browser/extensions/menu_manager.h"
 
 #include <algorithm>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/menu_manager_factory.h"
 #include "chrome/browser/extensions/state_store.h"
 #include "chrome/browser/extensions/tab_helper.h"
+#include "chrome/browser/guestview/webview/webview_guest.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/context_menus.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/context_menu_params.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
@@ skipping 183 matching lines @@
   return value.Pass();
 }
 
 // static
 MenuItem* MenuItem::Populate(const std::string& extension_id,
                              const base::DictionaryValue& value,
                              std::string* error) {
   bool incognito = false;
   if (!value.GetBoolean(kIncognitoKey, &incognito))
     return NULL;
-  Id id(incognito, extension_id);
+  Id id(incognito, MenuItem::ExtensionKey(extension_id));
   if (!value.GetString(kStringUIDKey, &id.string_uid))
     return NULL;
   int type_int;
   Type type = NORMAL;
   if (!value.GetInteger(kTypeKey, &type_int))
     return NULL;
   type = static_cast<Type>(type_int);
   std::string title;
   if (type != SEPARATOR && !value.GetString(kTitleKey, &title))
     return NULL;
@@ skipping 23 matching lines @@
     return NULL;
 
   if (!result->PopulateURLPatterns(&document_url_patterns,
                                    &target_url_patterns,
                                    error)) {
     return NULL;
   }
 
   // parent_id is filled in from the value, but it might not be valid. It's left
   // to be validated upon being added (via AddChildItem) to the menu manager.
-  scoped_ptr<Id> parent_id(new Id(incognito, extension_id));
+  scoped_ptr<Id> parent_id(
+      new Id(incognito, MenuItem::ExtensionKey(extension_id)));
   if (value.HasKey(kParentUIDKey)) {
     if (!value.GetString(kParentUIDKey, &parent_id->string_uid))
       return NULL;
     result->parent_id_.swap(parent_id);
   }
   return result.release();
 }
 
 bool MenuItem::PopulateURLPatterns(
     std::vector<std::string>* document_url_patterns,
@@ skipping 31 matching lines @@
   for (i = context_items_.begin(); i != context_items_.end(); ++i) {
     STLDeleteElements(&(i->second));
   }
 }
 
 // static
 MenuManager* MenuManager::Get(Profile* profile) {
   return MenuManagerFactory::GetForProfile(profile);
 }
 
-std::set<std::string> MenuManager::ExtensionIds() {
-  std::set<std::string> id_set;
+std::set<MenuItem::ExtensionKey> MenuManager::ExtensionIds() {
+  std::set<MenuItem::ExtensionKey> id_set;
   for (MenuItemMap::const_iterator i = context_items_.begin();
        i != context_items_.end(); ++i) {
     id_set.insert(i->first);
   }
   return id_set;
 }
 
 const MenuItem::List* MenuManager::MenuItems(
-    const std::string& extension_id) {
-  MenuItemMap::iterator i = context_items_.find(extension_id);
+    const MenuItem::ExtensionKey& key) {
+  MenuItemMap::iterator i = context_items_.find(key);
   if (i != context_items_.end()) {
     return &(i->second);
   }
   return NULL;
 }
 
-bool MenuManager::AddContextItem(
-    const Extension* extension,
-    MenuItem* item) {
-  const std::string& extension_id = item->extension_id();
+bool MenuManager::AddContextItem(const Extension* extension, MenuItem* item) {
+  const MenuItem::ExtensionKey& key = item->id().extension_key;
   // The item must have a non-empty extension id, and not have already been
   // added.
-  if (extension_id.empty() || ContainsKey(items_by_id_, item->id()))
+  if (key.empty() || ContainsKey(items_by_id_, item->id()))
     return false;
 
-  DCHECK_EQ(extension->id(), extension_id);
+  DCHECK_EQ(extension->id(), key.extension_id);
 
-  bool first_item = !ContainsKey(context_items_, extension_id);
-  context_items_[extension_id].push_back(item);
+  bool first_item = !ContainsKey(context_items_, key);
+  context_items_[key].push_back(item);
   items_by_id_[item->id()] = item;
 
   if (item->type() == MenuItem::RADIO) {
     if (item->checked())
       RadioItemSelected(item);
     else
-      SanitizeRadioList(context_items_[extension_id]);
+      SanitizeRadioList(context_items_[key]);
   }
 
   // If this is the first item for this extension, start loading its icon.
   if (first_item)
     icon_manager_.LoadIcon(profile_, extension);
 
   return true;
 }
 
 bool MenuManager::AddChildItem(const MenuItem::Id& parent_id,
@@ skipping 48 matching lines @@
       NOTREACHED();
       return false;
     }
     MenuItem* taken =
       old_parent->ReleaseChild(child_id, false /* non-recursive search*/);
     DCHECK(taken == child);
     SanitizeRadioList(old_parent->children());
   } else {
     // This is a top-level item, so we need to pull it out of our list of
     // top-level items.
-    MenuItemMap::iterator i = context_items_.find(child->extension_id());
+    const MenuItem::ExtensionKey& child_key = child->id().extension_key;
+    MenuItemMap::iterator i = context_items_.find(child_key);
     if (i == context_items_.end()) {
       NOTREACHED();
       return false;
     }
     MenuItem::List& list = i->second;
-    MenuItem::List::iterator j = std::find(list.begin(), list.end(),
-                                                    child);
+    MenuItem::List::iterator j = std::find(list.begin(), list.end(), child);
     if (j == list.end()) {
       NOTREACHED();
       return false;
     }
     list.erase(j);
     SanitizeRadioList(list);
   }
 
   if (new_parent) {
     new_parent->AddChild(child);
     SanitizeRadioList(new_parent->children());
   } else {
-    context_items_[child->extension_id()].push_back(child);
+    const MenuItem::ExtensionKey& child_key = child->id().extension_key;
+    context_items_[child_key].push_back(child);
     child->parent_id_.reset(NULL);
-    SanitizeRadioList(context_items_[child->extension_id()]);
+    SanitizeRadioList(context_items_[child_key]);
   }
   return true;
 }
 
 bool MenuManager::RemoveContextMenuItem(const MenuItem::Id& id) {
   if (!ContainsKey(items_by_id_, id))
     return false;
 
   MenuItem* menu_item = GetItemById(id);
   DCHECK(menu_item);
-  std::string extension_id = menu_item->extension_id();
-  MenuItemMap::iterator i = context_items_.find(extension_id);
+  MenuItemMap::iterator i = context_items_.find(id.extension_key);
   if (i == context_items_.end()) {
     NOTREACHED();
     return false;
   }
 
   bool result = false;
   std::set<MenuItem::Id> items_removed;
   MenuItem::List& list = i->second;
   MenuItem::List::iterator j;
   for (j = list.begin(); j < list.end(); ++j) {
@@ skipping 24 matching lines @@
 
   // Clear entries from the items_by_id_ map.
   std::set<MenuItem::Id>::iterator removed_iter;
   for (removed_iter = items_removed.begin();
        removed_iter != items_removed.end();
        ++removed_iter) {
     items_by_id_.erase(*removed_iter);
   }
 
   if (list.empty()) {
-    context_items_.erase(extension_id);
-    icon_manager_.RemoveIcon(extension_id);
+    context_items_.erase(id.extension_key);
+    icon_manager_.RemoveIcon(id.extension_key.extension_id);
   }
   return result;
 }
 
-void MenuManager::RemoveAllContextItems(const std::string& extension_id) {
+void MenuManager::RemoveAllContextItems(
+    const MenuItem::ExtensionKey& extension_key) {
   MenuItem::List::iterator i;
-  for (i = context_items_[extension_id].begin();
-       i != context_items_[extension_id].end(); ++i) {
+  for (i = context_items_[extension_key].begin();
+       i != context_items_[extension_key].end();
+       ++i) {
     MenuItem* item = *i;
     items_by_id_.erase(item->id());
 
     // Remove descendants from this item and erase them from the lookup cache.
     std::set<MenuItem::Id> removed_ids = item->RemoveAllDescendants();
     std::set<MenuItem::Id>::const_iterator j;
     for (j = removed_ids.begin(); j != removed_ids.end(); ++j) {
       items_by_id_.erase(*j);
     }
   }
-  STLDeleteElements(&context_items_[extension_id]);
-  context_items_.erase(extension_id);
-  icon_manager_.RemoveIcon(extension_id);
+  STLDeleteElements(&context_items_[extension_key]);
+  context_items_.erase(extension_key);
+  icon_manager_.RemoveIcon(extension_key.extension_id);
 }
 
 MenuItem* MenuManager::GetItemById(const MenuItem::Id& id) const {
   std::map<MenuItem::Id, MenuItem*>::const_iterator i =
       items_by_id_.find(id);
   if (i != items_by_id_.end())
     return i->second;
   else
     return NULL;
 }
 
 void MenuManager::RadioItemSelected(MenuItem* item) {
   // If this is a child item, we need to get a handle to the list from its
   // parent. Otherwise get a handle to the top-level list.
   const MenuItem::List* list = NULL;
   if (item->parent_id()) {
     MenuItem* parent = GetItemById(*item->parent_id());
     if (!parent) {
       NOTREACHED();
       return;
     }
     list = &(parent->children());
   } else {
-    if (context_items_.find(item->extension_id()) == context_items_.end()) {
+    const MenuItem::ExtensionKey& key = item->id().extension_key;
+    if (context_items_.find(key) == context_items_.end()) {
       NOTREACHED();
       return;
     }
-    list = &context_items_[item->extension_id()];
+    list = &context_items_[key];
   }
 
   // Find where |item| is in the list.
   MenuItem::List::const_iterator item_location;
   for (item_location = list->begin(); item_location != list->end();
        ++item_location) {
     if (*item_location == item)
       break;
   }
   if (item_location == list->end()) {
@@ skipping 36 matching lines @@
   if (!event_router)
     return;
 
   MenuItem* item = GetItemById(menu_item_id);
   if (!item)
     return;
 
   // ExtensionService/Extension can be NULL in unit tests :(
   ExtensionService* service =
       ExtensionSystem::Get(profile_)->extension_service();
-  const Extension* extension = service ?
-      service->extensions()->GetByID(menu_item_id.extension_id) : NULL;
+  const Extension* extension =
+      service ? service->extensions()->GetByID(item->extension_id()) : NULL;
 
   if (item->type() == MenuItem::RADIO)
     RadioItemSelected(item);
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
 
   base::DictionaryValue* properties = new base::DictionaryValue();
   SetIdKeyValue(properties, "menuItemId", item->id());
   if (item->parent_id())
     SetIdKeyValue(properties, "parentMenuItemId", *item->parent_id());
@@ skipping 14 matching lines @@
   AddURLProperty(properties, "linkUrl", params.unfiltered_link_url);
   AddURLProperty(properties, "srcUrl", params.src_url);
   AddURLProperty(properties, "pageUrl", params.page_url);
   AddURLProperty(properties, "frameUrl", params.frame_url);
 
   if (params.selection_text.length() > 0)
     properties->SetString("selectionText", params.selection_text);
 
   properties->SetBoolean("editable", params.is_editable);
 
+  WebViewGuest* webview_guest = WebViewGuest::FromWebContents(web_contents);
+  if (webview_guest) {
+    // This is used in webview_custom_bindings.js.
+    // The property is not exposed to developer API.
+    properties->SetInteger("webviewInstanceId",
+                           webview_guest->view_instance_id());
+  }
+
   args->Append(properties);
 
   // Add the tab info to the argument list.
   // No tab info in a platform app.
   if (!extension || !extension->is_platform_app()) {
     // Note: web_contents are NULL in unit tests :(
     if (web_contents) {
       args->Append(ExtensionTabUtil::CreateTabValue(web_contents));
     } else {
       args->Append(new base::DictionaryValue());
     }
   }
 
   if (item->type() == MenuItem::CHECKBOX ||
       item->type() == MenuItem::RADIO) {
     bool was_checked = item->checked();
     properties->SetBoolean("wasChecked", was_checked);
 
     // RADIO items always get set to true when you click on them, but CHECKBOX
     // items get their state toggled.
     bool checked =
         (item->type() == MenuItem::RADIO) ? true : !was_checked;
 
     item->SetChecked(checked);
     properties->SetBoolean("checked", item->checked());
 
     if (extension)
-      WriteToStorage(extension);
+      WriteToStorage(extension, item->id().extension_key);
   }
 
   // Note: web_contents are NULL in unit tests :(
   if (web_contents && extensions::TabHelper::FromWebContents(web_contents)) {
     extensions::TabHelper::FromWebContents(web_contents)->
         active_tab_permission_granter()->GrantIfRequested(extension);
   }
 
   {
+    // Dispatch to menu item's .onclick handler.
     scoped_ptr<Event> event(new Event(
         event_names::kOnContextMenus,
         scoped_ptr<base::ListValue>(args->DeepCopy())));
     event->restrict_to_browser_context = profile;
     event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
     event_router->DispatchEventToExtension(item->extension_id(), event.Pass());
   }
   {
-    scoped_ptr<Event> event(new Event(context_menus::OnClicked::kEventName,
-                                      args.Pass()));
+    // Dispatch to .contextMenus.onClicked handler.
+    scoped_ptr<Event> event(
+        new Event(webview_guest ? event_names::kOnWebviewContextMenus
+                                : context_menus::OnClicked::kEventName,
+                  args.Pass()));
     event->restrict_to_browser_context = profile;
     event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
+    if (webview_guest)
+      event->filter_info.SetInstanceID(webview_guest->view_instance_id());
     event_router->DispatchEventToExtension(item->extension_id(), event.Pass());
   }
 }
 
 void MenuManager::SanitizeRadioList(const MenuItem::List& item_list) {
   MenuItem::List::const_iterator i = item_list.begin();
   while (i != item_list.end()) {
     if ((*i)->type() != MenuItem::RADIO) {
       ++i;
       break;
@@ skipping 28 matching lines @@
 bool MenuManager::ItemUpdated(const MenuItem::Id& id) {
   if (!ContainsKey(items_by_id_, id))
     return false;
 
   MenuItem* menu_item = GetItemById(id);
   DCHECK(menu_item);
 
   if (menu_item->parent_id()) {
     SanitizeRadioList(GetItemById(*menu_item->parent_id())->children());
   } else {
-    std::string extension_id = menu_item->extension_id();
-    MenuItemMap::iterator i = context_items_.find(extension_id);
+    MenuItemMap::iterator i =
+        context_items_.find(menu_item->id().extension_key);
     if (i == context_items_.end()) {
       NOTREACHED();
       return false;
     }
     SanitizeRadioList(i->second);
   }
 
   return true;
 }
 
-void MenuManager::WriteToStorage(const Extension* extension) {
+void MenuManager::WriteToStorage(const Extension* extension,
+                                 const MenuItem::ExtensionKey& extension_key) {
   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
     return;
-  const MenuItem::List* top_items = MenuItems(extension->id());
+  // <webview> menu items are transient and not stored in storage.
+  if (extension_key.webview_instance_id)
+    return;
+  const MenuItem::List* top_items = MenuItems(extension_key);
   MenuItem::List all_items;
   if (top_items) {
     for (MenuItem::List::const_iterator i = top_items->begin();
          i != top_items->end(); ++i) {
+      DCHECK(!(*i)->id().extension_key.webview_instance_id);
       (*i)->GetFlattenedSubtree(&all_items);
     }
   }
 
-  if (store_)
+  if (store_) {
     store_->SetExtensionValue(extension->id(), kContextMenusKey,
                               MenuItemsToValue(all_items));
+  }
 }
 
 void MenuManager::ReadFromStorage(const std::string& extension_id,
                                   scoped_ptr<base::Value> value) {
   const Extension* extension =
       ExtensionSystem::Get(profile_)->extension_service()->extensions()->
           GetByID(extension_id);
   if (!extension)
     return;
 
@@ skipping 14 matching lines @@
 }
 
 void MenuManager::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       // Remove menu items for disabled/uninstalled extensions.
       const Extension* extension =
           content::Details<UnloadedExtensionInfo>(details)->extension;
-      if (ContainsKey(context_items_, extension->id())) {
-        RemoveAllContextItems(extension->id());
+      MenuItem::ExtensionKey extension_key(extension->id());
+      if (ContainsKey(context_items_, extension_key)) {
+        RemoveAllContextItems(extension_key);
       }
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       if (store_ && BackgroundInfo::HasLazyBackgroundPage(extension)) {
         store_->GetExtensionValue(extension->id(), kContextMenusKey,
             base::Bind(&MenuManager::ReadFromStorage,
                        AsWeakPtr(), extension->id()));
@@ skipping 33 matching lines @@
       items_to_remove.insert(iter->first);
   }
 
   std::set<MenuItem::Id>::iterator remove_iter;
   for (remove_iter = items_to_remove.begin();
        remove_iter != items_to_remove.end();
        ++remove_iter)
     RemoveContextMenuItem(*remove_iter);
 }
 
+MenuItem::ExtensionKey::ExtensionKey() : webview_instance_id(0) {}
+
+MenuItem::ExtensionKey::ExtensionKey(const std::string& extension_id,
+                                     int webview_instance_id)
+    : extension_id(extension_id), webview_instance_id(webview_instance_id) {}
+
+MenuItem::ExtensionKey::ExtensionKey(const std::string& extension_id)
+    : extension_id(extension_id), webview_instance_id(0) {}
+
+bool MenuItem::ExtensionKey::operator==(const ExtensionKey& other) const {
+  return extension_id == other.extension_id &&
+         webview_instance_id == other.webview_instance_id;
+}
+
+bool MenuItem::ExtensionKey::operator<(const ExtensionKey& other) const {
+  if (webview_instance_id != other.webview_instance_id)

[Yoyo Zhou, 2014/03/07 02:40:30]

nit: I would sort using extension id as the primary key.

[lazyboy, 2014/03/07 06:38:03]

Done.

+    return webview_instance_id < other.webview_instance_id;
+
+  return extension_id < other.extension_id;
+}
+
+bool MenuItem::ExtensionKey::operator!=(const ExtensionKey& other) const {
+  return !(*this == other);
+}
+
+bool MenuItem::ExtensionKey::empty() const {
+  return extension_id.empty() && !webview_instance_id;
+}
+
 MenuItem::Id::Id() : incognito(false), uid(0) {}
 
-MenuItem::Id::Id(bool incognito, const std::string& extension_id)
-    : incognito(incognito), extension_id(extension_id), uid(0) {}
+MenuItem::Id::Id(bool incognito, const MenuItem::ExtensionKey& extension_key)
+    : incognito(incognito), extension_key(extension_key), uid(0) {}
 
 MenuItem::Id::~Id() {
 }
 
 bool MenuItem::Id::operator==(const Id& other) const {
   return (incognito == other.incognito &&
-          extension_id == other.extension_id &&
-          uid == other.uid &&
+          extension_key == other.extension_key && uid == other.uid &&
           string_uid == other.string_uid);
 }
 
 bool MenuItem::Id::operator!=(const Id& other) const {
   return !(*this == other);
 }
 
 bool MenuItem::Id::operator<(const Id& other) const {
   if (incognito < other.incognito)
     return true;
   if (incognito == other.incognito) {
-    if (extension_id < other.extension_id)
+    if (extension_key < other.extension_key)
       return true;
-    if (extension_id == other.extension_id) {
+    if (extension_key == other.extension_key) {
       if (uid < other.uid)
         return true;
       if (uid == other.uid)
         return string_uid < other.string_uid;
     }
   }
   return false;
 }
 
 }  // namespace extensions