Refactor to allow same code to test both sync and async functions.

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 <list>
 #include <string>
@@ skipping 190 matching lines @@
   // returning.  The calling renderer process will be killed.
   bool bad_message_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionFunction);
 };
 
 // Extension functions that run on the UI thread. Most functions fall into
 // this category.
 class UIThreadExtensionFunction : public ExtensionFunction {
  public:
+  // A delegate for use in testing, to intercept the call to SendResponse.
+  class DelegateForTests {
+   public:
+    virtual void OnSendResponse(UIThreadExtensionFunction* function,
+                                bool success) = 0;
+  };
+
   UIThreadExtensionFunction();
 
   virtual UIThreadExtensionFunction* AsUIThreadExtensionFunction() OVERRIDE;
 
+  void set_test_delegate(DelegateForTests* delegate) {
+    delegate_ = delegate;
+  }
   // Set the profile which contains the extension that has originated this
   // function call.
   void set_profile(Profile* profile) { profile_ = profile; }
   Profile* profile() const { return profile_; }
 
   void SetRenderViewHost(RenderViewHost* render_view_host);
   RenderViewHost* render_view_host() const { return render_view_host_; }
 
   void set_dispatcher(
       const base::WeakPtr<ExtensionFunctionDispatcher>& dispatcher) {
     dispatcher_ = dispatcher;
   }
   ExtensionFunctionDispatcher* dispatcher() const {
     return dispatcher_.get();
   }
 
  protected:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   friend class DeleteTask<UIThreadExtensionFunction>;
 
   virtual ~UIThreadExtensionFunction();
 
-  virtual void SendResponse(bool success);
+  virtual void SendResponse(bool success) OVERRIDE;
 
   // Gets the "current" browser, if any.
   //
   // Many extension APIs operate relative to the current browser, which is the
   // browser the calling code is running inside of. For example, popups, tabs,
   // and infobars all have a containing browser, but background pages and
   // notification bubbles do not.
   //
   // If there is no containing window, the current browser defaults to the
   // foremost one.
@@ skipping 29 matching lines @@
     virtual void Observe(int type,
                          const content::NotificationSource& source,
                          const content::NotificationDetails& details) OVERRIDE;
     UIThreadExtensionFunction* function_;
     content::NotificationRegistrar registrar_;
   };
 
   virtual void Destruct() const;
 
   scoped_ptr<RenderViewHostTracker> tracker_;
+
+  DelegateForTests* delegate_;
 };
 
 // Extension functions that run on the IO thread. This type of function avoids
 // a roundtrip to and from the UI thread (because communication with the
 // extension process happens on the IO thread). It's intended to be used when
 // performance is critical (e.g. the webRequest API which can block network
 // requests). Generally, UIThreadExtensionFunction is more appropriate and will
 // be easier to use and interface with the rest of the browser.
 class IOThreadExtensionFunction : public ExtensionFunction {
  public:
@@ skipping 35 matching lines @@
   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:
-  // A delegate for use in testing, to intercept the call to SendResponse.
-  class DelegateForTests {
-   public:
-    virtual void OnSendResponse(AsyncExtensionFunction* function,
-                                bool success) = 0;
-  };
-
   AsyncExtensionFunction();
-  virtual void SendResponse(bool success) OVERRIDE;
-
-  void set_test_delegate(DelegateForTests* delegate) {
-    delegate_ = delegate;
-  }
 
  protected:
   virtual ~AsyncExtensionFunction();
-
-  DelegateForTests* delegate_;
 };
 
 // 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 {
@@ skipping 10 matching lines @@
  public:
   SyncIOThreadExtensionFunction();
 
   virtual void Run() OVERRIDE;
 
  protected:
   virtual ~SyncIOThreadExtensionFunction();
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_