Make ERR_ICANN_NAME_COLLISION work for async DNS resolver.

chrome/browser/net/dns_probe_browsertest.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 <memory>
 #include <set>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 301 matching lines @@
   base::Closure delayed_request_destruction_callback_;
 };
 
 class DnsProbeBrowserTestIOThreadHelper {
  public:
   DnsProbeBrowserTestIOThreadHelper();
 
   void SetUpOnIOThread(IOThread* io_thread);
   void CleanUpOnIOThreadAndDeleteHelper();
 
-  void SetMockDnsClientRules(MockDnsClientRule::Result system_good_result,
-                             MockDnsClientRule::Result public_good_result);
+  void SetMockDnsClientRules(MockDnsClientRule::ResultType system_good_result,
+                             MockDnsClientRule::ResultType public_good_result);
   void SetCorrectionServiceNetError(int net_error);
   void SetCorrectionServiceDelayRequests(bool delay_requests);
   void SetRequestDestructionCallback(const base::Closure& callback);
   void StartDelayedProbes(int expected_delayed_probe_count);
 
  private:
   IOThread* io_thread_;
   DnsProbeService* original_dns_probe_service_;
   DelayingDnsProbeService* delaying_dns_probe_service_;
   BreakableCorrectionInterceptor* interceptor_;
@@ skipping 41 matching lines @@
   std::unique_ptr<DnsProbeService> delaying_dns_probe_service(
       globals->dns_probe_service.release());
   globals->dns_probe_service.reset(original_dns_probe_service_);
 
   CHECK_EQ(delaying_dns_probe_service_, delaying_dns_probe_service.get());
 
   delete this;
 }
 
 void DnsProbeBrowserTestIOThreadHelper::SetMockDnsClientRules(
-    MockDnsClientRule::Result system_result,
-    MockDnsClientRule::Result public_result) {
+    MockDnsClientRule::ResultType system_result,
+    MockDnsClientRule::ResultType public_result) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DnsProbeService* service = io_thread_->globals()->dns_probe_service.get();
   service->SetSystemClientForTesting(
       CreateMockDnsClientForProbes(system_result));
   service->SetPublicClientForTesting(
       CreateMockDnsClientForProbes(public_result));
 }
 
 void DnsProbeBrowserTestIOThreadHelper::SetCorrectionServiceNetError(
@@ skipping 39 matching lines @@
   void TearDownOnMainThread() override;
 
  protected:
   // Sets the browser object that other methods apply to, and that has the
   // DnsProbeStatus messages of its currently active tab monitored.
   void SetActiveBrowser(Browser* browser);
 
   void SetCorrectionServiceBroken(bool broken);
   void SetCorrectionServiceDelayRequests(bool delay_requests);
   void WaitForDelayedRequestDestruction();
-  void SetMockDnsClientRules(MockDnsClientRule::Result system_result,
-                             MockDnsClientRule::Result public_result);
+  void SetMockDnsClientRules(MockDnsClientRule::ResultType system_result,
+                             MockDnsClientRule::ResultType public_result);
 
   // These functions are often used to wait for two navigations because two
   // pages are loaded when navigation corrections are enabled: a blank page, so
   // the user stops seeing the previous page, and then the error page, either
   // with navigation corrections or without them (If the request failed).
   void NavigateToDnsError(int num_navigations);
   void NavigateToOtherError(int num_navigations);
 
   void StartDelayedProbes(int expected_delayed_probe_count);
   DnsProbeStatus WaitForSentStatus();
@@ skipping 118 matching lines @@
 }
 
 void DnsProbeBrowserTest::NavigateToOtherError(int num_navigations) {
   NavigateToURLBlockUntilNavigationsComplete(
       active_browser_,
       URLRequestFailedJob::GetMockHttpUrl(net::ERR_CONNECTION_REFUSED),
       num_navigations);
 }
 
 void DnsProbeBrowserTest::SetMockDnsClientRules(
-    MockDnsClientRule::Result system_result,
-    MockDnsClientRule::Result public_result) {
+    MockDnsClientRule::ResultType system_result,
+    MockDnsClientRule::ResultType public_result) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       Bind(&DnsProbeBrowserTestIOThreadHelper::SetMockDnsClientRules,
            Unretained(helper_),
            system_result,
            public_result));
 }
 
 void DnsProbeBrowserTest::StartDelayedProbes(
     int expected_delayed_probe_count) {
@@ skipping 386 matching lines @@
 
   EXPECT_EQ(error_page::DNS_PROBE_FINISHED_INCONCLUSIVE,
             WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
   ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
 }
 
 }  // namespace
 
 }  // namespace chrome_browser_net