Context Menus now uses the JSON Schema Compiler.

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"
@@ skipping 185 matching lines @@
 MenuItem* MenuItem::Populate(const std::string& extension_id,
                              const DictionaryValue& value,
                              std::string* error) {
   bool incognito = false;
   if (!value.GetBoolean(kIncognitoKey, &incognito))
     return NULL;
   Id id(incognito, extension_id);
   if (!value.GetString(kStringUIDKey, &id.string_uid))
     return NULL;
   int type_int;
-  Type type;
+  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;
-  bool checked;
+  bool checked = false;
   if ((type == CHECKBOX || type == RADIO) &&
       !value.GetBoolean(kCheckedKey, &checked)) {
     return NULL;
   }
   bool enabled = true;
   if (!value.GetBoolean(kEnabledKey, &enabled))
     return NULL;
   ContextList contexts;
   const Value* contexts_value = NULL;
   if (!value.Get(kContextsKey, &contexts_value))
     return NULL;
   if (!contexts.Populate(*contexts_value))
     return NULL;
 
   scoped_ptr<MenuItem> result(new MenuItem(
       id, title, checked, enabled, type, contexts));
 
-  if (!result->PopulateURLPatterns(
-          value, kDocumentURLPatternsKey, kTargetURLPatternsKey, error))
+  std::vector<std::string> document_url_patterns;
+  if (value.HasKey(kDocumentURLPatternsKey)) {

[not at google - send to devlin, 2012/08/07 02:00:11]

code is basically repeated. Could you pull this out and make it look something
like:

namespace {
bool GetStringList(const DictionaryValue& dict,
                   const std::string& key,
                   std::vector<std::string>* out) {
  if (!dict.HasKey(key))
    return true;
  const ListValue* list = NULL;
  if (!dict.GetListWithoutPathExpansion(key, &list)
    return false;
  // etc
}
}  // namespace

then

std::vector<std::string> document_url_patterns;
std::vector<std::string> target_url_patterns;
if (!GetStringList(value, kDocumentURLPatternsKey, &document_url_patterns) ||
    !GetStringList(value, kTargetURLPatternsKey, &target_url_patterns)) {
  return NULL;
}

if (!result->PopulateURLPatterns(...)) {
  return NULL;
}

etc.

[chebert, 2012/08/13 22:41:52]

Done.

+    const ListValue* list = NULL;
+    if (!value.GetList(kDocumentURLPatternsKey, &list))
+      return NULL;
+
+    for (size_t i = 0; i < list->GetSize(); ++i) {
+      std::string pattern;
+      if (!list->GetString(i, &pattern))
+        return NULL;
+      document_url_patterns.push_back(pattern);
+    }
+  }
+
+  std::vector<std::string> target_url_patterns;
+  if (value.HasKey(kTargetURLPatternsKey)) {
+    const ListValue* list = NULL;
+    if (!value.GetList(kTargetURLPatternsKey, &list))
+      return NULL;
+
+    for (size_t i = 0; i < list->GetSize(); ++i) {
+      std::string pattern;
+      if (!list->GetString(i, &pattern))
+        return NULL;
+      target_url_patterns.push_back(pattern);
+    }
+  }
+  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));
   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(const DictionaryValue& properties,
-                                   const char* document_url_patterns_key,
-                                   const char* target_url_patterns_key,
-                                   std::string* error) {
-  if (properties.HasKey(document_url_patterns_key)) {
-    const ListValue* list = NULL;
-    if (!properties.GetList(document_url_patterns_key, &list))
-      return false;
+bool MenuItem::PopulateURLPatterns(
+    std::vector<std::string>* document_url_patterns,
+    std::vector<std::string>* target_url_patterns,
+    std::string* error) {
+  if (document_url_patterns) {
     if (!document_url_patterns_.Populate(
-            *list, URLPattern::SCHEME_ALL, true, error)) {
+            *document_url_patterns, URLPattern::SCHEME_ALL, true, error)) {
       return false;
     }
   }
-  if (properties.HasKey(target_url_patterns_key)) {
-    const ListValue* list = NULL;
-    if (!properties.GetList(target_url_patterns_key, &list))
-      return false;
+  if (target_url_patterns) {
     if (!target_url_patterns_.Populate(
-            *list, URLPattern::SCHEME_ALL, true, error)) {
+            *target_url_patterns, URLPattern::SCHEME_ALL, true, error)) {
       return false;
     }
   }
   return true;
 }
 
 MenuManager::MenuManager(Profile* profile)
     : profile_(profile) {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile));
@@ skipping 542 matching lines @@
       if (uid < other.uid)
         return true;
       if (uid == other.uid)
         return string_uid < other.string_uid;
     }
   }
   return false;
 }
 
 }  // namespace extensions