[Extensions] Remove UIThreadExtensionFunction::DelegateForTests

extensions/browser/extension_function.cc

 // Copyright 2013 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 "extensions/browser/extension_function.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 431 matching lines @@
 }
 
 bool ExtensionFunction::HasOptionalArgument(size_t index) {
   base::Value* value;
   return args_->Get(index, &value) && !value->IsType(base::Value::TYPE_NULL);
 }
 
 void ExtensionFunction::SendResponseImpl(bool success) {
   DCHECK(!response_callback_.is_null());
 
-  ResponseType type = success ? SUCCEEDED : FAILED;
+  ResponseType response = success ? SUCCEEDED : FAILED;
   if (bad_message_) {
-    type = BAD_MESSAGE;
+    response = BAD_MESSAGE;
     LOG(ERROR) << "Bad extension message " << name_;
   }
+  response_ = base::MakeUnique<ResponseType>(response);

[lazyboy, 2016/09/19 18:08:56]

I'd name this response_type_ (and the getter). Because skimming through the
code, I was reading that this field holds the entire response (i.e. what
|results_| currently holds).

[Devlin, 2016/09/19 20:14:20]

SG, done.

 
   // If results were never set, we send an empty argument list.
   if (!results_)
     results_.reset(new base::ListValue());
 
-  response_callback_.Run(type, *results_, GetError(), histogram_value());
+  response_callback_.Run(response, *results_, GetError(), histogram_value());
   LogUma(success, timer_.Elapsed(), histogram_value_);
 }
 
 void ExtensionFunction::OnRespondingLater(ResponseValue value) {
   SendResponse(value->Apply());
 }
 
 UIThreadExtensionFunction::UIThreadExtensionFunction()
     : context_(nullptr),
       render_frame_host_(nullptr),
-      is_from_service_worker_(false),
-      delegate_(nullptr) {}
+      is_from_service_worker_(false) {}
 
 UIThreadExtensionFunction::~UIThreadExtensionFunction() {
   if (dispatcher() && render_frame_host())
     dispatcher()->OnExtensionFunctionCompleted(extension());
   // The extension function should always respond to avoid leaks in the
   // renderer, dangling callbacks, etc. The exception is if the system is
   // shutting down.
   // TODO(devlin): Duplicate this check in IOThreadExtensionFunction. It's
   // tricky because checking IsShuttingDown has to be called from the UI thread.
   extensions::ExtensionsBrowserClient* browser_client =
@@ skipping 59 matching lines @@
 }
 
 content::WebContents* UIThreadExtensionFunction::GetSenderWebContents() {
   return render_frame_host_ ?
       content::WebContents::FromRenderFrameHost(render_frame_host_) : nullptr;
 }
 
 void UIThreadExtensionFunction::SendResponse(bool success) {
   DCHECK(!did_respond_) << name_;
   did_respond_ = true;
-  if (delegate_)
-    delegate_->OnSendResponse(this, success, bad_message_);
-  else
-    SendResponseImpl(success);
+  SendResponseImpl(success);
 
   if (!transferred_blob_uuids_.empty()) {
-    DCHECK(!delegate_) << "Blob transfer not supported with test delegate.";
     render_frame_host_->Send(
         new ExtensionMsg_TransferBlobs(transferred_blob_uuids_));
   }
 }
 
 void UIThreadExtensionFunction::SetTransferredBlobUUIDs(
     const std::vector<std::string>& blob_uuids) {
   DCHECK(transferred_blob_uuids_.empty());  // Should only be called once.
   transferred_blob_uuids_ = blob_uuids;
 }
@@ skipping 45 matching lines @@
 
 ExtensionFunction::ResponseAction AsyncExtensionFunction::Run() {
   return RunAsync() ? RespondLater() : RespondNow(Error(error_));
 }
 
 // static
 bool AsyncExtensionFunction::ValidationFailure(
     AsyncExtensionFunction* function) {
   return false;
 }