Display DNS probe results.

chrome/renderer/net/net_error_helper_unittest.cc

+// 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 "base/logging.h"
+#include "chrome/common/net/net_error_info.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using chrome_common_net::DnsProbeStatus;
+using chrome_common_net::DnsProbeStatusToString;
+
+enum TestStep {
+  LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START,
+  LOAD_COMMIT, LOAD_FINISH,
+
+  STATUS_STARTED, STATUS_NOT_RUN, STATUS_FINISHED,
+
+  EXPECT_UPDATE

[mmenke, 2013/07/12 16:14:48]

Think some comments are needed.  A detailed one for EXPECT_UPDATE.  Other two
groups can just have one short comment each.

[Deprecated (see juliatuttle), 2013/07/12 17:42:49]

Done.

+};
+
+class TestNetErrorHelper : public NetErrorHelper {
+ public:
+  TestNetErrorHelper()
+      : NetErrorHelper(NULL),
+        mock_page_update_count_(0),
+        mock_displayed_probe_status_(chrome_common_net::DNS_PROBE_MAX) {}
+
+  virtual ~TestNetErrorHelper() {}
+
+  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 ReceiveProbeStatus(DnsProbeStatus status) {
+    OnNetErrorInfo(static_cast<int>(status));
+  }
+
+  int mock_page_update_count() const { return mock_page_update_count_;  }
+  DnsProbeStatus mock_displayed_probe_status() const {
+    return mock_displayed_probe_status_;
+  }
+
+ protected:
+  virtual void UpdateErrorPage() OVERRIDE {
+    DVLOG(1) << "Updating error page with status "
+             << DnsProbeStatusToString(last_probe_status_);
+    mock_page_update_count_++;
+    mock_displayed_probe_status_ = last_probe_status_;
+  }
+
+ private:
+  int mock_page_update_count_;
+  DnsProbeStatus mock_displayed_probe_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 ReceiveProbeStatus(DnsProbeStatus status) {
+    helper_.ReceiveProbeStatus(status);
+  }
+
+  void RunTest(const TestStep steps[], int step_count);
+
+  int page_update_count() const { return helper_.mock_page_update_count(); }
+  DnsProbeStatus displayed_probe_status() const {
+    return helper_.mock_displayed_probe_status();
+  }
+
+ private:
+  TestNetErrorHelper helper_;
+};
+
+void NetErrorHelperTest::RunTest(const TestStep steps[], int step_count) {
+  bool update_expected = false;

[mmenke, 2013/07/12 16:14:48]

Think this is worth a comment.

[Deprecated (see juliatuttle), 2013/07/12 17:42:49]

Done.

+  int update_count = page_update_count();

[mmenke, 2013/07/12 16:14:48]

expected_updated_count?

[Deprecated (see juliatuttle), 2013/07/12 17:42:49]

Done.

+  chrome_common_net::DnsProbeStatus last_status_received =
+      chrome_common_net::DNS_PROBE_POSSIBLE;
+
+  for (int i = 0; i < step_count; i++) {
+    switch (steps[i]) {
+    case LOAD_NORMAL_START:
+      StartLoad(MAIN_FRAME, NORMAL_PAGE);
+      break;
+    case LOAD_NORMAL_FAIL:
+      FailLoad(MAIN_FRAME, DNS_ERROR);
+      break;
+    case LOAD_ERROR_START:
+      StartLoad(MAIN_FRAME, ERROR_PAGE);
+      break;
+    case LOAD_COMMIT:
+      CommitLoad(MAIN_FRAME);
+      break;
+    case LOAD_FINISH:
+      FinishLoad(MAIN_FRAME);
+      break;
+    case STATUS_STARTED:
+      ReceiveProbeStatus(chrome_common_net::DNS_PROBE_STARTED);
+      last_status_received = chrome_common_net::DNS_PROBE_STARTED;
+      break;
+    case STATUS_NOT_RUN:
+      ReceiveProbeStatus(chrome_common_net::DNS_PROBE_NOT_RUN);
+      last_status_received = chrome_common_net::DNS_PROBE_NOT_RUN;
+      break;
+    case STATUS_FINISHED:
+      ReceiveProbeStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+      last_status_received = chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN;
+      break;
+    case EXPECT_UPDATE:
+      // EXPECT_UPDATE acts as an instruction prefix that declares that the
+      // next instruction should cause an update.
+      DCHECK(!update_expected);

[mmenke, 2013/07/12 16:14:48]

DCHECKs shouldn't be used in tests.  Think we're fine just using EXPECT on
these.

[Deprecated (see juliatuttle), 2013/07/12 17:42:49]

EXPECT doesn't make sense to me -- if this DCHECK fails, it means that someone
provided an erroneous test case, not that the test failed.

[mmenke, 2013/07/12 18:02:12]

DCHECKs are not run by trybots, by default.  Also, if a DCHECK fails, all other
tests, and whatever information they may have provided, is lost.

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

Alright, changed to an ASSERT.

+      break;
+    }
+
+    if (steps[i] == EXPECT_UPDATE) {
+      update_expected = true;
+    } else if (update_expected) {
+      DCHECK_NE(chrome_common_net::DNS_PROBE_POSSIBLE, last_status_received);
+      ++update_count;
+      EXPECT_EQ(update_count, page_update_count());
+      EXPECT_EQ(last_status_received, displayed_probe_status());

[mmenke, 2013/07/12 16:14:48]

Think there should be a comment about this somewhere (Either here, or where
last_status_received is declared, or where update_expected is declared).

[Deprecated (see juliatuttle), 2013/07/12 17:42:49]

Done.

+      update_expected = false;
+
+      if (page_update_count() != update_count) {
+        LOG(ERROR) << "Missing update at step " << i << ".";
+        return;
+      }
+    } else {
+      EXPECT_EQ(update_count, page_update_count());
+
+      if (page_update_count() != update_count) {
+        LOG(ERROR) << "Spurious update at step " << i << ".";
+        return;
+      }

[mmenke, 2013/07/12 16:14:48]

nit:  Can you just share this code with the update_expected case?  I don't think
we get much from separating them out.

[Deprecated (see juliatuttle), 2013/07/12 17:42:49]

Done.

+    }
+  }
+
+  DCHECK(!update_expected);
+}
+
+TEST_F(NetErrorHelperTest, Null) {
+  // Test that we can simply create and destroy a NetErrorHelper.
+}
+
+TEST_F(NetErrorHelperTest, SuccessfulPageLoad) {
+  StartLoad(MAIN_FRAME, NORMAL_PAGE);
+  CommitLoad(MAIN_FRAME);
+  FinishLoad(MAIN_FRAME);
+
+  // Ignore spurious status.
+  ReceiveProbeStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, page_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);
+
+  // Ignore spurious status.
+  ReceiveProbeStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, page_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);
+
+  // Ignore spurious status.
+  ReceiveProbeStatus(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
+  EXPECT_EQ(0, page_update_count());
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterFail) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_FINISHED, LOAD_ERROR_START,
+    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterFail_StartedAfterFail) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, STATUS_FINISHED,
+    LOAD_ERROR_START, LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterStart) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, STATUS_FINISHED,
+    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterStart_StartedAfterFail) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
+    STATUS_FINISHED, LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterStart_StartedAfterStart) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
+    STATUS_FINISHED, LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterCommit) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
+    STATUS_FINISHED, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterCommit_StartedAfterFail) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
+    LOAD_COMMIT, STATUS_FINISHED, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterCommit_StartedAfterStart) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, STATUS_STARTED,
+    LOAD_ERROR_START, LOAD_COMMIT, STATUS_FINISHED, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterCommit_StartedAfterCommit) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
+    STATUS_STARTED, STATUS_FINISHED, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterFinish) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
+    LOAD_FINISH, EXPECT_UPDATE, STATUS_FINISHED
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterFinish_StartAfterFail) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
+    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH, EXPECT_UPDATE, STATUS_FINISHED
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterFinish_StartAfterStart) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, STATUS_STARTED,
+    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH, EXPECT_UPDATE, STATUS_FINISHED
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterFinish_StartAfterCommit) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
+    STATUS_STARTED, EXPECT_UPDATE, LOAD_FINISH, EXPECT_UPDATE, STATUS_FINISHED
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterFinish_StartAfterFinish) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
+    LOAD_FINISH, EXPECT_UPDATE, STATUS_STARTED, EXPECT_UPDATE, STATUS_FINISHED
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterNewStart) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
+    LOAD_FINISH, LOAD_NORMAL_START, EXPECT_UPDATE, STATUS_FINISHED,
+    LOAD_COMMIT, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, NotRunAfterFail) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_NOT_RUN, LOAD_ERROR_START,
+    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, NotRunAfterStart) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, STATUS_NOT_RUN,
+    LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, NotRunAfterCommit) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
+    STATUS_NOT_RUN, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, NotRunAfterFinish) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
+    LOAD_FINISH, EXPECT_UPDATE, STATUS_NOT_RUN
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterNewCommit) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
+    LOAD_FINISH, LOAD_NORMAL_START, LOAD_COMMIT, STATUS_FINISHED, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+TEST_F(NetErrorHelperTest, FinishedAfterNewFinish) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, LOAD_ERROR_START, LOAD_COMMIT,
+    LOAD_FINISH, LOAD_NORMAL_START, LOAD_COMMIT, LOAD_FINISH, STATUS_FINISHED
+  };
+  RunTest(steps, arraysize(steps));
+}
+
+// Two iterations of FinishedAfterStart_StartAfterFail
+TEST_F(NetErrorHelperTest, TwoProbes) {
+  const TestStep steps[] = {
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
+    STATUS_FINISHED, LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH,
+    LOAD_NORMAL_START, LOAD_NORMAL_FAIL, STATUS_STARTED, LOAD_ERROR_START,
+    STATUS_FINISHED, LOAD_COMMIT, EXPECT_UPDATE, LOAD_FINISH
+  };
+  RunTest(steps, arraysize(steps));
+}