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 100 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): can we just cache this in the ChromeV8Context instance?

[not at google - send to devlin, 2012/03/20 03:32:13]

I deleted this TODO because it *was* no longer relevant given we were only
looking at the available APIs here. However, now they're also being queried in
extension_dispatcher.cc, so perhaps we should revisit something like this. 
WDYT?

[koz (OOO until 15th September), 2012/03/20 04:43:05]

I can't think of any particularly good reason not to.

[not at google - send to devlin, 2012/03/20 07:02:05]

Bahhhhhhhhhhhhhhhhhhh turns out this is hard because of the fake extension ID
created in extension_messages_browsertest.cc (ExtensionMessagesOnConnect and
friend(s)). Which need to be known because parts of code is predicated on that
crap.

I'm really really sick of those tests though, once again they're silently
failing for no good reason (well, because I'm forgetting to check for
IsTestExtensionID in some place... grrrrrr).

Ok, I'm going to fix that freaking test tomorrow. Surely it can't be hard to
just create a fake extension then make sure it's added to the extension set??
Surely???

[koz (OOO until 15th September), 2012/03/20 23:04:18]

Surely!

+    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

[koz (OOO until 15th September), 2012/03/20 04:43:05]

"this caching" -> "the caching in GetV8SchemaForAPI"?

Or change GetV8SchemaForAPI() to GetAndCacheV8SchemaForAPI().

[not at google - send to devlin, 2012/03/20 07:02:05]

I've actually fixed this in a follow-up http://codereview.chromium.org/9616055/

(and then messed it up again. but I will un-mess it soon)

+      // 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