<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/guestview.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 470 matching lines @@
     items_by_id_.erase(*removed_iter);
   }
 
   if (list.empty()) {
     context_items_.erase(extension_id);
     icon_manager_.RemoveIcon(extension_id);
   }
   return result;
 }
 
+void MenuManager::RemoveAllWebviewContextItems(const std::string& extension_id,
+                                               int webview_instance_id) {
+  MenuItem::List::iterator i;
+  for (i = context_items_[extension_id].begin();
+       i != context_items_[extension_id].end();
+       ++i) {
+    MenuItem* item = *i;
+    if (item->id().webview_instance_id != webview_instance_id)
+      continue;
+    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);
+  }
+
+  // TODO(lazyboy): Consider better data structure. We are naivly iterating
+  // through each items in the extension and remvoving the ones that belong
+  // to the webview.
+  MenuItem::List& items = context_items_[extension_id];
+  i = items.begin();
+  MenuItem::List::iterator check_iter = items.begin();
+  MenuItem::List::iterator insert_iter = items.begin();
+
+  while (check_iter != items.end()) {
+    int item_webview_instance_id = (*check_iter)->id().webview_instance_id;
+    if (item_webview_instance_id != webview_instance_id) {
+      *insert_iter = *check_iter;
+      ++insert_iter;
+    } else {
+      delete *check_iter;
+    }
+    ++check_iter;
+  }
+
+  // Shrink.
+  items.resize(insert_iter - items.begin());
+  if (!items.size())
+    context_items_.erase(extension_id);
+}
+
 void MenuManager::RemoveAllContextItems(const std::string& extension_id) {
   MenuItem::List::iterator i;
   for (i = context_items_[extension_id].begin();
        i != context_items_[extension_id].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;
@@ skipping 117 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);
 
+  GuestView* guest_view = GuestView::FromWebContents(web_contents);
+  if (guest_view)
+    properties->SetInteger("webviewInstanceId", guest_view->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());
@@ skipping 17 matching lines @@
       WriteToStorage(extension);
   }
 
   // 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(guest_view ? event_names::kOnWebviewContextMenus
+                             : context_menus::OnClicked::kEventName,
+                  args.Pass()));
     event->restrict_to_browser_context = profile;
     event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
+    if (guest_view)
+      event->filter_info.SetInstanceID(guest_view->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 48 matching lines @@
 }
 
 void MenuManager::WriteToStorage(const Extension* extension) {
   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
     return;
   const MenuItem::List* top_items = MenuItems(extension->id());
   MenuItem::List all_items;
   if (top_items) {
     for (MenuItem::List::const_iterator i = top_items->begin();
          i != top_items->end(); ++i) {
+      if ((*i)->id().webview_instance_id)
+        continue;
       (*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 69 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::Id::Id() : incognito(false), uid(0) {}
+MenuItem::Id::Id() : incognito(false), uid(0), webview_instance_id(0) {}
 
 MenuItem::Id::Id(bool incognito, const std::string& extension_id)
-    : incognito(incognito), extension_id(extension_id), uid(0) {}
+    : incognito(incognito),
+      extension_id(extension_id),
+      uid(0),
+      webview_instance_id(0) {}
 
 MenuItem::Id::~Id() {
 }
 
 bool MenuItem::Id::operator==(const Id& other) const {
-  return (incognito == other.incognito &&
-          extension_id == other.extension_id &&
-          uid == other.uid &&
-          string_uid == other.string_uid);
+  return (incognito == other.incognito && extension_id == other.extension_id &&
+          uid == other.uid && string_uid == other.string_uid &&
+          webview_instance_id == other.webview_instance_id);
 }
 
 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)
       return true;
     if (extension_id == other.extension_id) {
-      if (uid < other.uid)
+      if (webview_instance_id < other.webview_instance_id)
         return true;
-      if (uid == other.uid)
-        return string_uid < other.string_uid;
+
+      if (webview_instance_id == other.webview_instance_id) {
+        if (uid < other.uid)
+          return true;
+        if (uid == other.uid)
+          return string_uid < other.string_uid;
+      }
     }
   }
   return false;
 }
 
 }  // namespace extensions