Remove some usages of AsyncExtensionFunction::results_.

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 135 matching lines @@
   SendResponseCallback send_response_;
 };
 
 class RespondLaterAction : public ExtensionFunction::ResponseActionObject {
  public:
   ~RespondLaterAction() override {}
 
   void Execute() override {}
 };
 
+class AlreadyRespondedAction : public ExtensionFunction::ResponseActionObject {
+ public:
+  using DidRespondCallback = base::Callback<bool(void)>;
+  AlreadyRespondedAction(const DidRespondCallback& did_respond)
+      : did_respond_(did_respond) {}
+  ~AlreadyRespondedAction() override {}
+
+  void Execute() override {
+    DCHECK(did_respond_.Run()) << "ExtensionFunction did not call Respond(),"
+                                  " but Run() returned AlreadyResponded()";
+  }
+
+ private:
+  DidRespondCallback did_respond_;
+};
+
 // Used in implementation of ScopedUserGestureForTests.
 class UserGestureForTests {
  public:
   static UserGestureForTests* GetInstance();
 
   // Returns true if there is at least one ScopedUserGestureForTests object
   // alive.
   bool HaveGesture();
 
   // These should be called when a ScopedUserGestureForTests object is
@@ skipping 220 matching lines @@
     ResponseValue result) {
   return ResponseAction(new RespondNowAction(
       std::move(result),
       base::Bind(&ExtensionFunction::SendResponseImpl, this)));
 }
 
 ExtensionFunction::ResponseAction ExtensionFunction::RespondLater() {
   return ResponseAction(new RespondLaterAction());
 }
 
+ExtensionFunction::ResponseAction ExtensionFunction::AlreadyResponded() {
+  return ResponseAction(new AlreadyRespondedAction(
+      base::Bind(&ExtensionFunction::did_respond, this)));

[Devlin, 2017/01/20 00:16:02]

Why not just DCHECK() here instead, and have Execute() do nothing?

[lazyboy, 2017/01/20 00:54:47]

Right, thanks.
Done.

+}
+
 // static
 ExtensionFunction::ResponseAction ExtensionFunction::ValidationFailure(
     ExtensionFunction* function) {
   return function->RespondNow(function->BadMessage());
 }
 
 void ExtensionFunction::Respond(ResponseValue result) {
   SendResponseImpl(result->Apply());
 }
 
@@ skipping 210 matching lines @@
 void AsyncExtensionFunction::SendResponse(bool success) {
   ResponseValue response;
   if (success) {
     response = ArgumentList(std::move(results_));
   } else {
     response = results_ ? ErrorWithArguments(std::move(results_), error_)
                         : Error(error_);
   }
   Respond(std::move(response));
 }