src/chrome/browser/net/dns_probe_browsertest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <set>
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/path_service.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "base/run_loop.h"
  13 #include "base/threading/thread_restrictions.h"
  14 #include "chrome/browser/browser_process.h"
  15 #include "chrome/browser/io_thread.h"
  16 #include "chrome/browser/net/dns_probe_test_util.h"
  17 #include "chrome/browser/net/net_error_tab_helper.h"
  18 #include "chrome/browser/net/url_request_mock_util.h"
  19 #include "chrome/browser/profiles/profile.h"
  20 #include "chrome/browser/ui/browser.h"
  21 #include "chrome/browser/ui/browser_commands.h"
  22 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  23 #include "chrome/common/chrome_paths.h"
  24 #include "chrome/common/net/net_error_info.h"
  25 #include "chrome/common/pref_names.h"
  26 #include "chrome/test/base/in_process_browser_test.h"
  27 #include "chrome/test/base/ui_test_utils.h"
  28 #include "components/google/core/browser/google_util.h"
  29 #include "content/public/browser/browser_thread.h"
  30 #include "content/public/browser/web_contents.h"
  31 #include "content/public/test/browser_test_utils.h"
  32 #include "content/public/test/test_navigation_observer.h"
  33 #include "net/base/net_errors.h"
  34 #include "net/dns/dns_test_util.h"
  35 #include "net/test/url_request/url_request_failed_job.h"
  36 #include "net/test/url_request/url_request_mock_http_job.h"
  37 #include "net/url_request/url_request_filter.h"
  38 #include "net/url_request/url_request_interceptor.h"
  39 #include "net/url_request/url_request_job.h"
  40
  41 using base::Bind;
  42 using base::Callback;
  43 using base::Closure;
  44 using base::ConstRef;
  45 using base::FilePath;
  46 using base::MessageLoop;
  47 using base::Unretained;
  48 using chrome_common_net::DnsProbeStatus;
  49 using content::BrowserThread;
  50 using net::URLRequestFailedJob;
  51 using net::URLRequestMockHTTPJob;
  52 using content::WebContents;
  53 using google_util::LinkDoctorBaseURL;
  54 using net::MockDnsClientRule;
  55 using net::NetworkDelegate;
  56 using net::URLRequest;
  57 using net::URLRequestFilter;
  58 using net::URLRequestInterceptor;
  59 using net::URLRequestJob;
  60 using ui_test_utils::NavigateToURL;
  61 using ui_test_utils::NavigateToURLBlockUntilNavigationsComplete;
  62
  63 namespace chrome_browser_net {
  64
  65 namespace {
  66
  67 // Postable function to run a Closure on the UI thread.  Since
  68 // BrowserThread::PostTask returns a bool, it can't directly be posted to
  69 // another thread.
  70 void RunClosureOnUIThread(const base::Closure& closure) {
  71   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, closure);
  72 }
  73
  74 // Wraps DnsProbeService and delays callbacks until someone calls
  75 // CallDelayedCallbacks.  This allows the DnsProbeBrowserTest to enforce a
  76 // stricter ordering of events.
  77 class DelayingDnsProbeService : public DnsProbeService {
  78  public:
  79   DelayingDnsProbeService() {}
  80
  81   virtual ~DelayingDnsProbeService() {
  82     EXPECT_TRUE(delayed_probes_.empty());
  83   }
  84
  85   virtual void ProbeDns(const ProbeCallback& callback) OVERRIDE {
  86     delayed_probes_.push_back(callback);
  87   }
  88
  89   void StartDelayedProbes() {
  90     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  91
  92     std::vector<ProbeCallback> probes;
  93     probes.swap(delayed_probes_);
  94
  95     for (std::vector<ProbeCallback>::const_iterator i = probes.begin();
  96          i != probes.end(); ++i) {
  97       DnsProbeService::ProbeDns(*i);
  98     }
  99   }
 100
 101   int delayed_probe_count() const {
 102     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 103     return delayed_probes_.size();
 104   }
 105
 106  private:
 107   std::vector<ProbeCallback> delayed_probes_;
 108 };
 109
 110 FilePath GetMockLinkDoctorFilePath() {
 111   FilePath root_http;
 112   PathService::Get(chrome::DIR_TEST_DATA, &root_http);
 113   return root_http.AppendASCII("mock-link-doctor.json");
 114 }
 115
 116 // A request that can be delayed until Resume() is called.  Can also run a
 117 // callback if destroyed without being resumed.  Resume can be called either
 118 // before or after a the request is started.
 119 class DelayableRequest {
 120  public:
 121   // Called by a DelayableRequest if it was set to be delayed, and has been
 122   // destroyed without Undelay being called.
 123   typedef base::Callback<void(DelayableRequest* request)> DestructionCallback;
 124
 125   virtual void Resume() = 0;
 126
 127  protected:
 128   virtual ~DelayableRequest() {}
 129 };
 130
 131 class DelayableURLRequestFailedJob : public URLRequestFailedJob,
 132                                      public DelayableRequest {
 133  public:
 134   // |destruction_callback| is only called if a delayed request is destroyed
 135   // without being resumed.
 136   DelayableURLRequestFailedJob(net::URLRequest* request,
 137                                net::NetworkDelegate* network_delegate,
 138                                int net_error,
 139                                bool should_delay,
 140                                const DestructionCallback& destruction_callback)
 141       : URLRequestFailedJob(request, network_delegate, net_error),
 142         should_delay_(should_delay),
 143         start_delayed_(false),
 144         destruction_callback_(destruction_callback) {}
 145
 146   virtual void Start() OVERRIDE {
 147     if (should_delay_) {
 148       DCHECK(!start_delayed_);
 149       start_delayed_ = true;
 150       return;
 151     }
 152     URLRequestFailedJob::Start();
 153   }
 154
 155   virtual void Resume() OVERRIDE {
 156     DCHECK(should_delay_);
 157     should_delay_ = false;
 158     if (start_delayed_) {
 159       start_delayed_ = false;
 160       Start();
 161     }
 162   }
 163
 164  private:
 165   virtual ~DelayableURLRequestFailedJob() {
 166     if (should_delay_)
 167       destruction_callback_.Run(this);
 168   }
 169
 170   bool should_delay_;
 171   bool start_delayed_;
 172   const DestructionCallback destruction_callback_;
 173 };
 174
 175 class DelayableURLRequestMockHTTPJob : public URLRequestMockHTTPJob,
 176                                        public DelayableRequest {
 177  public:
 178   DelayableURLRequestMockHTTPJob(
 179       net::URLRequest* request,
 180       net::NetworkDelegate* network_delegate,
 181       const base::FilePath& file_path,
 182       bool should_delay,
 183       const DestructionCallback& destruction_callback)
 184       : URLRequestMockHTTPJob(
 185             request,
 186             network_delegate,
 187             file_path,
 188             BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
 189                 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
 190         should_delay_(should_delay),
 191         start_delayed_(false),
 192         destruction_callback_(destruction_callback) {}
 193
 194   virtual void Start() OVERRIDE {
 195     if (should_delay_) {
 196       DCHECK(!start_delayed_);
 197       start_delayed_ = true;
 198       return;
 199     }
 200     URLRequestMockHTTPJob::Start();
 201   }
 202
 203   virtual void Resume() OVERRIDE {
 204     DCHECK(should_delay_);
 205     should_delay_ = false;
 206     if (start_delayed_) {
 207       start_delayed_ = false;
 208       Start();
 209     }
 210   }
 211
 212  private:
 213   virtual ~DelayableURLRequestMockHTTPJob() {
 214     if (should_delay_)
 215       destruction_callback_.Run(this);
 216   }
 217
 218   bool should_delay_;
 219   bool start_delayed_;
 220   const DestructionCallback destruction_callback_;
 221 };
 222
 223 // Interceptor for navigation correction requests.  Can cause requests to
 224 // fail with an error, and/or delay a request until a test allows to continue.
 225 // Also can run a callback when a delayed request is cancelled.
 226 class BreakableCorrectionInterceptor : public URLRequestInterceptor {
 227  public:
 228   explicit BreakableCorrectionInterceptor(
 229       const FilePath& mock_corrections_file_path)
 230       : mock_corrections_file_path_(mock_corrections_file_path),
 231         net_error_(net::OK),
 232         delay_requests_(false),
 233         on_request_destroyed_callback_(
 234             base::Bind(&BreakableCorrectionInterceptor::OnRequestDestroyed,
 235                        base::Unretained(this))) {
 236   }
 237
 238   virtual ~BreakableCorrectionInterceptor() {
 239     // All delayed requests should have been resumed or cancelled by this point.
 240     EXPECT_TRUE(delayed_requests_.empty());
 241   }
 242
 243   virtual URLRequestJob* MaybeInterceptRequest(
 244       URLRequest* request,
 245       NetworkDelegate* network_delegate) const OVERRIDE {
 246     if (net_error_ != net::OK) {
 247       DelayableURLRequestFailedJob* job =
 248           new DelayableURLRequestFailedJob(
 249               request, network_delegate, net_error_, delay_requests_,
 250               on_request_destroyed_callback_);
 251       if (delay_requests_)
 252         delayed_requests_.insert(job);
 253       return job;
 254     } else {
 255       DelayableURLRequestMockHTTPJob* job =
 256           new DelayableURLRequestMockHTTPJob(
 257               request, network_delegate, mock_corrections_file_path_,
 258               delay_requests_, on_request_destroyed_callback_);
 259       if (delay_requests_)
 260         delayed_requests_.insert(job);
 261       return job;
 262     }
 263   }
 264
 265   void set_net_error(int net_error) { net_error_ = net_error; }
 266
 267   void SetDelayRequests(bool delay_requests) {
 268     delay_requests_ = delay_requests;
 269
 270     // Resume all delayed requests if no longer delaying requests.
 271     if (!delay_requests) {
 272       while (!delayed_requests_.empty()) {
 273         DelayableRequest* request = *delayed_requests_.begin();
 274         delayed_requests_.erase(request);
 275         request->Resume();
 276       }
 277     }
 278   }
 279
 280   // Runs |callback| once all delayed requests have been destroyed.  Does not
 281   // wait for delayed requests that have been resumed.
 282   void SetRequestDestructionCallback(const base::Closure& callback) {
 283     ASSERT_TRUE(delayed_request_destruction_callback_.is_null());
 284     if (delayed_requests_.empty()) {
 285       callback.Run();
 286       return;
 287     }
 288     delayed_request_destruction_callback_ = callback;
 289   }
 290
 291   void OnRequestDestroyed(DelayableRequest* request) {
 292     ASSERT_EQ(1u, delayed_requests_.count(request));
 293     delayed_requests_.erase(request);
 294     if (delayed_requests_.empty() &&
 295         !delayed_request_destruction_callback_.is_null()) {
 296       delayed_request_destruction_callback_.Run();
 297       delayed_request_destruction_callback_.Reset();
 298     }
 299   }
 300
 301  private:
 302   const FilePath mock_corrections_file_path_;
 303   int net_error_;
 304   bool delay_requests_;
 305
 306   // Called when a request is destroyed.  Memeber variable because
 307   // MaybeCreateJob is "const", so calling base::Bind in that function does
 308   // not work well.
 309   const DelayableRequest::DestructionCallback on_request_destroyed_callback_;
 310
 311   // Mutable is needed because MaybeCreateJob is const.
 312   mutable std::set<DelayableRequest*> delayed_requests_;
 313
 314   base::Closure delayed_request_destruction_callback_;
 315 };
 316
 317 class DnsProbeBrowserTestIOThreadHelper {
 318  public:
 319   DnsProbeBrowserTestIOThreadHelper();
 320
 321   void SetUpOnIOThread(IOThread* io_thread);
 322   void CleanUpOnIOThreadAndDeleteHelper();
 323
 324   void SetMockDnsClientRules(MockDnsClientRule::Result system_good_result,
 325                              MockDnsClientRule::Result public_good_result);
 326   void SetCorrectionServiceNetError(int net_error);
 327   void SetCorrectionServiceDelayRequests(bool delay_requests);
 328   void SetRequestDestructionCallback(const base::Closure& callback);
 329   void StartDelayedProbes(int expected_delayed_probe_count);
 330
 331  private:
 332   IOThread* io_thread_;
 333   DnsProbeService* original_dns_probe_service_;
 334   DelayingDnsProbeService* delaying_dns_probe_service_;
 335   BreakableCorrectionInterceptor* interceptor_;
 336   FilePath mock_corrections_file_path_;
 337 };
 338
 339 DnsProbeBrowserTestIOThreadHelper::DnsProbeBrowserTestIOThreadHelper()
 340     : io_thread_(NULL),
 341       original_dns_probe_service_(NULL),
 342       delaying_dns_probe_service_(NULL),
 343       interceptor_(NULL),
 344       mock_corrections_file_path_(GetMockLinkDoctorFilePath()) {}
 345
 346 void DnsProbeBrowserTestIOThreadHelper::SetUpOnIOThread(IOThread* io_thread) {
 347   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 348   CHECK(io_thread);
 349   CHECK(!io_thread_);
 350   CHECK(!original_dns_probe_service_);
 351   CHECK(!delaying_dns_probe_service_);
 352   CHECK(!interceptor_);
 353
 354   io_thread_ = io_thread;
 355
 356   delaying_dns_probe_service_ = new DelayingDnsProbeService();
 357
 358   IOThread::Globals* globals = io_thread_->globals();
 359   original_dns_probe_service_ = globals->dns_probe_service.release();
 360   globals->dns_probe_service.reset(delaying_dns_probe_service_);
 361
 362   URLRequestFailedJob::AddUrlHandler();
 363
 364   interceptor_ =
 365       new BreakableCorrectionInterceptor(mock_corrections_file_path_);
 366   URLRequestFilter::GetInstance()->AddUrlInterceptor(
 367       LinkDoctorBaseURL(), scoped_ptr<URLRequestInterceptor>(interceptor_));
 368 }
 369
 370 void DnsProbeBrowserTestIOThreadHelper::CleanUpOnIOThreadAndDeleteHelper() {
 371   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 372
 373   URLRequestFilter::GetInstance()->ClearHandlers();
 374
 375   IOThread::Globals* globals = io_thread_->globals();
 376   scoped_ptr<DnsProbeService> delaying_dns_probe_service(
 377       globals->dns_probe_service.release());
 378   globals->dns_probe_service.reset(original_dns_probe_service_);
 379
 380   CHECK_EQ(delaying_dns_probe_service_, delaying_dns_probe_service.get());
 381
 382   delete this;
 383 }
 384
 385 void DnsProbeBrowserTestIOThreadHelper::SetMockDnsClientRules(
 386     MockDnsClientRule::Result system_result,
 387     MockDnsClientRule::Result public_result) {
 388   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 389
 390   DnsProbeService* service = io_thread_->globals()->dns_probe_service.get();
 391   service->SetSystemClientForTesting(
 392       CreateMockDnsClientForProbes(system_result));
 393   service->SetPublicClientForTesting(
 394       CreateMockDnsClientForProbes(public_result));
 395 }
 396
 397 void DnsProbeBrowserTestIOThreadHelper::SetCorrectionServiceNetError(
 398     int net_error) {
 399   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 400
 401   interceptor_->set_net_error(net_error);
 402 }
 403
 404 void DnsProbeBrowserTestIOThreadHelper::SetCorrectionServiceDelayRequests(
 405     bool delay_requests) {
 406   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 407
 408   interceptor_->SetDelayRequests(delay_requests);
 409 }
 410
 411 void DnsProbeBrowserTestIOThreadHelper::SetRequestDestructionCallback(
 412     const base::Closure& callback) {
 413   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 414
 415   interceptor_->SetRequestDestructionCallback(callback);
 416 }
 417
 418 void DnsProbeBrowserTestIOThreadHelper::StartDelayedProbes(
 419     int expected_delayed_probe_count) {
 420   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 421
 422   CHECK(delaying_dns_probe_service_);
 423
 424   int actual_delayed_probe_count =
 425       delaying_dns_probe_service_->delayed_probe_count();
 426   EXPECT_EQ(expected_delayed_probe_count, actual_delayed_probe_count);
 427
 428   delaying_dns_probe_service_->StartDelayedProbes();
 429 }
 430
 431 class DnsProbeBrowserTest : public InProcessBrowserTest {
 432  public:
 433   DnsProbeBrowserTest();
 434   virtual ~DnsProbeBrowserTest();
 435
 436   virtual void SetUpOnMainThread() OVERRIDE;
 437   virtual void TearDownOnMainThread() OVERRIDE;
 438
 439  protected:
 440   // Sets the browser object that other methods apply to, and that has the
 441   // DnsProbeStatus messages of its currently active tab monitored.
 442   void SetActiveBrowser(Browser* browser);
 443
 444   void SetCorrectionServiceBroken(bool broken);
 445   void SetCorrectionServiceDelayRequests(bool delay_requests);
 446   void WaitForDelayedRequestDestruction();
 447   void SetMockDnsClientRules(MockDnsClientRule::Result system_result,
 448                              MockDnsClientRule::Result public_result);
 449
 450   // These functions are often used to wait for two navigations because two
 451   // pages are loaded when navigation corrections are enabled: a blank page, so
 452   // the user stops seeing the previous page, and then the error page, either
 453   // with navigation corrections or without them (If the request failed).
 454   void NavigateToDnsError(int num_navigations);
 455   void NavigateToOtherError(int num_navigations);
 456
 457   void StartDelayedProbes(int expected_delayed_probe_count);
 458   DnsProbeStatus WaitForSentStatus();
 459   int pending_status_count() const { return dns_probe_status_queue_.size(); }
 460
 461   std::string Title();
 462   bool PageContains(const std::string& expected);
 463
 464   // Checks that the local error page is being displayed, without navigation
 465   // corrections, and with the specified status text.  The status text should be
 466   // either a network error or DNS probe status.
 467   void ExpectDisplayingLocalErrorPage(const std::string& status_text);
 468
 469   // Checks that an error page with mock navigation corrections is being
 470   // displayed, with the specified status text. The status text should be either
 471   // a network error or DNS probe status.
 472   void ExpectDisplayingCorrections(const std::string& status_text);
 473
 474  private:
 475   void OnDnsProbeStatusSent(DnsProbeStatus dns_probe_status);
 476
 477   DnsProbeBrowserTestIOThreadHelper* helper_;
 478
 479   // Browser that methods apply to.
 480   Browser* active_browser_;
 481   // Helper that current has its DnsProbeStatus messages monitored.
 482   NetErrorTabHelper* monitored_tab_helper_;
 483
 484   bool awaiting_dns_probe_status_;
 485   // Queue of statuses received but not yet consumed by WaitForSentStatus().
 486   std::list<DnsProbeStatus> dns_probe_status_queue_;
 487 };
 488
 489 DnsProbeBrowserTest::DnsProbeBrowserTest()
 490     : helper_(new DnsProbeBrowserTestIOThreadHelper()),
 491       active_browser_(NULL),
 492       monitored_tab_helper_(NULL),
 493       awaiting_dns_probe_status_(false) {
 494 }
 495
 496 DnsProbeBrowserTest::~DnsProbeBrowserTest() {
 497   // No tests should have any unconsumed probe statuses.
 498   EXPECT_EQ(0, pending_status_count());
 499 }
 500
 501 void DnsProbeBrowserTest::SetUpOnMainThread() {
 502   NetErrorTabHelper::set_state_for_testing(
 503       NetErrorTabHelper::TESTING_DEFAULT);
 504
 505   browser()->profile()->GetPrefs()->SetBoolean(
 506       prefs::kAlternateErrorPagesEnabled, true);
 507
 508   BrowserThread::PostTask(
 509       BrowserThread::IO, FROM_HERE,
 510       Bind(&DnsProbeBrowserTestIOThreadHelper::SetUpOnIOThread,
 511            Unretained(helper_),
 512            g_browser_process->io_thread()));
 513
 514   SetActiveBrowser(browser());
 515 }
 516
 517 void DnsProbeBrowserTest::TearDownOnMainThread() {
 518   BrowserThread::PostTask(
 519       BrowserThread::IO, FROM_HERE,
 520       Bind(&DnsProbeBrowserTestIOThreadHelper::CleanUpOnIOThreadAndDeleteHelper,
 521            Unretained(helper_)));
 522
 523   NetErrorTabHelper::set_state_for_testing(
 524       NetErrorTabHelper::TESTING_DEFAULT);
 525 }
 526
 527 void DnsProbeBrowserTest::SetActiveBrowser(Browser* browser) {
 528   // If currently watching a NetErrorTabHelper, stop doing so before start
 529   // watching another.
 530   if (monitored_tab_helper_) {
 531     monitored_tab_helper_->set_dns_probe_status_snoop_callback_for_testing(
 532         NetErrorTabHelper::DnsProbeStatusSnoopCallback());
 533   }
 534   active_browser_ = browser;
 535   monitored_tab_helper_ = NetErrorTabHelper::FromWebContents(
 536       active_browser_->tab_strip_model()->GetActiveWebContents());
 537   monitored_tab_helper_->set_dns_probe_status_snoop_callback_for_testing(
 538       Bind(&DnsProbeBrowserTest::OnDnsProbeStatusSent, Unretained(this)));
 539 }
 540
 541 void DnsProbeBrowserTest::SetCorrectionServiceBroken(bool broken) {
 542   int net_error = broken ? net::ERR_NAME_NOT_RESOLVED : net::OK;
 543
 544   BrowserThread::PostTask(
 545       BrowserThread::IO, FROM_HERE,
 546       Bind(&DnsProbeBrowserTestIOThreadHelper::SetCorrectionServiceNetError,
 547            Unretained(helper_),
 548            net_error));
 549 }
 550
 551 void DnsProbeBrowserTest::SetCorrectionServiceDelayRequests(
 552     bool delay_requests) {
 553   BrowserThread::PostTask(
 554       BrowserThread::IO, FROM_HERE,
 555       Bind(&DnsProbeBrowserTestIOThreadHelper::
 556                SetCorrectionServiceDelayRequests,
 557            Unretained(helper_),
 558            delay_requests));
 559 }
 560
 561 void DnsProbeBrowserTest::WaitForDelayedRequestDestruction() {
 562   base::RunLoop run_loop;
 563   BrowserThread::PostTask(
 564       BrowserThread::IO, FROM_HERE,
 565       Bind(&DnsProbeBrowserTestIOThreadHelper::SetRequestDestructionCallback,
 566            Unretained(helper_),
 567            base::Bind(&RunClosureOnUIThread,
 568                       run_loop.QuitClosure())));
 569   run_loop.Run();
 570 }
 571
 572 void DnsProbeBrowserTest::NavigateToDnsError(int num_navigations) {
 573   NavigateToURLBlockUntilNavigationsComplete(
 574       active_browser_,
 575       URLRequestFailedJob::GetMockHttpUrl(net::ERR_NAME_NOT_RESOLVED),
 576       num_navigations);
 577 }
 578
 579 void DnsProbeBrowserTest::NavigateToOtherError(int num_navigations) {
 580   NavigateToURLBlockUntilNavigationsComplete(
 581       active_browser_,
 582       URLRequestFailedJob::GetMockHttpUrl(net::ERR_CONNECTION_REFUSED),
 583       num_navigations);
 584 }
 585
 586 void DnsProbeBrowserTest::SetMockDnsClientRules(
 587     MockDnsClientRule::Result system_result,
 588     MockDnsClientRule::Result public_result) {
 589   BrowserThread::PostTask(
 590       BrowserThread::IO, FROM_HERE,
 591       Bind(&DnsProbeBrowserTestIOThreadHelper::SetMockDnsClientRules,
 592            Unretained(helper_),
 593            system_result,
 594            public_result));
 595 }
 596
 597 void DnsProbeBrowserTest::StartDelayedProbes(
 598     int expected_delayed_probe_count) {
 599   BrowserThread::PostTask(
 600       BrowserThread::IO, FROM_HERE,
 601       Bind(&DnsProbeBrowserTestIOThreadHelper::StartDelayedProbes,
 602            Unretained(helper_),
 603            expected_delayed_probe_count));
 604 }
 605
 606 DnsProbeStatus DnsProbeBrowserTest::WaitForSentStatus() {
 607   CHECK(!awaiting_dns_probe_status_);
 608   while (dns_probe_status_queue_.empty()) {
 609     awaiting_dns_probe_status_ = true;
 610     MessageLoop::current()->Run();
 611     awaiting_dns_probe_status_ = false;
 612   }
 613
 614   CHECK(!dns_probe_status_queue_.empty());
 615   DnsProbeStatus status = dns_probe_status_queue_.front();
 616   dns_probe_status_queue_.pop_front();
 617   return status;
 618 }
 619
 620 // Check title by roundtripping to renderer, to make sure any probe results
 621 // sent before this have been applied.
 622 std::string DnsProbeBrowserTest::Title() {
 623   std::string title;
 624
 625   WebContents* contents =
 626       active_browser_->tab_strip_model()->GetActiveWebContents();
 627
 628   bool rv = content::ExecuteScriptAndExtractString(
 629       contents,
 630       "domAutomationController.send(document.title);",
 631       &title);
 632   if (!rv)
 633     return "";
 634
 635   return title;
 636 }
 637
 638 // Check text by roundtripping to renderer, to make sure any probe results
 639 // sent before this have been applied.
 640 bool DnsProbeBrowserTest::PageContains(const std::string& expected) {
 641   std::string text_content;
 642
 643   bool rv = content::ExecuteScriptAndExtractString(
 644       active_browser_->tab_strip_model()->GetActiveWebContents(),
 645       "domAutomationController.send(document.body.textContent);",
 646       &text_content);
 647   if (!rv)
 648     return false;
 649
 650   return text_content.find(expected) != std::string::npos;
 651 }
 652
 653 void DnsProbeBrowserTest::ExpectDisplayingLocalErrorPage(
 654     const std::string& status_text) {
 655   EXPECT_FALSE(PageContains("http://correction1/"));
 656   EXPECT_FALSE(PageContains("http://correction2/"));
 657   EXPECT_TRUE(PageContains(status_text));
 658 }
 659
 660 void DnsProbeBrowserTest::ExpectDisplayingCorrections(
 661     const std::string& status_text) {
 662   EXPECT_TRUE(PageContains("http://correction1/"));
 663   EXPECT_TRUE(PageContains("http://correction2/"));
 664   EXPECT_TRUE(PageContains(status_text));
 665 }
 666
 667 void DnsProbeBrowserTest::OnDnsProbeStatusSent(
 668     DnsProbeStatus dns_probe_status) {
 669   dns_probe_status_queue_.push_back(dns_probe_status);
 670   if (awaiting_dns_probe_status_)
 671     MessageLoop::current()->Quit();
 672 }
 673
 674 // Make sure probes don't break non-DNS error pages when corrections load.
 675 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, OtherErrorWithCorrectionsSuccess) {
 676   SetCorrectionServiceBroken(false);
 677
 678   NavigateToOtherError(2);
 679   ExpectDisplayingCorrections("ERR_CONNECTION_REFUSED");
 680 }
 681
 682 // Make sure probes don't break non-DNS error pages when corrections failed to
 683 // load.
 684 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, OtherErrorWithCorrectionsFailure) {
 685   SetCorrectionServiceBroken(true);
 686
 687   NavigateToOtherError(2);
 688   ExpectDisplayingLocalErrorPage("ERR_CONNECTION_REFUSED");
 689 }
 690
 691 // Make sure probes don't break DNS error pages when corrections load.
 692 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
 693                        NxdomainProbeResultWithWorkingCorrections) {
 694   SetCorrectionServiceBroken(false);
 695   SetMockDnsClientRules(MockDnsClientRule::OK, MockDnsClientRule::OK);
 696
 697   NavigateToDnsError(2);
 698   ExpectDisplayingCorrections("ERR_NAME_NOT_RESOLVED");
 699
 700   // One status for committing a blank page before the corrections, and one for
 701   // when the error page with corrections is committed.
 702   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 703   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 704   EXPECT_EQ(0, pending_status_count());
 705   ExpectDisplayingCorrections("ERR_NAME_NOT_RESOLVED");
 706
 707   StartDelayedProbes(1);
 708
 709   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN,
 710             WaitForSentStatus());
 711   EXPECT_EQ(0, pending_status_count());
 712   ExpectDisplayingCorrections("ERR_NAME_NOT_RESOLVED");
 713 }
 714
 715 // Make sure probes don't break corrections when probes complete before the
 716 // corrections load.
 717 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
 718                        NxdomainProbeResultWithWorkingSlowCorrections) {
 719   SetCorrectionServiceBroken(false);
 720   SetCorrectionServiceDelayRequests(true);
 721   SetMockDnsClientRules(MockDnsClientRule::OK, MockDnsClientRule::OK);
 722
 723   NavigateToDnsError(1);
 724   // A blank page should be displayed while the corrections are loaded.
 725   EXPECT_EQ("", Title());
 726
 727   // A single probe should be triggered by the error page load, and it should
 728   // be ignored.
 729   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 730   EXPECT_EQ(0, pending_status_count());
 731   EXPECT_EQ("", Title());
 732
 733   StartDelayedProbes(1);
 734   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN,
 735             WaitForSentStatus());
 736   EXPECT_EQ(0, pending_status_count());
 737   EXPECT_EQ("", Title());
 738
 739   content::TestNavigationObserver observer(
 740       browser()->tab_strip_model()->GetActiveWebContents(), 1);
 741   // The corrections finish loading.
 742   SetCorrectionServiceDelayRequests(false);
 743   // Wait for it to commit.
 744   observer.Wait();
 745   ExpectDisplayingCorrections("ERR_NAME_NOT_RESOLVED");
 746
 747   // Committing the corections page should trigger sending the probe result
 748   // again.
 749   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN,
 750             WaitForSentStatus());
 751   ExpectDisplayingCorrections("ERR_NAME_NOT_RESOLVED");
 752 }
 753
 754 // Make sure probes update DNS error page properly when they're supposed to.
 755 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
 756                        NoInternetProbeResultWithBrokenCorrections) {
 757   SetCorrectionServiceBroken(true);
 758   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT,
 759                         MockDnsClientRule::TIMEOUT);
 760
 761   NavigateToDnsError(2);
 762
 763   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 764   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 765
 766   // Checking the page runs the RunLoop, so make sure nothing hairy happens.
 767   EXPECT_EQ(0, pending_status_count());
 768   ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
 769   EXPECT_EQ(0, pending_status_count());
 770
 771   StartDelayedProbes(1);
 772
 773   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET,
 774             WaitForSentStatus());
 775
 776   // Checking the page runs the RunLoop, so make sure nothing hairy happens.
 777   EXPECT_EQ(0, pending_status_count());
 778   ExpectDisplayingLocalErrorPage("DNS_PROBE_FINISHED_NO_INTERNET");
 779 }
 780
 781 // Make sure probes don't break corrections when probes complete before the
 782 // corrections request returns an error.
 783 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
 784                        NoInternetProbeResultWithSlowBrokenCorrections) {
 785   SetCorrectionServiceBroken(true);
 786   SetCorrectionServiceDelayRequests(true);
 787   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT,
 788                         MockDnsClientRule::TIMEOUT);
 789
 790   NavigateToDnsError(1);
 791   // A blank page should be displayed while the corrections load.
 792   EXPECT_EQ("", Title());
 793
 794   // A single probe should be triggered by the error page load, and it should
 795   // be ignored.
 796   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 797   EXPECT_EQ(0, pending_status_count());
 798   EXPECT_EQ("", Title());
 799
 800   StartDelayedProbes(1);
 801   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET,
 802             WaitForSentStatus());
 803   EXPECT_EQ("", Title());
 804   EXPECT_EQ(0, pending_status_count());
 805
 806   content::TestNavigationObserver observer(
 807       browser()->tab_strip_model()->GetActiveWebContents(), 1);
 808   // The corrections request fails.
 809   SetCorrectionServiceDelayRequests(false);
 810   // Wait for the DNS error page to load instead.
 811   observer.Wait();
 812   // The page committing should result in sending the probe results again.
 813   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET,
 814             WaitForSentStatus());
 815
 816   EXPECT_EQ(0, pending_status_count());
 817   ExpectDisplayingLocalErrorPage("DNS_PROBE_FINISHED_NO_INTERNET");
 818 }
 819
 820 // Double-check to make sure sync failures don't explode.
 821 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, SyncFailureWithBrokenCorrections) {
 822   SetCorrectionServiceBroken(true);
 823   SetMockDnsClientRules(MockDnsClientRule::FAIL, MockDnsClientRule::FAIL);
 824
 825   NavigateToDnsError(2);
 826
 827   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 828   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 829
 830   // Checking the page runs the RunLoop, so make sure nothing hairy happens.
 831   EXPECT_EQ(0, pending_status_count());
 832   ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
 833   EXPECT_EQ(0, pending_status_count());
 834
 835   StartDelayedProbes(1);
 836
 837   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
 838             WaitForSentStatus());
 839
 840   // Checking the page runs the RunLoop, so make sure nothing hairy happens.
 841   EXPECT_EQ(0, pending_status_count());
 842   ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
 843   EXPECT_EQ(0, pending_status_count());
 844 }
 845
 846 // Test that pressing the stop button cancels loading corrections.
 847 // TODO(mmenke):  Add a test for the cross process navigation case.
 848 // TODO(mmenke):  This test could flakily pass due to the timeout on downloading
 849 //                the corrections.  Disable that timeout for browser tests.
 850 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, CorrectionsLoadStopped) {
 851   SetCorrectionServiceDelayRequests(true);
 852   SetCorrectionServiceBroken(true);
 853   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT, MockDnsClientRule::TIMEOUT);
 854
 855   NavigateToDnsError(1);
 856
 857   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 858   StartDelayedProbes(1);
 859   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET,
 860             WaitForSentStatus());
 861
 862   EXPECT_EQ("", Title());
 863   EXPECT_EQ(0, pending_status_count());
 864
 865   chrome::Stop(browser());
 866   WaitForDelayedRequestDestruction();
 867
 868   // End up displaying a blank page.
 869   EXPECT_EQ("", Title());
 870 }
 871
 872 // Test that pressing the stop button cancels the load of corrections, and
 873 // receiving a probe result afterwards does not swap in a DNS error page.
 874 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, CorrectionsLoadStoppedSlowProbe) {
 875   SetCorrectionServiceDelayRequests(true);
 876   SetCorrectionServiceBroken(true);
 877   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT, MockDnsClientRule::TIMEOUT);
 878
 879   NavigateToDnsError(1);
 880
 881   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 882
 883   EXPECT_EQ("", Title());
 884   EXPECT_EQ(0, pending_status_count());
 885
 886   chrome::Stop(browser());
 887   WaitForDelayedRequestDestruction();
 888
 889   EXPECT_EQ("", Title());
 890   EXPECT_EQ(0, pending_status_count());
 891
 892   StartDelayedProbes(1);
 893   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET,
 894             WaitForSentStatus());
 895
 896   EXPECT_EQ("", Title());
 897 }
 898
 899 // Make sure probes don't run for subframe DNS errors.
 900 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, NoProbeInSubframe) {
 901   SetCorrectionServiceBroken(false);
 902
 903   const FilePath::CharType kIframeDnsErrorHtmlName[] =
 904       FILE_PATH_LITERAL("iframe_dns_error.html");
 905
 906   NavigateToURL(
 907       browser(),
 908       URLRequestMockHTTPJob::GetMockUrl(FilePath(kIframeDnsErrorHtmlName)));
 909
 910   // By the time NavigateToURL returns, the browser will have seen the failed
 911   // provisional load.  If a probe was started (or considered but not run),
 912   // then the NetErrorTabHelper would have sent a NetErrorInfo message.  Thus,
 913   // if one hasn't been sent by now, the NetErrorTabHelper has not (and won't)
 914   // start a probe for this DNS error.
 915   EXPECT_EQ(0, pending_status_count());
 916 }
 917
 918 // Make sure browser sends NOT_RUN properly when probes are disabled.
 919 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, ProbesDisabled) {
 920   // Disable probes (And corrections).
 921   browser()->profile()->GetPrefs()->SetBoolean(
 922       prefs::kAlternateErrorPagesEnabled, false);
 923
 924   SetCorrectionServiceBroken(true);
 925   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT, MockDnsClientRule::TIMEOUT);
 926
 927   NavigateToDnsError(1);
 928
 929   EXPECT_EQ(chrome_common_net::DNS_PROBE_NOT_RUN, WaitForSentStatus());
 930
 931   // Checking the page runs the RunLoop, so make sure nothing hairy happens.
 932   EXPECT_EQ(0, pending_status_count());
 933   ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
 934 }
 935
 936 // Test the case that corrections are disabled, but DNS probes are enabled.
 937 // This is the case with Chromium builds.
 938 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, CorrectionsDisabled) {
 939   // Disable corrections.
 940   browser()->profile()->GetPrefs()->SetBoolean(
 941       prefs::kAlternateErrorPagesEnabled, false);
 942   // Requests to the correction service should work if any are made, so the test
 943   // fails if that happens unexpectedly.
 944   SetCorrectionServiceBroken(false);
 945   // Normally disabling corrections disables DNS probes, so force DNS probes
 946   // to be enabled.
 947   NetErrorTabHelper::set_state_for_testing(
 948       NetErrorTabHelper::TESTING_FORCE_ENABLED);
 949
 950   SetMockDnsClientRules(MockDnsClientRule::FAIL, MockDnsClientRule::FAIL);
 951
 952   // Just one commit and one sent status, since corrections are disabled.
 953   NavigateToDnsError(1);
 954   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 955
 956   // Checking the page runs the RunLoop, so make sure nothing hairy happens.
 957   EXPECT_EQ(0, pending_status_count());
 958   ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
 959   EXPECT_EQ(0, pending_status_count());
 960
 961   StartDelayedProbes(1);
 962
 963   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
 964             WaitForSentStatus());
 965   EXPECT_EQ(0, pending_status_count());
 966   ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
 967 }
 968
 969 // Test incognito mode.  Corrections should be disabled, but DNS probes are
 970 // still enabled.
 971 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, Incognito) {
 972   // Requests to the correction service should work if any are made, so the test
 973   // will fail if one is requested unexpectedly.
 974   SetCorrectionServiceBroken(false);
 975
 976   Browser* incognito = CreateIncognitoBrowser();
 977   SetActiveBrowser(incognito);
 978
 979   SetMockDnsClientRules(MockDnsClientRule::FAIL, MockDnsClientRule::FAIL);
 980
 981   // Just one commit and one sent status, since the corrections are disabled.
 982   NavigateToDnsError(1);
 983   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 984
 985   // Checking the page runs the RunLoop, so make sure nothing hairy happens.
 986   EXPECT_EQ(0, pending_status_count());
 987   ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
 988   EXPECT_EQ(0, pending_status_count());
 989
 990   StartDelayedProbes(1);
 991
 992   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
 993             WaitForSentStatus());
 994   EXPECT_EQ(0, pending_status_count());
 995   ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
 996 }
 997
 998 }  // namespace
 999
1000 }  // namespace chrome_browser_net