Make a process-wide cache for the v8::Value representation of extension APIs.

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 60 matching lines @@
  public:
   explicit ExtensionImpl(ExtensionDispatcher* extension_dispatcher)
       : ChromeV8Extension(extension_dispatcher) {
     RouteStaticFunction("GetExtensionAPIDefinition",
                         &GetExtensionAPIDefinition);
     RouteStaticFunction("GetNextRequestId", &GetNextRequestId);
     RouteStaticFunction("StartRequest", &StartRequest);
     RouteStaticFunction("SetIconCommon", &SetIconCommon);
   }
 
-  ~ExtensionImpl() {
-    // TODO(aa): It seems that v8 never deletes us, so this doesn't get called.
-    // Leaving this in here in case v8's implementation ever changes.
-    for (CachedSchemaMap::iterator it = schemas_.begin(); it != schemas_.end();
-        ++it) {
-      if (!it->second.IsEmpty())
-        it->second.Dispose();
-    }
-  }
-
  private:
-  static v8::Handle<v8::Value> GetV8SchemaForAPI(
-      ExtensionImpl* self,
-      v8::Handle<v8::Context> context,
-      const std::string& api_name) {
-    CachedSchemaMap::iterator maybe_api = self->schemas_.find(api_name);
-    if (maybe_api != self->schemas_.end())
-      return maybe_api->second;
-
-    scoped_ptr<V8ValueConverter> v8_value_converter(V8ValueConverter::create());
-    const base::DictionaryValue* schema =
-        ExtensionAPI::GetInstance()->GetSchema(api_name);
-    CHECK(schema) << api_name;
-
-    self->schemas_[api_name] =
-        v8::Persistent<v8::Object>::New(v8::Handle<v8::Object>::Cast(
-            v8_value_converter->ToV8Value(schema, context)));
-    CHECK(!self->schemas_[api_name].IsEmpty());
-
-    return self->schemas_[api_name];
-  }
-
   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);
 
-    // TODO(kalman): can we just cache this in the ChromeV8Context instance?
     scoped_ptr<std::set<std::string> > apis;
 
     const std::string& extension_id = v8_context->extension_id();
     if (dispatcher->IsTestExtensionId(extension_id)) {
       apis.reset(new std::set<std::string>());
       // The minimal set of APIs that tests need.
       apis->insert("extension");
     } else {
       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(apis->size()));
-    size_t api_index = 0;
-    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;
+    return dispatcher->v8_schema_registry()->GetSchemas(*apis);
   }
 
   static v8::Handle<v8::Value> GetNextRequestId(const v8::Arguments& args) {
     static int next_request_id = 0;
     return v8::Integer::New(next_request_id++);
   }
 
   // Common code for starting an API request to the browser. |value_args|
   // contains the request's arguments.
   // Steals value_args contents for efficiency.
@@ skipping 142 matching lines @@
     if (details->Has(v8::String::New("tabId"))) {
       dict->SetInteger("tabId",
                        details->Get(v8::String::New("tabId"))->Int32Value());
     }
 
     ListValue list_value;
     list_value.Append(dict);
 
     return StartRequestCommon(args, &list_value);
   }
-
-  // Cached JS Array representation of each namespace in extension_api.json.
-  // 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);
@@ skipping 55 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