[Extensions] DCHECK that ExtensionFunctions respond (and only once)

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 47 matching lines @@
   do {                                    \
     if (!(test)) {                        \
       this->bad_message_ = true;          \
       return ValidationFailure(this);     \
     }                                     \
   } while (0)
 #else   // NDEBUG
 #define EXTENSION_FUNCTION_VALIDATE(test) CHECK(test)
 #endif  // NDEBUG
 
+#ifdef NDEBUG
+#define EXTENSION_FUNCTION_PRERUN_VALIDATE(test) \
+  do {                                           \
+    if (!(test)) {                               \
+      this->bad_message_ = true;                 \
+      return false;                              \
+    }                                            \
+  } while (0)
+#else  // NDEBUG
+#define EXTENSION_FUNCTION_PRERUN_VALIDATE(test) CHECK(test)
+#endif  // NDEBUG
+
 #define EXTENSION_FUNCTION_ERROR(error) \
   do {                                  \
     error_ = error;                     \
     this->bad_message_ = true;          \
     return ValidationFailure(this);     \
   } while (0)
 
 // Declares a callable extension function with the given |name|. You must also
 // supply a unique |histogramvalue| used for histograms of extension function
 // invocation (add new ones at the end of the enum in
@@ skipping 72 matching lines @@
 
   // Helper class for tests to force all ExtensionFunction::user_gesture()
   // calls to return true as long as at least one instance of this class
   // exists.
   class ScopedUserGestureForTests {
    public:
     ScopedUserGestureForTests();
     ~ScopedUserGestureForTests();
   };
 
+  // Called before Run() in order to perform a common verification check so that
+  // APIs subclassing this don't have to roll their own RunSafe() variants.
+  // If this returns false, then Run() is never called, and the function
+  // responds immediately with an error (note that error must be non-empty in
+  // this case). If this returns true, execution continues on to Run().
+  virtual bool PreRunValidation(std::string* error);
+
+  // Runs the extension function if PreRunValidation() succeeds.
+  ResponseAction RunWithValidation();
+
   // Runs the function and returns the action to take when the caller is ready
   // to respond.
   //
   // Typical return values might be:
   //   * RespondNow(NoArguments())
   //   * RespondNow(OneArgument(42))
   //   * RespondNow(ArgumentList(my_result.ToValue()))
   //   * RespondNow(Error("Warp core breach"))
   //   * RespondNow(Error("Warp core breach on *", GetURL()))
   //   * RespondLater(), then later,
@@ skipping 111 matching lines @@
     return source_context_type_;
   }
 
   void set_source_process_id(int source_process_id) {
     source_process_id_ = source_process_id;
   }
   int source_process_id() const {
     return source_process_id_;
   }
 
+  // Sets did_respond_ to true so that the function won't DCHECK if it never
+  // sends a response. Typically, this shouldn't be used, even in testing. It's
+  // only for when you want to test functionality that doesn't exercise the
+  // Run() aspect of an extension function.
+  void ignore_did_respond_for_testing() { did_respond_ = true; }
+  // Same as above, but global. Yuck. Do not add any more uses of this.
+  static bool ignore_all_did_respond_for_testing_do_not_use;
+
  protected:
   friend struct ExtensionFunctionDeleteTraits;
 
   // ResponseValues.
   //
   // Success, no arguments to pass to caller.
   ResponseValue NoArguments();
   // Success, a single argument |arg| to pass to caller. TAKES OWNERSHIP - a
   // raw pointer for convenience, since callers usually construct the argument
   // to this by hand.
@@ skipping 131 matching lines @@
   // The ID of the tab triggered this function call, or -1 if there is no tab.
   int source_tab_id_;
 
   // The type of the JavaScript context where this call originated.
   extensions::Feature::Context source_context_type_;
 
   // The process ID of the page that triggered this function call, or -1
   // if unknown.
   int source_process_id_;
 
+  // Whether this function has responded.
+  bool did_respond_;
+
  private:
   base::ElapsedTimer timer_;
 
   void OnRespondingLater(ResponseValue response);
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionFunction);
 };
 
 // Extension functions that run on the UI thread. Most functions fall into
 // this category.
@@ skipping 230 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 IOThreadExtensionFunction
   // instead of SyncIOExtensionFunction.
   ResponseAction Run() final;
 
   DISALLOW_COPY_AND_ASSIGN(SyncIOThreadExtensionFunction);
 };
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_