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

chrome/browser/extensions/extension_function.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/browser/extensions/extension_function.h"
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 110 matching lines @@
     CHECK(false);
   } else {
     NOTREACHED();
     UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_EFD"));
     if (process)
       base::KillProcess(process, content::RESULT_CODE_KILLED_BAD_MESSAGE,
                         false);
   }
 }
 UIThreadExtensionFunction::UIThreadExtensionFunction()
-    : render_view_host_(NULL), profile_(NULL) {
+    : render_view_host_(NULL), profile_(NULL), delegate_(NULL) {
 }
 
 UIThreadExtensionFunction::~UIThreadExtensionFunction() {
 }
 
 UIThreadExtensionFunction*
 UIThreadExtensionFunction::AsUIThreadExtensionFunction() {
   return this;
 }
 
 void UIThreadExtensionFunction::Destruct() const {
   BrowserThread::DeleteOnUIThread::Destruct(this);
 }
 
 void UIThreadExtensionFunction::SetRenderViewHost(
     RenderViewHost* render_view_host) {
   render_view_host_ = render_view_host;
   tracker_.reset(render_view_host ? new RenderViewHostTracker(this) : NULL);
 }
 
 Browser* UIThreadExtensionFunction::GetCurrentBrowser() {
   return dispatcher()->GetCurrentBrowser(render_view_host_, include_incognito_);
 }
 
 void UIThreadExtensionFunction::SendResponse(bool success) {
-  if (!render_view_host_ || !dispatcher())
-    return;
+  if (delegate_) {
+    delegate_->OnSendResponse(this, success);
+  } else {
+    if (!render_view_host_ || !dispatcher())
+      return;
 
-  SendResponseImpl(render_view_host_->process()->GetHandle(),
-                   render_view_host_,
-                   render_view_host_->routing_id(),
-                   success);
+    SendResponseImpl(render_view_host_->process()->GetHandle(),
+                     render_view_host_,
+                     render_view_host_->routing_id(),
+                     success);
+  }
 }
 
 IOThreadExtensionFunction::IOThreadExtensionFunction()
     : routing_id_(-1) {
 }
 
 IOThreadExtensionFunction::~IOThreadExtensionFunction() {
 }
 
 IOThreadExtensionFunction*
 IOThreadExtensionFunction::AsIOThreadExtensionFunction() {
   return this;
 }
 
 void IOThreadExtensionFunction::Destruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 void IOThreadExtensionFunction::SendResponse(bool success) {
   if (!ipc_sender())
     return;
 
   SendResponseImpl(ipc_sender()->peer_handle(),
                    ipc_sender(), routing_id_, success);
 }
 
-AsyncExtensionFunction::AsyncExtensionFunction() : delegate_(NULL) {
-}
-
-void AsyncExtensionFunction::SendResponse(bool success) {
-  if (delegate_)
-    delegate_->OnSendResponse(this, success);
-  else
-    UIThreadExtensionFunction::SendResponse(success);
+AsyncExtensionFunction::AsyncExtensionFunction() {
 }
 
 AsyncExtensionFunction::~AsyncExtensionFunction() {
 }
 
 SyncExtensionFunction::SyncExtensionFunction() {
 }
 
 SyncExtensionFunction::~SyncExtensionFunction() {
 }
 
 void SyncExtensionFunction::Run() {
   SendResponse(RunImpl());
 }
 
 SyncIOThreadExtensionFunction::SyncIOThreadExtensionFunction() {
 }
 
 SyncIOThreadExtensionFunction::~SyncIOThreadExtensionFunction() {
 }
 
 void SyncIOThreadExtensionFunction::Run() {
   SendResponse(RunImpl());
 }