Convert app_bindings.js to the schema_generated_bindings.js infrastructure.

chrome/renderer/extensions/schema_generated_bindings.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/renderer/extensions/schema_generated_bindings.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 13 matching lines @@
 #include "chrome/common/extensions/api/extension_api.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/chrome_render_process_observer.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/extensions/chrome_v8_context_set.h"
 #include "chrome/renderer/extensions/chrome_v8_extension.h"
 #include "chrome/renderer/extensions/event_bindings.h"
 #include "chrome/renderer/extensions/extension_dispatcher.h"
 #include "chrome/renderer/extensions/miscellaneous_bindings.h"
 #include "chrome/renderer/extensions/user_script_slave.h"
+#include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "grit/common_resources.h"
 #include "grit/renderer_resources.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 #include "webkit/glue/webkit_glue.h"
 
+using content::RenderThread;
 using content::V8ValueConverter;
 using extensions::ExtensionAPI;
+using extensions::Feature;
 using WebKit::WebFrame;
 using WebKit::WebSecurityOrigin;
 
 namespace {
 
 // Contains info relevant to a pending API request.
 struct PendingRequest {
  public :
   PendingRequest(v8::Persistent<v8::Context> context, const std::string& name,
                  const std::string& extension_id)
@@ skipping 52 matching lines @@
   }
 
   static v8::Handle<v8::Value> GetExtensionAPIDefinition(
       const v8::Arguments& args) {
     ExtensionImpl* self = GetFromArguments<ExtensionImpl>(args);
     ExtensionDispatcher* dispatcher = self->extension_dispatcher_;
 
     ChromeV8Context* v8_context = dispatcher->v8_context_set().GetCurrent();
     CHECK(v8_context);
 
-    std::string extension_id = v8_context->extension_id();
-    ExtensionAPI::SchemaMap schemas;
-    ExtensionAPI::GetSchemasFilter filter =
-        dispatcher->is_extension_process() ?
-            ExtensionAPI::ALL : ExtensionAPI::ONLY_UNPRIVILEGED;
+    // TODO(kalman): This is being calculated twice, first in
+    // ExtensionDispatcher then again here. It might as well be a property of
+    // ChromeV8Context, however, this would require making ChromeV8Context take
+    // an Extension rather than an extension ID.  In itself this is fine,
+    // however it does not play correctly with the "IsTestExtensionId" checks.
+    // We need to remove that first.
+    scoped_ptr<std::set<std::string> > apis;
 
+    const std::string& extension_id = v8_context->extension_id();
     if (dispatcher->IsTestExtensionId(extension_id)) {
-      ExtensionAPI::GetInstance()->GetDefaultSchemas(filter, &schemas);
+      apis.reset(new std::set<std::string>());
+      // The minimal set of APIs that tests need.
+      apis->insert("extension");
     } else {
-      const ::Extension* extension =
-          dispatcher->extensions()->GetByID(extension_id);
-      CHECK(extension) << extension_id << " not found";
-      ExtensionAPI::GetInstance()->GetSchemasForExtension(
-          *extension, filter, &schemas);
+      apis = ExtensionAPI::GetInstance()->GetAPIsForContext(
+          v8_context->context_type(),
+          dispatcher->extensions()->GetByID(extension_id),
+          UserScriptSlave::GetDataSourceURLForFrame(v8_context->web_frame()));
     }
 
     v8::Persistent<v8::Context> context(v8::Context::New());
     v8::Context::Scope context_scope(context);
-    v8::Handle<v8::Array> api(v8::Array::New(schemas.size()));
+    v8::Handle<v8::Array> api(v8::Array::New(apis->size()));
     size_t api_index = 0;
-    for (ExtensionAPI::SchemaMap::iterator it = schemas.begin();
-        it != schemas.end(); ++it) {
-      std::string api_name = it->first;
-      api->Set(api_index, GetV8SchemaForAPI(self, context, api_name));
+    for (std::set<std::string>::iterator i = apis->begin(); i != apis->end();
+        ++i) {
+      // TODO(kalman): this caching is actually useless now, because
+      // SchemaGeneratedBindings is per-context not per-process. We should
+      // (e.g.) hang a SchemaRegistry off ExtensionDispatcher (which maintains
+      // a *single* v8::Context rather than multiple ones as here).
+      api->Set(api_index, GetV8SchemaForAPI(self, context, *i));
       ++api_index;
     }
 
     // The persistent extension_api_ will keep the context alive.
     context.Dispose();
 
     return api;
   }
 
   static v8::Handle<v8::Value> GetNextRequestId(const v8::Arguments& args) {
@@ skipping 161 matching lines @@
   // We store this so that we don't have to parse it over and over again for
   // every context that uses it.
   typedef std::map<std::string, v8::Persistent<v8::Object> > CachedSchemaMap;
   CachedSchemaMap schemas_;
 };
 
 }  // namespace
 
 namespace extensions {
 
+// static
 ChromeV8Extension* SchemaGeneratedBindings::Get(
     ExtensionDispatcher* extension_dispatcher) {
   return new ExtensionImpl(extension_dispatcher);
 }
 
 // static
 void SchemaGeneratedBindings::HandleResponse(const ChromeV8ContextSet& contexts,
                                              int request_id,
                                              bool success,
                                              const std::string& response,
@@ skipping 48 matching lines @@
     const std::string& extension_id) {
   for (PendingRequestMap::const_iterator it = g_pending_requests.Get().begin();
        it != g_pending_requests.Get().end(); ++it) {
     if (it->second->extension_id == extension_id)
       return true;
   }
   return false;
 }
 
 }  // namespace