Display DNS probe results.

chrome/renderer/net/net_error_helper_unittest.cc

Index: chrome/renderer/net/net_error_helper_unittest.cc
diff --git a/chrome/renderer/net/net_error_helper_unittest.cc b/chrome/renderer/net/net_error_helper_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8c9043ad9663d3dc99ae6645844be8ff18ef8eb4
--- /dev/null
+++ b/chrome/renderer/net/net_error_helper_unittest.cc
@@ -0,0 +1,231 @@
+// 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/renderer/net/net_error_helper.h"
+
+#include "chrome/common/net/net_error_info.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using chrome_common_net::DnsProbeStatus;
+
+class TestNetErrorHelper : public NetErrorHelper {
+ public:
+  TestNetErrorHelper()
+      : NetErrorHelper(NULL),
+        mock_update_count_(0),
+        mock_update_status_(chrome_common_net::DNS_PROBE_MAX) {}
+
+  void StartLoad(bool is_main_frame, bool is_error_page) {
+    OnStartLoad(is_main_frame, is_error_page);
+  }
+
+  void FailLoad(bool is_main_frame, bool is_dns_error) {
+    OnFailLoad(is_main_frame, is_dns_error);
+  }
+
+  void CommitLoad(bool is_main_frame) {
+    OnCommitLoad(is_main_frame);
+  }
+
+  void FinishLoad(bool is_main_frame) {
+    OnFinishLoad(is_main_frame);
+  }
+
+  void ReceiveStatus(DnsProbeStatus status) {
+    OnNetErrorInfo(static_cast<int>(status));
+  }
+
+  int mock_update_count() const { return mock_update_count_;  }
+  DnsProbeStatus mock_update_status() const { return mock_update_status_; }
+
+ protected:
+  virtual void UpdateErrorPage() OVERRIDE {
+    mock_update_count_++;
+    mock_update_status_ = last_status_;
+  }
+
+ private:
+  int mock_update_count_;
+  DnsProbeStatus mock_update_status_;
+};
+
+class NetErrorHelperTest : public testing::Test {
+ protected:
+  enum MainFrame { SUB_FRAME, MAIN_FRAME };
+  enum ErrorPage { NORMAL_PAGE, ERROR_PAGE };
+  enum ErrorType { OTHER_ERROR, DNS_ERROR };
+
+  void StartLoad(MainFrame main_frame, ErrorPage error_page) {
+    helper_.StartLoad(main_frame == MAIN_FRAME, error_page == ERROR_PAGE);
+  }
+
+  void FailLoad(MainFrame main_frame, ErrorType error_type) {
+    helper_.FailLoad(main_frame == MAIN_FRAME, error_type == DNS_ERROR);
+  }
+
+  void CommitLoad(MainFrame main_frame) {
+    helper_.CommitLoad(main_frame == MAIN_FRAME);
+  }
+
+  void FinishLoad(MainFrame main_frame) {
+    helper_.FinishLoad(main_frame == MAIN_FRAME);
+  }
+
+  void ReceiveStatus(DnsProbeStatus status) {
+    helper_.ReceiveStatus(status);
+  }
+
+  int update_count() const { return helper_.mock_update_count(); }
+  DnsProbeStatus update_status() const { return helper_.mock_update_status(); }
+
+ private:
+  TestNetErrorHelper helper_;
+};
+
+TEST_F(NetErrorHelperTest, Null) {
+
+}
+
+TEST_F(NetErrorHelperTest, SuccessfulPageLoad) {
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  CommitLoad(MAIN_FRAME);
+  FinishLoad(MAIN_FRAME);
+
+  EXPECT_EQ(0, update_count());
+}
+
+TEST_F(NetErrorHelperTest, MainFrameNonDnsError) {
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailLoad(MAIN_FRAME, OTHER_ERROR);
+  StartLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitLoad(MAIN_FRAME);
+  FinishLoad(MAIN_FRAME);
+
+  ReceiveStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, update_count());
+}
+
+TEST_F(NetErrorHelperTest, SubFrameDnsError) {
+  StartLoad(SUB_FRAME, NORMAL_PAGE);
+  FailLoad(SUB_FRAME, DNS_ERROR);
+  StartLoad(SUB_FRAME, ERROR_PAGE);
+  CommitLoad(SUB_FRAME);
+  FinishLoad(SUB_FRAME);
+
+  ReceiveStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, update_count());
+}
+
+TEST_F(NetErrorHelperTest, ProbeResultBeforeStart) {
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailLoad(MAIN_FRAME, DNS_ERROR);
+
+  ReceiveStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  StartLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitLoad(MAIN_FRAME);
+  EXPECT_EQ(0, update_count());
+
+  FinishLoad(MAIN_FRAME);
+  EXPECT_EQ(1, update_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, update_status());
+}
+
+TEST_F(NetErrorHelperTest, ProbeResultBetweenStartAndCommit) {
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailLoad(MAIN_FRAME, DNS_ERROR);
+
+  StartLoad(MAIN_FRAME, ERROR_PAGE);
+  ReceiveStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  CommitLoad(MAIN_FRAME);
+  EXPECT_EQ(0, update_count());
+
+  FinishLoad(MAIN_FRAME);
+  EXPECT_EQ(1, update_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, update_status());
+}
+
+TEST_F(NetErrorHelperTest, ProbeResultBetweenCommitAndFinish) {
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailLoad(MAIN_FRAME, DNS_ERROR);
+
+  StartLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitLoad(MAIN_FRAME);
+  ReceiveStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, update_count());
+
+  FinishLoad(MAIN_FRAME);
+  EXPECT_EQ(1, update_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, update_status());
+}
+
+TEST_F(NetErrorHelperTest, ProbeResultAfterFinish) {
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailLoad(MAIN_FRAME, DNS_ERROR);
+  StartLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitLoad(MAIN_FRAME);
+  EXPECT_EQ(0, update_count());
+
+  FinishLoad(MAIN_FRAME);
+  EXPECT_EQ(1, update_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_POSSIBLE, update_status());
+
+  ReceiveStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(2, update_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, update_status());
+}
+
+TEST_F(NetErrorHelperTest, ProbeResultBetweenNewStartAndCommit) {
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailLoad(MAIN_FRAME, DNS_ERROR);
+  StartLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitLoad(MAIN_FRAME);
+  EXPECT_EQ(0, update_count());
+
+  FinishLoad(MAIN_FRAME);
+  EXPECT_EQ(1, update_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_POSSIBLE, update_status());
+
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  ReceiveStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(2, update_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN, update_status());
+
+  CommitLoad(MAIN_FRAME);
+  FinishLoad(MAIN_FRAME);
+}
+
+TEST_F(NetErrorHelperTest, ProbeResultBetweenNewCommitAndFinish) {
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailLoad(MAIN_FRAME, DNS_ERROR);
+  StartLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitLoad(MAIN_FRAME);
+  EXPECT_EQ(0, update_count());
+
+  FinishLoad(MAIN_FRAME);
+  EXPECT_EQ(1, update_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_POSSIBLE, update_status());
+
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  CommitLoad(MAIN_FRAME);
+  ReceiveStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  FinishLoad(MAIN_FRAME);
+  EXPECT_EQ(1, update_count());
+}
+TEST_F(NetErrorHelperTest, ProbeResultAfterNewFinish) {
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  FailLoad(MAIN_FRAME, DNS_ERROR);
+  StartLoad(MAIN_FRAME, ERROR_PAGE);
+  CommitLoad(MAIN_FRAME);
+  EXPECT_EQ(0, update_count());
+
+  FinishLoad(MAIN_FRAME);
+  EXPECT_EQ(1, update_count());
+  EXPECT_EQ(chrome_common_net::DNS_PROBE_POSSIBLE, update_status());
+
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  CommitLoad(MAIN_FRAME);
+  FinishLoad(MAIN_FRAME);
+  ReceiveStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(1, update_count());
+}