Convert app_bindings.js to the schema_generated_bindings.js infrastructure.

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>
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_permission_set.h"
+#include "googleurl/src/gurl.h"
 #include "grit/common_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace extensions {
 
 namespace {
 
 // Adds any APIs listed in "dependencies" found in |schema| but not in
 // |reference| to |out|.
 void GetMissingDependencies(
@@ skipping 60 matching lines @@
     loaded->Remove(loaded->GetSize() - 1, &value);
     CHECK(value->IsType(Value::TYPE_DICTIONARY));
     const DictionaryValue* schema = static_cast<const DictionaryValue*>(value);
     CHECK(schema->GetString("namespace", &schema_namespace));
     schemas_[schema_namespace] = linked_ptr<const DictionaryValue>(schema);
   }
 }
 
 ExtensionAPI::ExtensionAPI() {
   static int kJsonApiResourceIds[] = {
+    IDR_EXTENSION_API_JSON_APP,
     IDR_EXTENSION_API_JSON_BOOKMARKS,
     IDR_EXTENSION_API_JSON_BROWSERACTION,
     IDR_EXTENSION_API_JSON_CHROMEAUTHPRIVATE,
     IDR_EXTENSION_API_JSON_CHROMEOSINFOPRIVATE,
     IDR_EXTENSION_API_JSON_CHROMEPRIVATE,
     IDR_EXTENSION_API_JSON_CONTENTSETTINGS,
     IDR_EXTENSION_API_JSON_CONTEXTMENUS,
     IDR_EXTENSION_API_JSON_COOKIES,
     IDR_EXTENSION_API_JSON_DEBUGGER,
     IDR_EXTENSION_API_JSON_DEVTOOLS,
@@ skipping 62 matching lines @@
       continue;
     }
 
     // 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 (HasUnprivilegedChild(it->second.get(), "functions") ||
         HasUnprivilegedChild(it->second.get(), "events")) {
       partially_unprivileged_apis_.insert(it->first);
     }
   }
+
+  // Populate |url_matching_apis_|.
+  for (SchemaMap::const_iterator it = schemas_.begin();
+      it != schemas_.end(); ++it) {
+    ListValue* matches = NULL;
+    {
+      Value* matches_value = NULL;
+      if (!it->second->Get("matches", &matches_value))
+        continue;
+      CHECK_EQ(Value::TYPE_LIST, matches_value->GetType());
+      matches = static_cast<ListValue*>(matches_value);
+    }
+    URLPatternSet pattern_set;
+    for (size_t i = 0; i < matches->GetSize(); ++i) {
+      std::string pattern;
+      CHECK(matches->GetString(i, &pattern));
+      pattern_set.AddPattern(
+          URLPattern(UserScript::kValidUserScriptSchemes, pattern));
+    }
+    url_matching_apis_[it->first] = pattern_set;
+  }
 }
 
 ExtensionAPI::~ExtensionAPI() {
 }
 
 bool ExtensionAPI::IsPrivileged(const std::string& full_name) const {
   std::string api_name;
   std::string child_name;
 
   {
@@ skipping 114 matching lines @@
     if (permissions.HasAnyAccessToAPI(it->first))
       (*out)[it->first] = it->second;
   }
 }
 
 bool ExtensionAPI::IsWholeAPIPrivileged(const std::string& api_name) const {
   return !completely_unprivileged_apis_.count(api_name) &&
          !partially_unprivileged_apis_.count(api_name);
 }
 
+bool ExtensionAPI::MatchesURL(
+    const std::string& api_name, const GURL& url) const {
+  std::map<std::string, URLPatternSet>::const_iterator it =
+      url_matching_apis_.find(api_name);
+  return it != url_matching_apis_.end() && it->second.MatchesURL(url);
+}
+
+void ExtensionAPI::GetSchemasForURL(const GURL& url, SchemaMap* out) const {
+  for (std::map<std::string, URLPatternSet>::const_iterator it =
+      url_matching_apis_.begin(); it != url_matching_apis_.end(); ++it) {
+    if (it->second.MatchesURL(url))
+      (*out)[it->first] = schemas_.find(it->first)->second;
+  }
+}
+
 }  // namespace extensions