[Extensions] Remove UIThreadExtensionFunction::DelegateForTests

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 297 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_;
   }
 
+  ResponseType* response() const { return response_.get(); }
+
   // 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;
@@ skipping 140 matching lines @@
   // 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_;
 
+  // The response of the function, if one has been set.

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

The response type of the function, if response has been set.

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

Done.

+  std::unique_ptr<ResponseType> response_;
+
   void OnRespondingLater(ResponseValue response);
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionFunction);
 };
 
 // Extension functions that run on the UI thread. Most functions fall into
 // this category.
 class UIThreadExtensionFunction : public ExtensionFunction {
  public:
-  // TODO(yzshen): We should be able to remove this interface now that we
-  // support overriding the response callback.
-  // A delegate for use in testing, to intercept the call to SendResponse.
-  class DelegateForTests {
-   public:
-    virtual void OnSendResponse(UIThreadExtensionFunction* function,
-                                bool success,
-                                bool bad_message) = 0;
-  };
-
   UIThreadExtensionFunction();
 
   UIThreadExtensionFunction* AsUIThreadExtensionFunction() override;
 
   bool PreRunValidation(std::string* error) override;
 
-  void set_test_delegate(DelegateForTests* delegate) {
-    delegate_ = delegate;
-  }
-
   // Called when a message was received.
   // Should return true if it processed the message.
   virtual bool OnMessageReceived(const IPC::Message& message);
 
   // Set the browser context which contains the extension that has originated
   // this function call.
   void set_browser_context(content::BrowserContext* context) {
     context_ = context;
   }
   content::BrowserContext* browser_context() const { return context_; }
@@ skipping 55 matching lines @@
 
   // The RenderFrameHost we will send responses to.
   content::RenderFrameHost* render_frame_host_;
 
   // Whether or not this ExtensionFunction was called by an extension Service
   // Worker.
   bool is_from_service_worker_;
 
   std::unique_ptr<RenderFrameHostTracker> tracker_;
 
-  DelegateForTests* delegate_;
-
   // The blobs transferred to the renderer process.
   std::vector<std::string> transferred_blob_uuids_;
 
   DISALLOW_COPY_AND_ASSIGN(UIThreadExtensionFunction);
 };
 
 // Extension functions that run on the IO thread. This type of function avoids
 // a roundtrip to and from the UI thread (because communication with the
 // extension process happens on the IO thread). It's intended to be used when
 // performance is critical (e.g. the webRequest API which can block network
@@ skipping 68 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_