[Extensions API] Remove inline enums

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 "chrome/common/extensions/api/context_menus.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>
 scoped_ptr<extensions::MenuItem::Id> GetParentId(
@@ skipping 25 matching lines @@
 extern const char kOnclickDisallowedError[];
 extern const char kParentsMustBeNormalError[];
 extern const char kTitleNeededError[];
 
 std::string GetIDString(const MenuItem::Id& id);
 
 MenuItem* GetParent(MenuItem::Id parent_id,
                     const MenuManager* menu_manager,
                     std::string* error);
 
-template<typename PropertyWithEnumT>
-MenuItem::ContextList GetContexts(const PropertyWithEnumT& property) {
-  MenuItem::ContextList contexts;
-  for (size_t i = 0; i < property.contexts->size(); ++i) {
-    switch (property.contexts->at(i)) {
-      case PropertyWithEnumT::CONTEXTS_TYPE_ALL:
-        contexts.Add(extensions::MenuItem::ALL);
-        break;
-      case PropertyWithEnumT::CONTEXTS_TYPE_PAGE:
-        contexts.Add(extensions::MenuItem::PAGE);
-        break;
-      case PropertyWithEnumT::CONTEXTS_TYPE_SELECTION:
-        contexts.Add(extensions::MenuItem::SELECTION);
-        break;
-      case PropertyWithEnumT::CONTEXTS_TYPE_LINK:
-        contexts.Add(extensions::MenuItem::LINK);
-        break;
-      case PropertyWithEnumT::CONTEXTS_TYPE_EDITABLE:
-        contexts.Add(extensions::MenuItem::EDITABLE);
-        break;
-      case PropertyWithEnumT::CONTEXTS_TYPE_IMAGE:
-        contexts.Add(extensions::MenuItem::IMAGE);
-        break;
-      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_BROWSER_ACTION:
-        // Not available for <webview>.
-        contexts.Add(extensions::MenuItem::BROWSER_ACTION);
-        break;
-      case PropertyWithEnumT::CONTEXTS_TYPE_PAGE_ACTION:
-        // Not available for <webview>.
-        contexts.Add(extensions::MenuItem::PAGE_ACTION);
-        break;
-      case PropertyWithEnumT::CONTEXTS_TYPE_NONE:
-        NOTREACHED();
-    }
-  }
-  return contexts;
-}
+MenuItem::ContextList GetContexts(const std::vector<
+    extensions::api::context_menus::ContextType>& in_contexts);
 
-template<typename PropertyWithEnumT>
-MenuItem::Type GetType(const PropertyWithEnumT& property,
-                       MenuItem::Type default_type) {
-  switch (property.type) {
-    case PropertyWithEnumT::TYPE_NONE:
-      return default_type;
-    case PropertyWithEnumT::TYPE_NORMAL:
-      return extensions::MenuItem::NORMAL;
-    case PropertyWithEnumT::TYPE_CHECKBOX:
-      return extensions::MenuItem::CHECKBOX;
-    case PropertyWithEnumT::TYPE_RADIO:
-      return extensions::MenuItem::RADIO;
-    case PropertyWithEnumT::TYPE_SEPARATOR:
-      return extensions::MenuItem::SEPARATOR;
-  }
-  return extensions::MenuItem::NORMAL;
-}
+MenuItem::Type GetType(extensions::api::context_menus::ItemType type,
+                       MenuItem::Type default_type);
 
 // 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.extension_key.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 (!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);
+    contexts = GetContexts(*create_properties.contexts);
   else
     contexts.Add(MenuItem::PAGE);
 
   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.Contains(MenuItem::BROWSER_ACTION) ||
       contexts.Contains(MenuItem::PAGE_ACTION)) {
     // Action items are not allowed for <webview>.
     if (!extension->is_extension() || is_webview) {
       *error = kActionNotAllowedError;
       return false;
     }
   }
 
   // Title.
   std::string title;
   if (create_properties.title.get())
     title = *create_properties.title;
 
-  MenuItem::Type type = GetType(create_properties, MenuItem::NORMAL);
+  MenuItem::Type type = GetType(create_properties.type, MenuItem::NORMAL);
   if (title.empty() && type != MenuItem::SEPARATOR) {
     *error = kTitleNeededError;
     return false;
   }
 
   // Checked state.
   bool checked = false;
   if (create_properties.checked.get())
     checked = *create_properties.checked;
 
@@ skipping 45 matching lines @@
   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.
-  MenuItem::Type type = GetType(update_properties, item->type());
+  MenuItem::Type type = GetType(update_properties.type, item->type());
 
   if (type != item->type()) {
     if (type == MenuItem::RADIO || item->type() == MenuItem::RADIO)
       radio_item_updated = true;
     item->set_type(type);
   }
 
   // Title.
   if (update_properties.title.get()) {
     std::string title(*update_properties.title);
@@ skipping 22 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);
+    contexts = GetContexts(*update_properties.contexts);
 
     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())
@@ skipping 23 matching lines @@
     return false;
 
   menu_manager->WriteToStorage(extension, item_id.extension_key);
   return true;
 }
 
 }  // namespace context_menus_api_helpers
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_CONTEXT_MENUS_CONTEXT_MENUS_API_HELPERS_H_