Handle extension webrequest API on the IO thread. This speeds up blocking event

chrome/renderer/extensions/extension_process_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 <set>
 #include <string>
 #include <vector>
 
@@ skipping 150 matching lines @@
     } 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("GetCurrentPageActions"))) {
       return v8::FunctionTemplate::New(GetCurrentPageActions,
                                        v8::External::New(this));
     } else if (name->Equals(v8::String::New("StartRequest"))) {
       return v8::FunctionTemplate::New(StartRequest,
                                        v8::External::New(this));
+    } else if (name->Equals(v8::String::New("StartRequestForIOThread"))) {
+      return v8::FunctionTemplate::New(StartRequestForIOThread,
+                                       v8::External::New(this));
     } else if (name->Equals(v8::String::New("GetRenderViewId"))) {
       return v8::FunctionTemplate::New(GetRenderViewId);
     } else if (name->Equals(v8::String::New("SetIconCommon"))) {
       return v8::FunctionTemplate::New(SetIconCommon,
                                        v8::External::New(this));
     } else if (name->Equals(v8::String::New("IsExtensionProcess"))) {
       return v8::FunctionTemplate::New(IsExtensionProcess,
                                        v8::External::New(this));
     } else if (name->Equals(v8::String::New("IsIncognitoProcess"))) {
       return v8::FunctionTemplate::New(IsIncognitoProcess);
@@ skipping 201 matching lines @@
                               v8::String::New(id.c_str(), id.size()));
     }
 
     return page_action_vector;
   }
 
   // Common code for starting an API request to the browser. |value_args|
   // contains the request's arguments.
   // Steals value_args contents for efficiency.
   static v8::Handle<v8::Value> StartRequestCommon(
-      const v8::Arguments& args, ListValue* value_args) {
+      const v8::Arguments& args, ListValue* value_args, bool for_io_thread) {
     ExtensionImpl* v8_extension = GetFromArguments<ExtensionImpl>(args);
 
     // Get the current RenderView so that we can send a routed IPC message from
     // the correct source.
     RenderView* renderview = bindings_utils::GetRenderViewForCurrentContext();
     if (!renderview)
       return v8::Undefined();
 
     std::string name = *v8::String::AsciiValue(args[0]);
     const std::set<std::string>& function_names =
@@ skipping 20 matching lines @@
     GetPendingRequestMap()[request_id].reset(new PendingRequest(
         current_context, name));
 
     ExtensionHostMsg_Request_Params params;
     params.name = name;
     params.arguments.Swap(value_args);
     params.source_url = source_url;
     params.request_id = request_id;
     params.has_callback = has_callback;
     params.user_gesture = webframe->isProcessingUserGesture();
-    renderview->Send(new ExtensionHostMsg_Request(
-        renderview->routing_id(), params));
+    if (for_io_thread) {
+      renderview->Send(new ExtensionHostMsg_RequestForIOThread(
+          renderview->routing_id(), params));
+    } else {
+      renderview->Send(new ExtensionHostMsg_Request(
+          renderview->routing_id(), params));
+    }
 
     return v8::Undefined();
   }
 
   // Starts an API request to the browser, with an optional callback.  The
   // callback will be dispatched to EventBindings::HandleResponse.
   static v8::Handle<v8::Value> StartRequest(const v8::Arguments& args) {
     std::string str_args = *v8::String::Utf8Value(args[1]);
     base::JSONReader reader;
     scoped_ptr<Value> value_args;
     value_args.reset(reader.JsonToValue(str_args, false, false));
 
     // Since we do the serialization in the v8 extension, we should always get
     // valid JSON.
     if (!value_args.get() || !value_args->IsType(Value::TYPE_LIST)) {
       NOTREACHED() << "Invalid JSON passed to StartRequest.";
       return v8::Undefined();
     }
 
-    return StartRequestCommon(args, static_cast<ListValue*>(value_args.get()));
+    return StartRequestCommon(args, static_cast<ListValue*>(value_args.get()),
+                              false);
+  }
+
+  // Starts an API request to the browser, with an optional callback.  The
+  // callback will be dispatched to EventBindings::HandleResponse.
+  static v8::Handle<v8::Value> StartRequestForIOThread(

[Mihai Parparita -not on Chrome, 2011/06/08 01:11:59]

This seems very similar to StartRequest. Can the for_io_thread bool just be a JS
parameter to StartRequest?

[Matt Perry, 2011/06/08 20:47:00]

Done.

+      const v8::Arguments& args) {
+    std::string str_args = *v8::String::Utf8Value(args[1]);
+    base::JSONReader reader;
+    scoped_ptr<Value> value_args;
+    value_args.reset(reader.JsonToValue(str_args, false, false));
+
+    // Since we do the serialization in the v8 extension, we should always get
+    // valid JSON.
+    if (!value_args.get() || !value_args->IsType(Value::TYPE_LIST)) {
+      NOTREACHED() << "Invalid JSON passed to StartRequest.";

[Mihai Parparita -not on Chrome, 2011/06/08 01:11:59]

If you do keep this function, the message here should be updated to say
StartRequestForIOThread.

+      return v8::Undefined();
+    }
+
+    return StartRequestCommon(args, static_cast<ListValue*>(value_args.get()),
+                              true);
   }
 
   static bool ConvertImageDataToBitmapValue(
       const v8::Arguments& args, Value** bitmap_value) {
     v8::Local<v8::Object> extension_args = args[1]->ToObject();
     v8::Local<v8::Object> details =
         extension_args->Get(v8::String::New("0"))->ToObject();
     v8::Local<v8::Object> image_data =
         details->Get(v8::String::New("imageData"))->ToObject();
     v8::Local<v8::Object> data =
@@ skipping 48 matching lines @@
     dict->Set("imageData", bitmap_value);
 
     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);
+    return StartRequestCommon(args, &list_value, false);
   }
 
   static v8::Handle<v8::Value> GetRenderViewId(const v8::Arguments& args) {
     RenderView* renderview = bindings_utils::GetRenderViewForCurrentContext();
     if (!renderview)
       return v8::Undefined();
     return v8::Integer::New(renderview->routing_id());
   }
 
   static v8::Handle<v8::Value> IsExtensionProcess(const v8::Arguments& args) {
@@ skipping 40 matching lines @@
   if (!retval.IsEmpty() && !retval->IsUndefined()) {
     std::string error = *v8::String::AsciiValue(retval);
     DCHECK(false) << error;
   }
 #endif
 
   request->second->context.Dispose();
   request->second->context.Clear();
   pending_requests.erase(request);
 }