[Extensions] Consolidate ExtensionFunction::SendResponse()s

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 283 matching lines @@
 
 bool ExtensionFunction::HasPermission() {
   Feature::Availability availability =
       ExtensionAPI::GetSharedInstance()->IsAvailable(
           name_, extension_.get(), source_context_type_, source_url());
   return availability.is_available();
 }
 
 void ExtensionFunction::OnQuotaExceeded(const std::string& violation_error) {
   error_ = violation_error;
-  SendResponse(false);
+  SendResponseImpl(false);
 }
 
 void ExtensionFunction::SetArgs(const base::ListValue* args) {
   DCHECK(!args_.get());  // Should only be called once.
   args_ = args->CreateDeepCopy();
 }
 
 void ExtensionFunction::SetResult(std::unique_ptr<base::Value> result) {
   results_.reset(new base::ListValue());
   results_->Append(std::move(result));
@@ skipping 85 matching lines @@
       name(), "ErrorWithArguments", this, std::move(args), error));
 }
 
 ExtensionFunction::ResponseValue ExtensionFunction::BadMessage() {
   return ResponseValue(new BadMessageResponseValue(this));
 }
 
 ExtensionFunction::ResponseAction ExtensionFunction::RespondNow(
     ResponseValue result) {
   return ResponseAction(new RespondNowAction(
-      std::move(result), base::Bind(&ExtensionFunction::SendResponse, this)));
+      std::move(result),
+      base::Bind(&ExtensionFunction::SendResponseImpl, this)));
 }
 
 ExtensionFunction::ResponseAction ExtensionFunction::RespondLater() {
   return ResponseAction(new RespondLaterAction());
 }
 
 // static
 ExtensionFunction::ResponseAction ExtensionFunction::ValidationFailure(
     ExtensionFunction* function) {
   return function->RespondNow(function->BadMessage());
 }
 
 void ExtensionFunction::Respond(ResponseValue result) {
-  SendResponse(result->Apply());
+  SendResponseImpl(result->Apply());
 }
 
 bool ExtensionFunction::PreRunValidation(std::string* error) {
   return true;
 }
 
 ExtensionFunction::ResponseAction ExtensionFunction::RunWithValidation() {
   std::string error;
   if (!PreRunValidation(&error)) {
     DCHECK(!error.empty() || bad_message_);
     return bad_message_ ? ValidationFailure(this) : RespondNow(Error(error));
   }
   return Run();
 }
 
 bool ExtensionFunction::ShouldSkipQuotaLimiting() const {
   return false;
 }
 
 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());
+  DCHECK(!did_respond_) << name_;
+  did_respond_ = true;
 
   ResponseType response = success ? SUCCEEDED : FAILED;
   if (bad_message_) {
     response = BAD_MESSAGE;
     LOG(ERROR) << "Bad extension message " << name_;
   }
   response_type_ = base::MakeUnique<ResponseType>(response);
 
   // If results were never set, we send an empty argument list.
   if (!results_)
     results_.reset(new base::ListValue());
 
   response_callback_.Run(response, *results_, GetError(), histogram_value());
   LogUma(success, timer_.Elapsed(), histogram_value_);
+
+  OnResponded();
 }
 
 void ExtensionFunction::OnRespondingLater(ResponseValue value) {

[lazyboy, 2016/09/20 20:21:33]

Is OnRespondingLater used still? (I can't find any caller to this).

[Devlin, 2016/09/20 21:51:04]

Looks like no - good catch!

-  SendResponse(value->Apply());
+  SendResponseImpl(value->Apply());
 }
 
 UIThreadExtensionFunction::UIThreadExtensionFunction()
     : context_(nullptr),
       render_frame_host_(nullptr),
       is_from_service_worker_(false) {}
 
 UIThreadExtensionFunction::~UIThreadExtensionFunction() {
   if (dispatcher() && render_frame_host())
     dispatcher()->OnExtensionFunctionCompleted(extension());
@@ skipping 62 matching lines @@
     web_contents = dispatcher()->GetAssociatedWebContents();
 
   return web_contents;
 }
 
 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;
-  SendResponseImpl(success);
-
+void UIThreadExtensionFunction::OnResponded() {
   if (!transferred_blob_uuids_.empty()) {
     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 17 matching lines @@
 
 IOThreadExtensionFunction*
 IOThreadExtensionFunction::AsIOThreadExtensionFunction() {
   return this;
 }
 
 void IOThreadExtensionFunction::Destruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
-void IOThreadExtensionFunction::SendResponse(bool success) {
-  DCHECK(!did_respond_) << name_;
-  did_respond_ = true;
-  SendResponseImpl(success);
-}
-
 AsyncExtensionFunction::AsyncExtensionFunction() {
 }
 
 AsyncExtensionFunction::~AsyncExtensionFunction() {
 }
 
 ExtensionFunction::ScopedUserGestureForTests::ScopedUserGestureForTests() {
   UserGestureForTests::GetInstance()->IncrementCount();
 }
 
 ExtensionFunction::ScopedUserGestureForTests::~ScopedUserGestureForTests() {
   UserGestureForTests::GetInstance()->DecrementCount();
 }
 
 ExtensionFunction::ResponseAction AsyncExtensionFunction::Run() {
   return RunAsync() ? RespondLater() : RespondNow(Error(error_));
 }
 
 // static
 bool AsyncExtensionFunction::ValidationFailure(
     AsyncExtensionFunction* function) {
   return false;
 }
+
+void AsyncExtensionFunction::SendResponse(bool success) {
+  Respond(success ? ArgumentList(std::move(results_)) : Error(error_));
+}