Remove some usages of AsyncExtensionFunction::results_.

extensions/browser/extension_function.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_
 #define EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_
 
 #include <stddef.h>
 
 #include <list>
@@ skipping 135 matching lines @@
    protected:
     void SetFunctionResults(ExtensionFunction* function,
                             std::unique_ptr<base::ListValue> results);
     void SetFunctionError(ExtensionFunction* function,
                           const std::string& error);
   };
   typedef std::unique_ptr<ResponseValueObject> ResponseValue;
 
   // The action to use when returning from RunAsync.
   //
-  // Use RespondNow() or RespondLater() rather than this class directly.
+  // Use RespondNow() or RespondLater() or AlreadyResponded() rather than this
+  // class directly.
   class ResponseActionObject {
    public:
     virtual ~ResponseActionObject() {}
 
     virtual void Execute() = 0;
   };
   typedef std::unique_ptr<ResponseActionObject> ResponseAction;
 
   // Helper class for tests to force all ExtensionFunction::user_gesture()
   // calls to return true as long as at least one instance of this class
@@ skipping 197 matching lines @@
   // ResponseActions.
   //
   // These are exclusively used as return values from Run(). Call Respond(...)
   // to respond at any other time - but as described below, only after Run()
   // has already executed, and only if it returned RespondLater().
   //
   // Respond to the extension immediately with |result|.
   ResponseAction RespondNow(ResponseValue result) WARN_UNUSED_RESULT;
   // Don't respond now, but promise to call Respond(...) later.
   ResponseAction RespondLater() WARN_UNUSED_RESULT;
+  // Respond() was already called before Run() finished executing.
+  //
+  // Assume Run() uses some helper system that accepts callback that Respond()s.
+  // If that helper system calls the synchronously in some cases, then use
+  // this return value in those cases.
+  //
+  // FooExtensionFunction::Run() {
+  //   Helper::FetchResults(..., base::Bind(&Success));
+  //   if (did_respond()) return AlreadyResponded();
+  //   return RespondLater();
+  // }
+  // FooExtensionFunction::Success() {
+  //   Respond(...);
+  // }
+  //
+  // Helper::FetchResults(..., callback) {
+  //   if (...)
+  //     callback.Run(..);  // Synchronously call |callback|.
+  //   else
+  //     // Asynchronously call |callback|.
+  // }
+  ResponseAction AlreadyResponded() WARN_UNUSED_RESULT;
 
   // This is the return value of the EXTENSION_FUNCTION_VALIDATE macro, which
   // needs to work from Run(), RunAsync(), and RunSync(). The former of those
   // has a different return type (ResponseAction) than the latter two (bool).
   static ResponseAction ValidationFailure(ExtensionFunction* function)
       WARN_UNUSED_RESULT;
 
   // If RespondLater() was returned from Run(), functions must at some point
   // call Respond() with |result| as their result.
   //
@@ skipping 283 matching lines @@
  private:
   // If you're hitting a compile error here due to "final" - great! You're
   // doing the right thing, you just need to extend UIThreadExtensionFunction
   // instead of AsyncExtensionFunction.
   ResponseAction Run() final;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncExtensionFunction);
 };
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_