Home | History | Annotate | Download | only in net 
      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 "chrome/browser/net/net_error_tab_helper.h"
      6 
      7 #include "base/message_loop/message_loop.h"
      8 #include "chrome/common/net/net_error_info.h"
      9 #include "content/public/browser/browser_thread.h"
     10 #include "content/public/common/page_transition_types.h"
     11 #include "content/public/test/test_browser_thread.h"
     12 #include "net/base/net_errors.h"
     13 #include "testing/gtest/include/gtest/gtest.h"
     14 
     15 using base::MessageLoop;
     16 using chrome_browser_net::NetErrorTabHelper;
     17 using chrome_common_net::DnsProbeStatus;
     18 using content::BrowserThread;
     19 using content::TestBrowserThread;
     20 
     21 class TestNetErrorTabHelper : public NetErrorTabHelper {
     22  public:
     23   TestNetErrorTabHelper()
     24       : NetErrorTabHelper(NULL),
     25         mock_probe_running_(false),
     26         last_status_sent_(chrome_common_net::DNS_PROBE_MAX),
     27         mock_sent_count_(0) {}
     28 
     29   void FinishProbe(DnsProbeStatus status) {
     30     EXPECT_TRUE(mock_probe_running_);
     31     OnDnsProbeFinished(status);
     32     mock_probe_running_ = false;
     33   }
     34 
     35   bool mock_probe_running() const { return mock_probe_running_; }
     36   DnsProbeStatus last_status_sent() const { return last_status_sent_; }
     37   int mock_sent_count() const { return mock_sent_count_; }
     38 
     39  private:
     40   virtual void StartDnsProbe() OVERRIDE {
     41     EXPECT_FALSE(mock_probe_running_);
     42     mock_probe_running_ = true;
     43   }
     44 
     45   virtual void SendInfo() OVERRIDE {
     46     last_status_sent_ = dns_probe_status();
     47     mock_sent_count_++;
     48   }
     49 
     50   bool mock_probe_running_;
     51   DnsProbeStatus last_status_sent_;
     52   int mock_sent_count_;
     53 };
     54 
     55 class NetErrorTabHelperTest : public testing::Test {
     56  protected:
     57   enum MainFrame { SUB_FRAME, MAIN_FRAME };
     58   enum ErrorPage { NORMAL_PAGE, ERROR_PAGE };
     59   enum ErrorType { DNS_ERROR, OTHER_ERROR };
     60 
     61   NetErrorTabHelperTest()
     62       : fake_ui_thread_(BrowserThread::UI, &message_loop_) {
     63     NetErrorTabHelper::set_state_for_testing(
     64         NetErrorTabHelper::TESTING_FORCE_ENABLED);
     65   }
     66 
     67   void StartProvisionalLoad(MainFrame main_frame, ErrorPage error_page) {
     68     tab_helper_.DidStartProvisionalLoadForFrame(
     69         1,  // frame_id
     70         0,  // parent_frame_id
     71         (main_frame == MAIN_FRAME),
     72         bogus_url_,  // validated_url
     73         (error_page == ERROR_PAGE),
     74         false,  // is_iframe_srcdoc
     75         NULL);  // render_view_host
     76   }
     77 
     78   void CommitProvisionalLoad(MainFrame main_frame) {
     79     tab_helper_.DidCommitProvisionalLoadForFrame(
     80         1,  // frame id
     81         base::string16(),
     82         (main_frame == MAIN_FRAME),
     83         bogus_url_,  // url
     84         content::PAGE_TRANSITION_TYPED,
     85         NULL);  // render_view_host
     86   }
     87 
     88   void FailProvisionalLoad(MainFrame main_frame, ErrorType error_type) {
     89     int net_error;
     90 
     91     if (error_type == DNS_ERROR)
     92       net_error = net::ERR_NAME_NOT_RESOLVED;
     93     else
     94       net_error = net::ERR_TIMED_OUT;
     95 
     96     tab_helper_.DidFailProvisionalLoad(
     97         1,  // frame id
     98         base::string16(),
     99         (main_frame == MAIN_FRAME),
    100         bogus_url_,  // validated_url
    101         net_error,
    102         base::string16(),
    103         NULL);  // render_view_host
    104   }
    105 
    106   void FinishProbe(DnsProbeStatus status) {
    107     tab_helper_.FinishProbe(status);
    108   }
    109 
    110   bool probe_running() { return tab_helper_.mock_probe_running(); }
    111   DnsProbeStatus last_status_sent() { return tab_helper_.last_status_sent(); }
    112   int sent_count() { return tab_helper_.mock_sent_count(); }
    113 
    114  private:
    115   MessageLoop message_loop_;
    116   TestBrowserThread fake_ui_thread_;
    117   TestNetErrorTabHelper tab_helper_;
    118   GURL bogus_url_;
    119 };
    120 
    121 TEST_F(NetErrorTabHelperTest, Null) {
    122   EXPECT_FALSE(probe_running());
    123 }
    124 
    125 TEST_F(NetErrorTabHelperTest, MainFrameNonDnsError) {
    126   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    127   FailProvisionalLoad(MAIN_FRAME, OTHER_ERROR);
    128   EXPECT_FALSE(probe_running());
    129   EXPECT_EQ(0, sent_count());
    130 }
    131 
    132 TEST_F(NetErrorTabHelperTest, NonMainFrameDnsError) {
    133   StartProvisionalLoad(SUB_FRAME, NORMAL_PAGE);
    134   FailProvisionalLoad(SUB_FRAME, DNS_ERROR);
    135   EXPECT_FALSE(probe_running());
    136   EXPECT_EQ(0, sent_count());
    137 }
    138 
    139 // Test complete DNS error page loads.  Note that the helper can see two error
    140 // page loads: Link Doctor loads an empty HTML page so the user knows something
    141 // is going on, then fails over to the normal error page if and when Link
    142 // Doctor fails to load or declines to provide a page.
    143 
    144 TEST_F(NetErrorTabHelperTest, ProbeResponseBeforeFirstCommit) {
    145   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    146   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    147   EXPECT_TRUE(probe_running());
    148   EXPECT_EQ(0, sent_count());
    149 
    150   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    151   EXPECT_TRUE(probe_running());
    152   EXPECT_EQ(0, sent_count());
    153 
    154   FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
    155   EXPECT_FALSE(probe_running());
    156   EXPECT_EQ(0, sent_count());
    157 
    158   CommitProvisionalLoad(MAIN_FRAME);
    159   EXPECT_FALSE(probe_running());
    160   EXPECT_EQ(1, sent_count());
    161   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
    162 
    163   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    164   EXPECT_FALSE(probe_running());
    165   EXPECT_EQ(1, sent_count());
    166 
    167   CommitProvisionalLoad(MAIN_FRAME);
    168   EXPECT_FALSE(probe_running());
    169   EXPECT_EQ(2, sent_count());
    170   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
    171 }
    172 
    173 TEST_F(NetErrorTabHelperTest, ProbeResponseBetweenFirstAndSecondCommit) {
    174   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    175   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    176   EXPECT_TRUE(probe_running());
    177   EXPECT_EQ(0, sent_count());
    178 
    179   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    180   EXPECT_TRUE(probe_running());
    181   EXPECT_EQ(0, sent_count());
    182 
    183   CommitProvisionalLoad(MAIN_FRAME);
    184   EXPECT_TRUE(probe_running());
    185   EXPECT_EQ(1, sent_count());
    186   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    187 
    188   FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
    189   EXPECT_FALSE(probe_running());
    190   EXPECT_EQ(2, sent_count());
    191   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
    192 
    193   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    194   EXPECT_FALSE(probe_running());
    195   EXPECT_EQ(2, sent_count());
    196 
    197   CommitProvisionalLoad(MAIN_FRAME);
    198   EXPECT_FALSE(probe_running());
    199   EXPECT_EQ(3, sent_count());
    200   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
    201 }
    202 
    203 TEST_F(NetErrorTabHelperTest, ProbeResponseAfterSecondCommit) {
    204   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    205   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    206   EXPECT_TRUE(probe_running());
    207   EXPECT_EQ(0, sent_count());
    208 
    209   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    210   EXPECT_TRUE(probe_running());
    211   EXPECT_EQ(0, sent_count());
    212 
    213   CommitProvisionalLoad(MAIN_FRAME);
    214   EXPECT_TRUE(probe_running());
    215   EXPECT_EQ(1, sent_count());
    216   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    217 
    218   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    219   EXPECT_TRUE(probe_running());
    220   EXPECT_EQ(1, sent_count());
    221 
    222   CommitProvisionalLoad(MAIN_FRAME);
    223   EXPECT_TRUE(probe_running());
    224   EXPECT_EQ(2, sent_count());
    225   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    226 
    227   FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
    228   EXPECT_FALSE(probe_running());
    229   EXPECT_EQ(3, sent_count());
    230   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
    231 }
    232 
    233 // Send result even if a new page load has started; the error page is still
    234 // visible, and the user might cancel the load.
    235 TEST_F(NetErrorTabHelperTest, ProbeResponseAfterNewStart) {
    236   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    237   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    238   EXPECT_TRUE(probe_running());
    239   EXPECT_EQ(0, sent_count());
    240 
    241   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    242   EXPECT_TRUE(probe_running());
    243   EXPECT_EQ(0, sent_count());
    244 
    245   CommitProvisionalLoad(MAIN_FRAME);
    246   EXPECT_TRUE(probe_running());
    247   EXPECT_EQ(1, sent_count());
    248   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    249 
    250   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    251   EXPECT_TRUE(probe_running());
    252   EXPECT_EQ(1, sent_count());
    253 
    254   CommitProvisionalLoad(MAIN_FRAME);
    255   EXPECT_TRUE(probe_running());
    256   EXPECT_EQ(2, sent_count());
    257   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    258 
    259   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    260   EXPECT_TRUE(probe_running());
    261   EXPECT_EQ(2, sent_count());
    262 
    263   FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
    264   EXPECT_FALSE(probe_running());
    265   EXPECT_EQ(3, sent_count());
    266   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
    267 }
    268 
    269 // Don't send result if a new page has committed; the result would go to the
    270 // wrong page, and the error page is gone anyway.
    271 TEST_F(NetErrorTabHelperTest, ProbeResponseAfterNewCommit) {
    272   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    273   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    274   EXPECT_TRUE(probe_running());
    275   EXPECT_EQ(0, sent_count());
    276 
    277   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    278   EXPECT_TRUE(probe_running());
    279   EXPECT_EQ(0, sent_count());
    280 
    281   CommitProvisionalLoad(MAIN_FRAME);
    282   EXPECT_TRUE(probe_running());
    283   EXPECT_EQ(1, sent_count());
    284   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    285 
    286   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    287   EXPECT_TRUE(probe_running());
    288   EXPECT_EQ(1, sent_count());
    289 
    290   CommitProvisionalLoad(MAIN_FRAME);
    291   EXPECT_TRUE(probe_running());
    292   EXPECT_EQ(2, sent_count());
    293   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    294 
    295   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    296   EXPECT_TRUE(probe_running());
    297   EXPECT_EQ(2, sent_count());
    298 
    299   CommitProvisionalLoad(MAIN_FRAME);
    300   EXPECT_TRUE(probe_running());
    301   EXPECT_EQ(2, sent_count());
    302 
    303   FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
    304   EXPECT_FALSE(probe_running());
    305   EXPECT_EQ(2, sent_count());
    306 }
    307 
    308 TEST_F(NetErrorTabHelperTest, MultipleDnsErrorsWithProbesWithoutErrorPages) {
    309   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    310   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    311   EXPECT_TRUE(probe_running());
    312   EXPECT_EQ(0, sent_count());
    313 
    314   FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
    315   EXPECT_FALSE(probe_running());
    316   EXPECT_EQ(0, sent_count());
    317 
    318   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    319   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    320   EXPECT_TRUE(probe_running());
    321   EXPECT_EQ(0, sent_count());
    322 
    323   FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET);
    324   EXPECT_FALSE(probe_running());
    325   EXPECT_EQ(0, sent_count());
    326 }
    327 
    328 TEST_F(NetErrorTabHelperTest, MultipleDnsErrorsWithProbesAndErrorPages) {
    329   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    330   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    331   EXPECT_TRUE(probe_running());
    332   EXPECT_EQ(0, sent_count());
    333 
    334   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    335   CommitProvisionalLoad(MAIN_FRAME);
    336   EXPECT_TRUE(probe_running());
    337   EXPECT_EQ(1, sent_count());
    338   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    339 
    340   FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
    341   EXPECT_FALSE(probe_running());
    342   EXPECT_EQ(2, sent_count());
    343   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
    344 
    345   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    346   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    347   EXPECT_TRUE(probe_running());
    348   EXPECT_EQ(2, sent_count());
    349 
    350   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    351   CommitProvisionalLoad(MAIN_FRAME);
    352   EXPECT_TRUE(probe_running());
    353   EXPECT_EQ(3, sent_count());
    354   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    355 
    356   FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET);
    357   EXPECT_FALSE(probe_running());
    358   EXPECT_EQ(4, sent_count());
    359   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET,
    360             last_status_sent());
    361 }
    362 
    363 // If multiple DNS errors occur in a row before a probe result, don't start
    364 // multiple probes.
    365 TEST_F(NetErrorTabHelperTest, CoalesceFailures) {
    366   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    367   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    368   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    369   CommitProvisionalLoad(MAIN_FRAME);
    370   EXPECT_TRUE(probe_running());
    371   EXPECT_EQ(1, sent_count());
    372   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    373 
    374   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    375   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    376   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    377   CommitProvisionalLoad(MAIN_FRAME);
    378   EXPECT_TRUE(probe_running());
    379   EXPECT_EQ(2, sent_count());
    380   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    381 
    382   StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
    383   FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
    384   StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
    385   CommitProvisionalLoad(MAIN_FRAME);
    386   EXPECT_TRUE(probe_running());
    387   EXPECT_EQ(3, sent_count());
    388   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
    389 
    390   FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
    391   EXPECT_FALSE(probe_running());
    392   EXPECT_EQ(4, sent_count());
    393   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
    394 }
    395