Overhaul JSON Schema Compiler to support a number of features required to

chrome/browser/extensions/api/context_menus/context_menus_api.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/api/context_menus/context_menus_api.h"
 
 #include <string>
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 34 matching lines @@
   else
     return base::IntToString(id.uid);
 }
 
 template<typename PropertyWithEnumT>
 extensions::MenuItem::ContextList GetContexts(
     const PropertyWithEnumT& property) {
   extensions::MenuItem::ContextList contexts;
   for (size_t i = 0; i < property.contexts->size(); ++i) {
     switch (property.contexts->at(i)) {
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_ALL:
+      case PropertyWithEnumT::CONTEXTS_TYPE_ALL:
         contexts.Add(extensions::MenuItem::ALL);
         break;
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_PAGE:
+      case PropertyWithEnumT::CONTEXTS_TYPE_PAGE:
         contexts.Add(extensions::MenuItem::PAGE);
         break;
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_SELECTION:
+      case PropertyWithEnumT::CONTEXTS_TYPE_SELECTION:
         contexts.Add(extensions::MenuItem::SELECTION);
         break;
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_LINK:
+      case PropertyWithEnumT::CONTEXTS_TYPE_LINK:
         contexts.Add(extensions::MenuItem::LINK);
         break;
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_EDITABLE:
+      case PropertyWithEnumT::CONTEXTS_TYPE_EDITABLE:
         contexts.Add(extensions::MenuItem::EDITABLE);
         break;
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_IMAGE:
+      case PropertyWithEnumT::CONTEXTS_TYPE_IMAGE:
         contexts.Add(extensions::MenuItem::IMAGE);
         break;
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_VIDEO:
+      case PropertyWithEnumT::CONTEXTS_TYPE_VIDEO:
         contexts.Add(extensions::MenuItem::VIDEO);
         break;
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_AUDIO:
+      case PropertyWithEnumT::CONTEXTS_TYPE_AUDIO:
         contexts.Add(extensions::MenuItem::AUDIO);
         break;
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_FRAME:
+      case PropertyWithEnumT::CONTEXTS_TYPE_FRAME:
         contexts.Add(extensions::MenuItem::FRAME);
         break;
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_LAUNCHER:
+      case PropertyWithEnumT::CONTEXTS_TYPE_LAUNCHER:
         contexts.Add(extensions::MenuItem::LAUNCHER);
         break;
-      case PropertyWithEnumT::CONTEXTS_ELEMENT_NONE:
+      case PropertyWithEnumT::CONTEXTS_TYPE_NONE:
         NOTREACHED();
     }
   }
   return contexts;
 }
 
 template<typename PropertyWithEnumT>
 extensions::MenuItem::Type GetType(const PropertyWithEnumT& property) {
   switch (property.type) {
     case PropertyWithEnumT::TYPE_NONE:
     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;
 }
 
 template<typename PropertyWithEnumT>
 scoped_ptr<extensions::MenuItem::Id> GetParentId(
     const PropertyWithEnumT& property,
     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));
-  switch (property.parent_id_type) {
-    case PropertyWithEnumT::PARENT_ID_NONE:
-      return scoped_ptr<extensions::MenuItem::Id>().Pass();
-    case PropertyWithEnumT::PARENT_ID_INTEGER:
-      parent_id->uid = *property.parent_id_integer;
-      break;
-    case PropertyWithEnumT::PARENT_ID_STRING:
-      parent_id->string_uid = *property.parent_id_string;
-      break;
-  }
+  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();
   return parent_id.Pass();
 }
 
 extensions::MenuItem* GetParent(extensions::MenuItem::Id parent_id,
                                 const extensions::MenuManager* menu_manager,
                                 std::string* error) {
   extensions::MenuItem* parent = menu_manager->GetItemById(parent_id);
   if (!parent) {
     *error = ErrorUtils::FormatErrorMessage(
         kCannotFindItemError, GetIDString(parent_id));
@@ skipping 109 matching lines @@
   menu_manager->WriteToStorage(GetExtension());
   return true;
 }
 
 bool ContextMenusUpdateFunction::RunImpl() {
   bool radio_item_updated = false;
   MenuItem::Id item_id(profile()->IsOffTheRecord(), extension_id());
   scoped_ptr<Update::Params> params(Update::Params::Create(*args_));
 
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  switch (params->id_type) {
-    case Update::Params::ID_STRING:
-      item_id.string_uid = *params->id_string;
-      break;
-    case Update::Params::ID_INTEGER:
-      item_id.uid = *params->id_integer;
-      break;
-    case Update::Params::ID_NONE:
-      NOTREACHED();
-  }
+  if (params->id.as_string)
+    item_id.string_uid = *params->id.as_string;
+  else if (params->id.as_integer)
+    item_id.uid = *params->id.as_integer;
+  else
+    NOTREACHED();
 
   ExtensionService* service = profile()->GetExtensionService();
   MenuManager* manager = service->menu_manager();
   MenuItem* item = manager->GetItemById(item_id);
   if (!item || item->extension_id() != extension_id()) {
     error_ = ErrorUtils::FormatErrorMessage(
         kCannotFindItemError, GetIDString(item_id));
     return false;
   }
 
@@ skipping 81 matching lines @@
 }
 
 bool ContextMenusRemoveFunction::RunImpl() {
   scoped_ptr<Remove::Params> params(Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ExtensionService* service = profile()->GetExtensionService();
   MenuManager* manager = service->menu_manager();
 
   MenuItem::Id id(profile()->IsOffTheRecord(), extension_id());
-  switch (params->menu_item_id_type) {
-    case Remove::Params::MENU_ITEM_ID_STRING:
-      id.string_uid = *params->menu_item_id_string;
-      break;
-    case Remove::Params::MENU_ITEM_ID_INTEGER:
-      id.uid = *params->menu_item_id_integer;
-      break;
-    case Remove::Params::MENU_ITEM_ID_NONE:
-      NOTREACHED();
-  }
+  if (params->menu_item_id.as_string)
+    id.string_uid = *params->menu_item_id.as_string;
+  else if (params->menu_item_id.as_integer)
+    id.uid = *params->menu_item_id.as_integer;
+  else
+    NOTREACHED();
 
   MenuItem* item = manager->GetItemById(id);
   // Ensure one extension can't remove another's menu items.
   if (!item || item->extension_id() != extension_id()) {
     error_ = ErrorUtils::FormatErrorMessage(
         kCannotFindItemError, GetIDString(id));
     return false;
   }
 
   if (!manager->RemoveContextMenuItem(id))
     return false;
   manager->WriteToStorage(GetExtension());
   return true;
 }
 
 bool ContextMenusRemoveAllFunction::RunImpl() {
   ExtensionService* service = profile()->GetExtensionService();
   MenuManager* manager = service->menu_manager();
   manager->RemoveAllContextItems(GetExtension()->id());
   manager->WriteToStorage(GetExtension());
   return true;
 }
 
 }  // namespace extensions