<webview>: Context menu API implementation CL.

chrome/browser/extensions/api/context_menus/context_menus_api_helpers.h

 // Copyright 2014 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.
 
 // Definition of helper functions for the ContextMenus API.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_CONTEXT_MENUS_CONTEXT_MENUS_API_HELPERS_H_
 #define CHROME_BROWSER_EXTENSIONS_API_CONTEXT_MENUS_CONTEXT_MENUS_API_HELPERS_H_
 
 #include "chrome/browser/extensions/menu_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 
 namespace extensions {
 namespace context_menus_api_helpers {
 
 namespace {
 
-template<typename PropertyWithEnumT>
+template <typename PropertyWithEnumT>
 scoped_ptr<extensions::MenuItem::Id> GetParentId(
     const PropertyWithEnumT& property,
+    int webview_instance_id,
     bool is_off_the_record,
     std::string extension_id) {
   if (!property.parent_id)
     return scoped_ptr<extensions::MenuItem::Id>();
 
   scoped_ptr<extensions::MenuItem::Id> parent_id(
       new extensions::MenuItem::Id(is_off_the_record, extension_id));
   if (property.parent_id->as_integer)
     parent_id->uid = *property.parent_id->as_integer;
   else if (property.parent_id->as_string)
     parent_id->string_uid = *property.parent_id->as_string;
   else
     NOTREACHED();
+
+  if (webview_instance_id)
+    parent_id->webview_instance_id = webview_instance_id;
+
   return parent_id.Pass();
 }
 
 }  // namespace
 
 extern const char kCannotFindItemError[];
 extern const char kCheckedError[];
 extern const char kDuplicateIDError[];
 extern const char kGeneratedIdKey[];
 extern const char kLauncherNotAllowedError[];
@@ skipping 33 matching lines @@
       case PropertyWithEnumT::CONTEXTS_TYPE_VIDEO:
         contexts.Add(extensions::MenuItem::VIDEO);
         break;
       case PropertyWithEnumT::CONTEXTS_TYPE_AUDIO:
         contexts.Add(extensions::MenuItem::AUDIO);
         break;
       case PropertyWithEnumT::CONTEXTS_TYPE_FRAME:
         contexts.Add(extensions::MenuItem::FRAME);
         break;
       case PropertyWithEnumT::CONTEXTS_TYPE_LAUNCHER:
+        // Not available for <webview>.
         contexts.Add(extensions::MenuItem::LAUNCHER);
         break;
       case PropertyWithEnumT::CONTEXTS_TYPE_NONE:
         NOTREACHED();
     }
   }
   return contexts;
 }
 
 template<typename PropertyWithEnumT>
