Enable extension APIs for content scripts.

chrome/renderer/extensions/schema_generated_bindings.cc

 // Copyright (c) 2011 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/extension_process_bindings.h"
+#include "chrome/renderer/extensions/schema_generated_bindings.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/extensions/url_pattern.h"
+#include "chrome/common/extensions/api/extension_api.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/common/chrome_view_types.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/render_view_visitor.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/extension_helper.h"
-#include "chrome/renderer/extensions/renderer_extension_bindings.h"
+#include "chrome/renderer/extensions/miscellaneous_bindings.h"
 #include "chrome/renderer/extensions/user_script_slave.h"
-#include "chrome/renderer/static_v8_external_string_resource.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/WebBlob.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/WebView.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::V8ValueConverter;
+using extensions::ExtensionAPI;
 using WebKit::WebFrame;
 using WebKit::WebView;
 
 namespace {
 
 const char* kExtensionDeps[] = {
   "extensions/event.js",
   "extensions/json_schema.js",
-  "extensions/renderer_extension_bindings.js",
+  "extensions/miscellaneous_bindings.js",
   "extensions/apitest.js"
 };
 
 // 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)
       : context(context), name(name), extension_id(extension_id) {
   }
@@ skipping 81 matching lines @@
   std::string extension_id_;
   int browser_window_id_;
   content::ViewType view_type_;
   v8::Local<v8::Array> views_;
   int index_;
 };
 
 class ExtensionImpl : public ChromeV8Extension {
  public:
   explicit ExtensionImpl(ExtensionDispatcher* extension_dispatcher)
-      : ChromeV8Extension("extensions/extension_process_bindings.js",
-                          IDR_EXTENSION_PROCESS_BINDINGS_JS,
+      : ChromeV8Extension("extensions/schema_generated_bindings.js",
+                          IDR_SCHEMA_GENERATED_BINDINGS_JS,
                           arraysize(kExtensionDeps),
                           kExtensionDeps,
                           extension_dispatcher) {
   }
-  ~ExtensionImpl() {}
+
+  ~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.
+    if (!extension_api_.IsEmpty())
+      extension_api_.Dispose();
+  }
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
-      v8::Handle<v8::String> name) {
+      v8::Handle<v8::String> name) OVERRIDE {
     if (name->Equals(v8::String::New("GetExtensionAPIDefinition"))) {
-      return v8::FunctionTemplate::New(GetExtensionAPIDefinition);
+      return v8::FunctionTemplate::New(GetExtensionAPIDefinition,
+                                       v8::External::New(this));
     } else if (name->Equals(v8::String::New("GetExtensionViews"))) {
       return v8::FunctionTemplate::New(GetExtensionViews,
                                        v8::External::New(this));
     } else if (name->Equals(v8::String::New("GetNextRequestId"))) {
       return v8::FunctionTemplate::New(GetNextRequestId);
     } else if (name->Equals(v8::String::New("OpenChannelToTab"))) {
       return v8::FunctionTemplate::New(OpenChannelToTab);
     } else if (name->Equals(v8::String::New("GetNextContextMenuId"))) {
       return v8::FunctionTemplate::New(GetNextContextMenuId);
     } else if (name->Equals(v8::String::New("GetNextTtsEventId"))) {
@@ skipping 18 matching lines @@
     } else if (name->Equals(v8::String::New("CreateBlob"))) {
       return v8::FunctionTemplate::New(CreateBlob, v8::External::New(this));
     }
 
     return ChromeV8Extension::GetNativeFunction(name);
   }
 
  private:
   static v8::Handle<v8::Value> GetExtensionAPIDefinition(
       const v8::Arguments& args) {
-    return v8::String::NewExternal(
-        new StaticV8ExternalAsciiStringResource(
-            ResourceBundle::GetSharedInstance().GetRawDataResource(
-                IDR_EXTENSION_API_JSON)));
+    ExtensionImpl* self = GetFromArguments<ExtensionImpl>(args);
+    if (!self->extension_api_.IsEmpty())
+      return self->extension_api_;
+
+    v8::Persistent<v8::Context> context(v8::Context::New());
+    v8::Context::Scope context_scope(context);
+
+    scoped_ptr<V8ValueConverter> v8_value_converter(V8ValueConverter::create());
+    self->extension_api_ = v8::Persistent<v8::Array>::New(
+        v8::Handle<v8::Array>::Cast(
+            v8_value_converter->ToV8Value(
+                ExtensionAPI::GetInstance()->value(), context)));
+    CHECK(!self->extension_api_.IsEmpty());
+
+    // The persistent extension_api_ will keep the context alive.
+    context.Dispose();
+
+    return self->extension_api_;
   }
 
   static v8::Handle<v8::Value> GetExtensionViews(const v8::Arguments& args) {
     if (args.Length() != 2)
       return v8::Undefined();
 
     if (!args[0]->IsInt32() || !args[1]->IsString())
       return v8::Undefined();
 
     // |browser_window_id| == extension_misc::kUnknownWindowId means getting
@@ skipping 223 matching lines @@
       return v8::Undefined();
 
     std::string name = *v8::String::AsciiValue(args[0]);
     const std::set<std::string>& function_names =
         v8_extension->extension_dispatcher_->function_names();
     if (function_names.find(name) == function_names.end()) {
       NOTREACHED() << "Unexpected function " << name;
       return v8::Undefined();
     }
 
-    // TODO(aa): add this to ChromeV8Context.
-    if (!v8_extension->CheckPermissionForCurrentRenderView(name))
+    if (!v8_extension->CheckCurrentContextAccessToExtensionAPI(name))
       return v8::Undefined();
 
     GURL source_url;
     WebFrame* webframe = current_context->web_frame();
     if (webframe)
       source_url = webframe->document().url();
 
     int request_id = args[2]->Int32Value();
     bool has_callback = args[3]->BooleanValue();
     bool for_io_thread = args[4]->BooleanValue();
 
     v8::Persistent<v8::Context> v8_context =
         v8::Persistent<v8::Context>::New(v8::Context::GetCurrent());
     DCHECK(!v8_context.IsEmpty());
     g_pending_requests.Get()[request_id].reset(new PendingRequest(
         v8_context, name, current_context->extension_id()));
 
     ExtensionHostMsg_Request_Params params;
     params.name = name;
     params.arguments.Swap(value_args);
+    params.extension_id = current_context->extension_id();
     params.source_url = source_url;
     params.request_id = request_id;
     params.has_callback = has_callback;
     params.user_gesture =
         webframe ? webframe->isProcessingUserGesture() : false;
     if (for_io_thread) {
       renderview->Send(new ExtensionHostMsg_RequestForIOThread(
           renderview->GetRoutingId(), params));
     } else {
       renderview->Send(new ExtensionHostMsg_Request(
@@ skipping 89 matching lines @@
 
     return StartRequestCommon(args, &list_value);
   }
 
   static v8::Handle<v8::Value> GetRenderViewId(const v8::Arguments& args) {
     content::RenderView* renderview = GetCurrentRenderView();
     if (!renderview)
       return v8::Undefined();
     return v8::Integer::New(renderview->GetRoutingId());
   }
+
+  // Cached JS Array representation of 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.
+  v8::Persistent<v8::Array> extension_api_;
 };
 
 }  // namespace
 
-v8::Extension* ExtensionProcessBindings::Get(
+namespace extensions {
+
+v8::Extension* SchemaGeneratedBindings::Get(
     ExtensionDispatcher* extension_dispatcher) {
   static v8::Extension* extension = new ExtensionImpl(extension_dispatcher);
   CHECK_EQ(extension_dispatcher,
            static_cast<ExtensionImpl*>(extension)->extension_dispatcher());
   return extension;
 }
 
 // static
-void ExtensionProcessBindings::HandleResponse(
-    const ChromeV8ContextSet& contexts,
-    int request_id,
-    bool success,
-    const std::string& response,
-    const std::string& error,
-    std::string* extension_id) {
+void SchemaGeneratedBindings::HandleResponse(const ChromeV8ContextSet& contexts,
+                                             int request_id,
+                                             bool success,
+                                             const std::string& response,
+                                             const std::string& error,
+                                             std::string* extension_id) {
   PendingRequestMap::iterator request =
       g_pending_requests.Get().find(request_id);
   if (request == g_pending_requests.Get().end()) {
     // This should not be able to happen since we only remove requests when they
     // are handled.
     LOG(ERROR) << "Could not find specified request id: " << request_id;
     return;
   }
 
   ChromeV8Context* v8_context =
@@ skipping 25 matching lines @@
 
   // Save the extension id before erasing the request.
   *extension_id = request->second->extension_id;
 
   request->second->context.Dispose();
   request->second->context.Clear();
   g_pending_requests.Get().erase(request);
 }
 
 // static
-bool ExtensionProcessBindings::HasPendingRequests(
+bool SchemaGeneratedBindings::HasPendingRequests(
     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