Make all extension api types fully qualified.

chrome/common/extensions/api/extension_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/common/extensions/api/extension_api.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 107 matching lines @@
 
 struct Static {
   Static()
       : api(ExtensionAPI::CreateWithDefaultConfiguration()) {
   }
   scoped_ptr<ExtensionAPI> api;
 };
 
 base::LazyInstance<Static> g_lazy_instance = LAZY_INSTANCE_INITIALIZER;
 
+// If it exists and does not already specify a namespace, then the value stored
+// with key |key| in |schema| will be updated to |schema_namespace| + "." +
+// |schema[key]|.
+void MaybePrefixFieldWithNamespace(const std::string& schema_namespace,
+                                   DictionaryValue* schema,
+                                   const std::string& key) {
+  if (!schema->HasKey(key))
+    return;
+
+  std::string old_id;
+  CHECK(schema->GetString(key, &old_id));
+  if (old_id.find(".") == std::string::npos)
+    schema->SetString(key, schema_namespace + "." + old_id);
+}
+
+// Modify all objects in the "types" section of the schema to be prefixed by
+// |schema_namespace| if they do not already specify a namespace.

[asargent_no_longer_on_chrome, 2012/05/09 18:37:23]

nit: looks like this comment should go with PrefixTypesWithNamespace , and the
comment there should go here (this function is about refs, that one about
types).

[bryeung, 2012/05/09 19:12:00]

Oops.  Good catch!  Done.

+void PrefixRefsWithNamespace(const std::string& schema_namespace,
+                             Value* value) {
+  if (value->IsType(Value::TYPE_LIST)) {
+    ListValue* list;
+    CHECK(value->GetAsList(&list));
+    for (ListValue::iterator i = list->begin(); i != list->end(); ++i) {
+      PrefixRefsWithNamespace(schema_namespace, *i);
+    }
+  } else if (value->IsType(Value::TYPE_DICTIONARY)) {
+    DictionaryValue* dict;
+    CHECK(value->GetAsDictionary(&dict));
+    MaybePrefixFieldWithNamespace(schema_namespace, dict, "$ref");
+    for (DictionaryValue::key_iterator i = dict->begin_keys();
+        i != dict->end_keys(); ++i) {
+      Value* next_value;
+      CHECK(dict->GetWithoutPathExpansion(*i, &next_value));
+      PrefixRefsWithNamespace(schema_namespace, next_value);
+    }
+  }
+}
+
+// Modify all "$ref" keys anywhere in |schema| to be prefxied by
+// |schema_namespace| if they do not already specify a namespace.
+void PrefixTypesWithNamespace(const std::string& schema_namespace,
+                              DictionaryValue* schema) {
+  if (!schema->HasKey("types"))
+    return;
+
+  // Add the namespace to all of the types defined in this schema
+  ListValue *types;
+  CHECK(schema->GetList("types", &types));
+  for (size_t i = 0; i < types->GetSize(); ++i) {
+    DictionaryValue *type;
+    CHECK(types->GetDictionary(i, &type));
+    MaybePrefixFieldWithNamespace(schema_namespace, type, "id");
+    MaybePrefixFieldWithNamespace(schema_namespace, type, "customBindings");
+  }
+}
+
+// Modify the schema so that all types are fully qualified.
+void PrefixWithNamespace(const std::string& schema_namespace,
+                         DictionaryValue* schema) {
+  PrefixTypesWithNamespace(schema_namespace, schema);
+  PrefixRefsWithNamespace(schema_namespace, schema);
+}
+
 }  // namespace
 
 // static
 ExtensionAPI* ExtensionAPI::GetSharedInstance() {
   return g_lazy_instance.Get().api.get();
 }
 
 // static
 ExtensionAPI* ExtensionAPI::CreateWithDefaultConfiguration() {
   ExtensionAPI* api = new ExtensionAPI();
@@ skipping 16 matching lines @@
   *feature_type = full_name.substr(0, colon_index);
   *feature_name = full_name.substr(colon_index + 1);
 }
 
 void ExtensionAPI::LoadSchema(const std::string& name,
                               const base::StringPiece& schema) {
   scoped_ptr<ListValue> schema_list(LoadSchemaList(name, schema));
   std::string schema_namespace;
 
   while (!schema_list->empty()) {
-    const DictionaryValue* schema = NULL;
+    DictionaryValue* schema = NULL;
     {
       Value* value = NULL;
       schema_list->Remove(schema_list->GetSize() - 1, &value);
       CHECK(value->IsType(Value::TYPE_DICTIONARY));
-      schema = static_cast<const DictionaryValue*>(value);
+      schema = static_cast<DictionaryValue*>(value);
     }
 
     CHECK(schema->GetString("namespace", &schema_namespace));
+    PrefixWithNamespace(schema_namespace, schema);
     schemas_[schema_namespace] = make_linked_ptr(schema);
     CHECK_EQ(1u, unloaded_schemas_.erase(schema_namespace));
 
     // Populate |{completely,partially}_unprivileged_apis_|.
     //
     // For "partially", only need to look at functions/events; even though
     // there are unprivileged properties (e.g. in extensions), access to those
     // never reaches C++ land.
     if (schema->HasKey("unprivileged")) {
       completely_unprivileged_apis_.insert(schema_namespace);
@@ skipping 543 matching lines @@
 
 void ExtensionAPI::LoadAllSchemas() {
   while (unloaded_schemas_.size()) {
     std::map<std::string, base::StringPiece>::iterator it =
         unloaded_schemas_.begin();
     LoadSchema(it->first, it->second);
   }
 }
 
 }  // namespace extensions