Display DNS probe results.

chrome/browser/net/net_error_tab_helper_unittest.cc

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..f70a81ce3d2f203102d01a01d826f2ee8817a9da
--- /dev/null
+++ b/chrome/browser/net/net_error_tab_helper_unittest.cc
@@ -0,0 +1,386 @@
+// 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),
+        running_probe_count_(0),
+        last_status_sent_(chrome_common_net::DNS_PROBE_MAX),
+        mock_sent_count_(0) {}
+
+  void FinishProbe(DnsProbeStatus status) {
+    OnDnsProbeFinished(status);
+    running_probe_count_--;
+  }
+
+  int running_probe_count() const { return running_probe_count_; }
+  DnsProbeStatus last_status_sent() const { return last_status_sent_; }
+  int mock_sent_count() const { return mock_sent_count_; }
+
+ private:
+  virtual void StartDnsProbe() OVERRIDE {
+    running_probe_count_++;

[mmenke, 2013/07/12 19:51:22]

Couldn't this just be a bool that we can assert is false here?

[Deprecated (see juliatuttle), 2013/07/12 20:55:55]

Sure.

+  }
+
+  virtual void SendInfo() OVERRIDE {
+    last_status_sent_ = dns_probe_status();
+    mock_sent_count_++;
+  }
+
+  int running_probe_count_;
+  DnsProbeStatus last_status_sent_;
+  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,

[mmenke, 2013/07/12 19:51:22]

nit:  Can we just pass in "string16()" instead?

[Deprecated (see juliatuttle), 2013/07/12 20:55:55]

Done.

+        NULL);  // render_view_host
+  }
+
+  void FinishProbe(DnsProbeStatus status) {
+    tab_helper_.FinishProbe(status);
+  }
+
+  int running_probe_count() { return tab_helper_.running_probe_count(); }
+  DnsProbeStatus last_status_sent() { return tab_helper_.last_status_sent(); }
+  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, running_probe_count());
+}
+
+TEST_F(NetErrorTabHelperTest, MainFrameNonDnsError) {
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, OTHER_ERROR);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+}
+
+TEST_F(NetErrorTabHelperTest, NonMainFrameDnsError) {
+  StartProvisionalLoad(SUB_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(SUB_FRAME, DNS_ERROR);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+}
+
+TEST_F(NetErrorTabHelperTest, ProbeResponseBeforeFirstCommit) {
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);

[mmenke, 2013/07/12 19:51:22]

Think it's worth mentioning double error page loads like this happen in the case
of the link doctor being enabled.

[Deprecated (see juliatuttle), 2013/07/12 20:55:55]

Done.

+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
+}
+
+TEST_F(NetErrorTabHelperTest, ProbeResponseBetweenFirstAndSecondCommit) {
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(3, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
+}
+
+TEST_F(NetErrorTabHelperTest, ProbeResponseAfterSecondCommit) {
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(3, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
+}
+
+// Send result even if we've started a new page load; the error page is still

[mmenke, 2013/07/12 19:51:22]

nit:  --we, per other comment.

[Deprecated (see juliatuttle), 2013/07/12 20:55:55]

Done.

+// 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, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+
+  FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(3, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
+}
+
+// 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, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+
+  FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+}
+
+TEST_F(NetErrorTabHelperTest, MultipleProbesWithoutErrorPage) {
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+}
+
+TEST_F(NetErrorTabHelperTest, MultipleProbesWithErrorPage) {

[mmenke, 2013/07/12 19:51:22]

nit:  Think the title could be clearer.  "TwoSequentialDnsErrorsWithProbes",
maybe?

[Deprecated (see juliatuttle), 2013/07/12 20:55:55]

Done.

+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(0, sent_count());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
+
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(3, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(4, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET,
+            last_status_sent());
+}
+
+// If we see multiple errors in a row before a probe result, don't start
+// multiple probes.
+TEST_F(NetErrorTabHelperTest, CoalesceFailures) {
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(1, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(2, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  StartProvisionalLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailProvisionalLoad(MAIN_FRAME, DNS_ERROR);
+  StartProvisionalLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitProvisionalLoad(MAIN_FRAME);
+  EXPECT_EQ(1, running_probe_count());
+  EXPECT_EQ(3, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, last_status_sent());
+
+  FinishProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, running_probe_count());
+  EXPECT_EQ(4, sent_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, last_status_sent());
+}