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

chrome/browser/extensions/extension_function.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_
 #pragma once
 
 #include <string>
 #include <list>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/process.h"
+#include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_observer.h"
 #include "content/common/notification_registrar.h"
+#include "ipc/ipc_message.h"
 
 class Browser;
+class ChromeRenderMessageFilter;
 class ExtensionFunction;
 class ExtensionFunctionDispatcher;
 class UIThreadExtensionFunction;
+class IOThreadExtensionFunction;
 class ListValue;
 class QuotaLimitHeuristic;
 class RenderViewHost;
 class Value;
 
 #define EXTENSION_FUNCTION_VALIDATE(test) do { \
     if (!(test)) { \
       bad_message_ = true; \
       return false; \
     } \
@@ skipping 18 matching lines @@
 
 // Abstract base class for extension functions the ExtensionFunctionDispatcher
 // knows how to dispatch to.
 class ExtensionFunction
     : public base::RefCountedThreadSafe<ExtensionFunction,
                                         ExtensionFunctionDeleteTraits> {
  public:
   ExtensionFunction();
 
   virtual UIThreadExtensionFunction* AsUIThreadExtensionFunction();
+  virtual IOThreadExtensionFunction* AsIOThreadExtensionFunction();
 
   // Execute the API. Clients should initialize the ExtensionFunction using
   // SetArgs(), set_request_id(), and the other setters before calling this
   // method. Derived classes should be ready to return GetResult() and
   // GetError() before returning from this function.
   // Note that once Run() returns, dispatcher() can be NULL, so be sure to
   // NULL-check.
   virtual void Run();
 
   // Returns a quota limit heuristic suitable for this function.
@@ skipping 45 matching lines @@
   // Helper method for ExtensionFunctionDeleteTraits. Deletes this object.
   virtual void Destruct() const = 0;
 
   // Derived classes should implement this method to do their work and return
   // success/failure.
   virtual bool RunImpl() = 0;
 
   // Sends the result back to the extension.
   virtual void SendResponse(bool success) = 0;
 
+  // Common implementation for SenderResponse.
+  void SendResponseImpl(base::ProcessHandle process,
+                        IPC::Message::Sender* ipc_sender,
+                        int routing_id,
+                        bool success);
+
   // Called when we receive an extension api request that is invalid in a way
   // that JSON validation in the renderer should have caught. This should never
   // happen and could be an attacker trying to exploit the browser, so we crash
   // the renderer instead.
-  virtual void HandleBadMessage() = 0;
+  void HandleBadMessage(base::ProcessHandle process);
 
   // Return true if the argument to this function at |index| was provided and
   // is non-null.
   bool HasOptionalArgument(size_t index);
 
   // Id of this request, used to map the response back to the caller.
   int request_id_;
 
   // The ID of the Profile of this function's extension.
   ProfileId profile_id_;
@@ skipping 108 matching lines @@
    public:
     explicit RenderViewHostTracker(UIThreadExtensionFunction* function);
    private:
     virtual void Observe(NotificationType type,
                          const NotificationSource& source,
                          const NotificationDetails& details);
     UIThreadExtensionFunction* function_;
     NotificationRegistrar registrar_;
   };
 
-  virtual void HandleBadMessage();
-
   virtual void Destruct() const;
 
   scoped_ptr<RenderViewHostTracker> tracker_;
+};
 
+// Extension functions that run on the IO thread.
+class IOThreadExtensionFunction : public ExtensionFunction {
+ public:
+  IOThreadExtensionFunction();
+
+  virtual IOThreadExtensionFunction* AsIOThreadExtensionFunction() OVERRIDE;
+
+  void set_ipc_sender(base::WeakPtr<ChromeRenderMessageFilter> ipc_sender,
+                      int routing_id) {
+    ipc_sender_ = ipc_sender;
+    routing_id_ = routing_id;
+  }
+  ChromeRenderMessageFilter* ipc_sender() const { return ipc_sender_.get(); }
+  int routing_id() const { return routing_id_; }
+
+  base::WeakPtr<ChromeRenderMessageFilter> ipc_sender_weak() const {
+    return ipc_sender_;
+  }
+
+  void set_extension_info_map(const ExtensionInfoMap* extension_info_map) {
+    extension_info_map_ = extension_info_map;
+  }
+  const ExtensionInfoMap* extension_info_map() const {
+    return extension_info_map_.get();
+  }
+
+ protected:
+  friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
+  friend class DeleteTask<IOThreadExtensionFunction>;
+
+  virtual ~IOThreadExtensionFunction();
+
+  virtual void Destruct() const;
+
+  virtual void SendResponse(bool success);
+
+ private:
+  base::WeakPtr<ChromeRenderMessageFilter> ipc_sender_;
+  int routing_id_;
+
+  scoped_refptr<const ExtensionInfoMap> extension_info_map_;
 };
 
 // Base class for an extension function that runs asynchronously *relative to
 // the browser's UI thread*.
 class AsyncExtensionFunction : public UIThreadExtensionFunction {
  public:
   AsyncExtensionFunction();
 
  protected:
-  virtual ~AsyncExtensionFunction();
+  ~AsyncExtensionFunction();

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

Why is this no longer virtual?

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

oops

 };
 
 // A SyncExtensionFunction is an ExtensionFunction that runs synchronously
 // *relative to the browser's UI thread*. Note that this has nothing to do with
 // running synchronously relative to the extension process. From the extension
 // process's point of view, the function is still asynchronous.
 //
 // This kind of function is convenient for implementing simple APIs that just
 // need to interact with things on the browser UI thread.
 class SyncExtensionFunction : public UIThreadExtensionFunction {
  public:
   SyncExtensionFunction();
 
   virtual void Run() OVERRIDE;
 
  protected:
   virtual ~SyncExtensionFunction();
+};
 
- private:
-  DISALLOW_COPY_AND_ASSIGN(SyncExtensionFunction);
+class SyncIOThreadExtensionFunction : public IOThreadExtensionFunction {
+ public:
+  SyncIOThreadExtensionFunction();
+
+  virtual void Run() OVERRIDE;
+
+ protected:
+  virtual ~SyncIOThreadExtensionFunction();
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_