@@ skipping 14 matching lines @@
   return extensions::MenuItem::NORMAL;
 }
 
 // Creates and adds a menu item from |create_properties|.
 template<typename PropertyWithEnumT>
 bool CreateMenuItem(const PropertyWithEnumT& create_properties,
                     Profile* profile,
                     const Extension* extension,
                     const MenuItem::Id& item_id,
                     std::string* error) {
+  bool is_webview = item_id.webview_instance_id != 0;
   MenuManager* menu_manager = MenuManager::Get(profile);
 
   if (menu_manager->GetItemById(item_id)) {
     *error = ErrorUtils::FormatErrorMessage(kDuplicateIDError,
                                             GetIDString(item_id));
     return false;
   }
 
-  if (BackgroundInfo::HasLazyBackgroundPage(extension) &&
+  if (!is_webview && BackgroundInfo::HasLazyBackgroundPage(extension) &&
       create_properties.onclick.get()) {
     *error = kOnclickDisallowedError;
     return false;
   }
 
   // Contexts.
   MenuItem::ContextList contexts;
   if (create_properties.contexts.get())
     contexts = GetContexts(create_properties);
   else
     contexts.Add(MenuItem::PAGE);
 
-  if (contexts.Contains(MenuItem::LAUNCHER) && !extension->is_platform_app()) {
-    *error = kLauncherNotAllowedError;
-    return false;
+  if (contexts.Contains(MenuItem::LAUNCHER)) {
+    // Launcher item is not allowed for <webview>.
+    if (!extension->is_platform_app() || is_webview) {
+      *error = kLauncherNotAllowedError;
+      return false;
+    }
   }
 
   // Title.
   std::string title;
   if (create_properties.title.get())
     title = *create_properties.title;
 
   MenuItem::Type type = GetType(create_properties, MenuItem::NORMAL);
   if (title.empty() && type != MenuItem::SEPARATOR) {
     *error = kTitleNeededError;
@@ skipping 17 matching lines @@
   if (!item->PopulateURLPatterns(
           create_properties.document_url_patterns.get(),
           create_properties.target_url_patterns.get(),
           error)) {
     return false;
   }
 
   // Parent id.
   bool success = true;
   scoped_ptr<MenuItem::Id> parent_id(GetParentId(create_properties,
+                                                 item_id.webview_instance_id,
                                                  profile->IsOffTheRecord(),
                                                  extension->id()));
   if (parent_id.get()) {
     MenuItem* parent = GetParent(*parent_id, menu_manager, error);
     if (!parent)
       return false;
     success = menu_manager->AddChildItem(parent->id(), item.release());
   } else {
     success = menu_manager->AddContextItem(extension, item.release());
   }
 
   if (!success)
     return false;
 
   menu_manager->WriteToStorage(extension);
   return true;
 }
 
 // Updates a menu item from |update_properties|.
 template<typename PropertyWithEnumT>
 bool UpdateMenuItem(const PropertyWithEnumT& update_properties,
                     Profile* profile,
                     const Extension* extension,
                     const MenuItem::Id& item_id,
                     std::string* error) {
   bool radio_item_updated = false;
+  bool is_webview = item_id.webview_instance_id != 0;
   MenuManager* menu_manager = MenuManager::Get(profile);
 
   MenuItem* item = menu_manager->GetItemById(item_id);
   if (!item || item->extension_id() != extension->id()){
     *error = ErrorUtils::FormatErrorMessage(
         kCannotFindItemError, GetIDString(item_id));
     return false;
   }
 
   // Type.
@@ skipping 35 matching lines @@
 
   // Enabled.
   if (update_properties.enabled.get())
     item->set_enabled(*update_properties.enabled);
 
   // Contexts.
   MenuItem::ContextList contexts;
   if (update_properties.contexts.get()) {
     contexts = GetContexts(update_properties);
 
-    if (contexts.Contains(MenuItem::LAUNCHER) &&
-        !extension->is_platform_app()) {
-      *error = kLauncherNotAllowedError;
-      return false;
+    if (contexts.Contains(MenuItem::LAUNCHER)) {
+      // Launcher item is not allowed for <webview>.
+      if (!extension->is_platform_app() || is_webview) {
+        *error = kLauncherNotAllowedError;
+        return false;
+      }
     }
 
     if (contexts != item->contexts())
       item->set_contexts(contexts);
   }
 
   // Parent id.
   MenuItem* parent = NULL;
   scoped_ptr<MenuItem::Id> parent_id(GetParentId(update_properties,
+                                                 item_id.webview_instance_id,
                                                  profile->IsOffTheRecord(),
                                                  extension->id()));
   if (parent_id.get()) {
     MenuItem* parent = GetParent(*parent_id, menu_manager, error);
     if (!parent || !menu_manager->ChangeParent(item->id(), &parent->id()))
       return false;
   }
 
   // URL Patterns.
   if (!item->PopulateURLPatterns(
           update_properties.document_url_patterns.get(),
           update_properties.target_url_patterns.get(), error)) {
     return false;
   }
 
   // There is no need to call ItemUpdated if ChangeParent is called because
   // all sanitation is taken care of in ChangeParent.
   if (!parent && radio_item_updated && !menu_manager->ItemUpdated(item->id()))
     return false;
 
   menu_manager->WriteToStorage(extension);
   return true;
 }
 
 }  // namespace context_menus_api_helpers
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_CONTEXT_MENUS_CONTEXT_MENUS_API_HELPERS_H_