Index: chrome/browser/net/net_error_tab_helper_unittest.cc |
diff --git a/chrome/browser/net/net_error_tab_helper_unittest.cc b/chrome/browser/net/net_error_tab_helper_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..d541dd0b2288181b669ddecaef0fc68157a8c816 |
--- /dev/null |
+++ b/chrome/browser/net/net_error_tab_helper_unittest.cc |
@@ -0,0 +1,323 @@ |
+// Copyright (c) 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 "chrome/browser/net/net_error_tab_helper.h" |
+ |
+#include "base/message_loop.h" |
+#include "chrome/common/net/net_error_info.h" |
+#include "content/public/browser/browser_thread.h" |
+#include "content/public/common/page_transition_types.h" |
+#include "content/public/test/test_browser_thread.h" |
+#include "net/base/net_errors.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+using base::MessageLoop; |
+using chrome_browser_net::NetErrorTabHelper; |
+using chrome_common_net::DnsProbeStatus; |
+using content::BrowserThread; |
+using content::TestBrowserThread; |
+ |
+class TestNetErrorTabHelper : public NetErrorTabHelper { |
+ public: |
+ TestNetErrorTabHelper() |
+ : NetErrorTabHelper(NULL), |
+ mock_probe_count_(0), |
+ mock_sent_status_(chrome_common_net::DNS_PROBE_MAX), |
+ mock_sent_count_(0) {} |
+ |
+ void FinishProbe(DnsProbeStatus status) { |
+ OnDnsProbeFinished(status); |
+ mock_probe_count_--; |
+ } |
+ |
+ int mock_probe_count() const { return mock_probe_count_; } |
+ DnsProbeStatus mock_sent_status() const { return mock_sent_status_; } |
+ int mock_sent_count() const { return mock_sent_count_; } |
+ |
+ private: |
+ virtual void StartDnsProbe() OVERRIDE { |
+ mock_probe_count_++; |
+ } |
+ |
+ virtual void SendInfo() OVERRIDE { |
+ mock_sent_status_ = dns_probe_status_; |
+ mock_sent_count_++; |
+ } |
+ |
+ int mock_probe_count_; |
mmenke
2013/06/26 16:31:28
nit: Think this is a bit of a misnomer. Suggest
Deprecated (see juliatuttle)
2013/06/26 22:23:56
Done.
|
+ DnsProbeStatus mock_sent_status_; |
+ int mock_sent_count_; |
+}; |
+ |
+class NetErrorTabHelperTest : public testing::Test { |
+ protected: |
+ enum MainFrame { SUB_FRAME, MAIN_FRAME }; |
+ enum ErrorPage { NORMAL_PAGE, ERROR_PAGE }; |
+ enum ErrorType { DNS_ERROR, OTHER_ERROR }; |
+ |
+ NetErrorTabHelperTest() |
+ : fake_ui_thread_(BrowserThread::UI, &message_loop_) { |
+ NetErrorTabHelper::set_state_for_testing( |
+ NetErrorTabHelper::TESTING_FORCE_ENABLED); |
+ } |
+ |
+ void StartProvisionalLoad(MainFrame main_frame, ErrorPage error_page) { |
+ tab_helper_.DidStartProvisionalLoadForFrame( |
+ 1, // frame_id |
+ 0, // parent_frame_id |
+ (main_frame == MAIN_FRAME), |
+ bogus_url_, // validated_url |
+ (error_page == ERROR_PAGE), |
+ false, // is_iframe_srcdoc |
+ NULL); // render_view_host |
+ } |
+ |
+ void CommitProvisionalLoad(MainFrame main_frame) { |
+ tab_helper_.DidCommitProvisionalLoadForFrame( |
+ 1, // frame id |
+ (main_frame == MAIN_FRAME), |
+ bogus_url_, // url |
+ content::PAGE_TRANSITION_TYPED, |
+ NULL); // render_view_host |
+ } |
+ |
+ void FailProvisionalLoad(MainFrame main_frame, ErrorType error_type) { |
+ string16 bogus_error_description; |
+ int net_error; |
+ |
+ if (error_type == DNS_ERROR) |
+ net_error = net::ERR_NAME_NOT_RESOLVED; |
+ else |
+ net_error = net::ERR_TIMED_OUT; |
+ |
+ tab_helper_.DidFailProvisionalLoad( |
+ 1, // frame id |
+ (main_frame == MAIN_FRAME), |
+ bogus_url_, // validated_url |
+ net_error, |
+ bogus_error_description, |
+ NULL); // render_view_host |
+ } |
+ |
+ void FinishProbe(DnsProbeStatus status) { |
+ tab_helper_.FinishProbe(status); |
+ } |
+ |
+ int probe_count() { return tab_helper_.mock_probe_count(); } |
+ DnsProbeStatus sent_status() { return tab_helper_.mock_sent_status(); } |
+ int sent_count() { return tab_helper_.mock_sent_count(); } |
+ |
+ private: |
+ MessageLoop message_loop_; |
+ TestBrowserThread fake_ui_thread_; |
+ TestNetErrorTabHelper tab_helper_; |
+ GURL bogus_url_; |
+}; |
+ |
+TEST_F(NetErrorTabHelperTest, Null) { |
+ EXPECT_EQ(0, probe_count()); |
+} |
+ |
+TEST_F(NetErrorTabHelperTest, MainFrameNonDnsError) { |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, OTHER_ERROR); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(0, sent_count()); |
+} |
+ |
+TEST_F(NetErrorTabHelperTest, NonMainFrameDnsError) { |
+ StartProvisionalLoad(SUB_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(SUB_FRAME, DNS_ERROR); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(0, sent_count()); |
+} |
+ |
+TEST_F(NetErrorTabHelperTest, ProbeResponseBeforeStart) { |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(1, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(2, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE); |
+ CommitProvisionalLoad(MAIN_FRAME); |
+ EXPECT_EQ(3, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, sent_status()); |
+} |
+ |
+TEST_F(NetErrorTabHelperTest, ProbeResponseBetweenStartAndCommit) { |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(1, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE); |
+ |
+ FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(2, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, sent_status()); |
+ |
+ CommitProvisionalLoad(MAIN_FRAME); |
+ EXPECT_EQ(3, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, sent_status()); |
+} |
+ |
+TEST_F(NetErrorTabHelperTest, ProbeResponseAfterCommit) { |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(1, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE); |
+ CommitProvisionalLoad(MAIN_FRAME); |
+ EXPECT_EQ(2, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(3, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, sent_status()); |
+} |
+ |
+// Send result even if we've started a new page load; the error page is still |
+// visible, and the user might cancel the load. |
+TEST_F(NetErrorTabHelperTest, ProbeResponseAfterNewStart) { |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(1, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE); |
+ CommitProvisionalLoad(MAIN_FRAME); |
+ EXPECT_EQ(2, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ |
+ FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(3, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, sent_status()); |
+} |
+ |
+// Don't send result if we've committed a new page load; the result would go |
+// to the wrong page, and the error page is gone anyway. |
+TEST_F(NetErrorTabHelperTest, ProbeResponseAfterNewCommit) { |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(1, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE); |
+ CommitProvisionalLoad(MAIN_FRAME); |
+ EXPECT_EQ(2, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ CommitProvisionalLoad(MAIN_FRAME); |
+ |
+ FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(2, sent_count()); |
+} |
+ |
+TEST_F(NetErrorTabHelperTest, MultipleProbesWithoutErrorPage) { |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(1, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(2, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(3, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(4, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET, sent_status()); |
+} |
+ |
+TEST_F(NetErrorTabHelperTest, MultipleProbesWithErrorPage) { |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(1, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE); |
+ CommitProvisionalLoad(MAIN_FRAME); |
+ EXPECT_EQ(2, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(3, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(4, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE); |
+ CommitProvisionalLoad(MAIN_FRAME); |
+ EXPECT_EQ(5, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(6, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET, sent_status()); |
+} |
+ |
+// If we see multiple errors in a row before a probe result, send STARTED for |
+// each error, but don't start multiple probes. |
+TEST_F(NetErrorTabHelperTest, CoalesceFailures) { |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(1, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(2, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE); |
+ FailProvisionalLoad(MAIN_FRAME, DNS_ERROR); |
+ EXPECT_EQ(1, probe_count()); |
+ EXPECT_EQ(3, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE); |
+ CommitProvisionalLoad(MAIN_FRAME); |
+ EXPECT_EQ(4, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, sent_status()); |
+ |
+ FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); |
+ EXPECT_EQ(0, probe_count()); |
+ EXPECT_EQ(5, sent_count()); |
+ EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, sent_status()); |
+} |