[Extensions] Remove UIThreadExtensionFunction::DelegateForTests

chrome/browser/extensions/api/identity/identity_apitest.cc

 // Copyright (c) 2012 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 <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 60 matching lines @@
 namespace extensions {
 
 namespace {
 
 namespace errors = identity_constants;
 namespace utils = extension_function_test_utils;
 
 static const char kAccessToken[] = "auth_token";
 static const char kExtensionId[] = "ext_id";
 
-// This helps us be able to wait until an UIThreadExtensionFunction calls
-// SendResponse.
-class SendResponseDelegate
-    : public UIThreadExtensionFunction::DelegateForTests {
- public:
-  SendResponseDelegate() : should_post_quit_(false) {}
-
-  virtual ~SendResponseDelegate() {}
-
-  void set_should_post_quit(bool should_quit) {
-    should_post_quit_ = should_quit;
-  }
-
-  bool HasResponse() {
-    return response_.get() != NULL;
-  }
-
-  bool GetResponse() {
-    EXPECT_TRUE(HasResponse());
-    return *response_;
-  }
-
-  void OnSendResponse(UIThreadExtensionFunction* function,
-                      bool success,
-                      bool bad_message) override {
-    ASSERT_FALSE(bad_message);
-    ASSERT_FALSE(HasResponse());
-    response_.reset(new bool);
-    *response_ = success;
-    if (should_post_quit_) {
-      base::MessageLoopForUI::current()->QuitWhenIdle();
-    }
-  }
-
- private:
-  std::unique_ptr<bool> response_;
-  bool should_post_quit_;
-};
-
 class AsyncExtensionBrowserTest : public ExtensionBrowserTest {
  protected:
   // Asynchronous function runner allows tests to manipulate the browser window
   // after the call happens.
   void RunFunctionAsync(
       UIThreadExtensionFunction* function,
       const std::string& args) {
-    response_delegate_.reset(new SendResponseDelegate);
-    function->set_test_delegate(response_delegate_.get());
+    response_delegate_.reset(new api_test_utils::SendResponseHelper(function));
     std::unique_ptr<base::ListValue> parsed_args(utils::ParseList(args));
     EXPECT_TRUE(parsed_args.get()) <<
         "Could not parse extension function arguments: " << args;
     function->SetArgs(parsed_args.get());
 
     if (!function->extension()) {
       scoped_refptr<Extension> empty_extension(
           test_util::CreateEmptyExtension());
       function->set_extension(empty_extension.get());
     }
 
     function->set_browser_context(browser()->profile());
     function->set_has_callback(true);
     function->RunWithValidation()->Execute();
   }
 
   std::string WaitForError(UIThreadExtensionFunction* function) {
     RunMessageLoopUntilResponse();
-    EXPECT_FALSE(function->GetResultList()) << "Did not expect a result";
+    CHECK(function->response_type());
+    EXPECT_EQ(ExtensionFunction::FAILED, *function->response_type());
     return function->GetError();
   }
 
   base::Value* WaitForSingleResult(UIThreadExtensionFunction* function) {
     RunMessageLoopUntilResponse();
     EXPECT_TRUE(function->GetError().empty()) << "Unexpected error: "
                                               << function->GetError();
     const base::Value* single_result = NULL;
     if (function->GetResultList() != NULL &&
         function->GetResultList()->Get(0, &single_result)) {
       return single_result->DeepCopy();
     }
     return NULL;
   }
 
  private:
   void RunMessageLoopUntilResponse() {
-    // If the RunAsync of |function| didn't already call SendResponse, run the
-    // message loop until they do.
-    if (!response_delegate_->HasResponse()) {
-      response_delegate_->set_should_post_quit(true);
-      content::RunMessageLoop();
-    }
-    EXPECT_TRUE(response_delegate_->HasResponse());
+    response_delegate_->WaitForResponse();
+    EXPECT_TRUE(response_delegate_->has_response());
   }
 
-  std::unique_ptr<SendResponseDelegate> response_delegate_;
+  std::unique_ptr<api_test_utils::SendResponseHelper> response_delegate_;
 };
 
 class TestHangOAuth2MintTokenFlow : public OAuth2MintTokenFlow {
  public:
   TestHangOAuth2MintTokenFlow()
       : OAuth2MintTokenFlow(NULL, OAuth2MintTokenFlow::Parameters()) {}
 
   void Start(net::URLRequestContextGetter* context,
              const std::string& access_token) override {
     // Do nothing, simulating a hanging network call.
@@ skipping 1713 matching lines @@
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 }  // namespace extensions
 
 // Tests the chrome.identity API implemented by custom JS bindings .
 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ChromeIdentityJsBindings) {
   ASSERT_TRUE(RunExtensionTest("identity/js_bindings")) << message_;
 }