Unify browser- and renderer- side logic for new DNS error pages

Create a new NetErrorTracker (TODO: better name?) that can be used on the browser and renderer side to watch the Start/Commit/Fail/Finish events and tell whether a tab or renderer is currently displaying a DNS error page.

This will be used immediately for the new NetErrorHelper (the renderer-side RenderViewObserver that receives the NetErrorInfo IPC from the browser-side NetErrorTabHelper); in a later CL, I'll convert NetErrorTabHelper to use it as well.

BUG=156415


Review URL: https://chromiumcodereview.appspot.com/12223098

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@182556 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 234 insertions, 0 deletions

diff --git a/chrome/chrome_common.gypi b/chrome/chrome_common.gypi
index 16ba699..4877e2d 100644
--- a/chrome/chrome_common.gypi
+++ b/chrome/chrome_common.gypi
@@ -608,6 +608,8 @@
       'target_name': 'common_net',
       'type': 'static_library',
       'sources': [
+        'common/net/net_error_tracker.cc',
+        'common/net/net_error_tracker.h',
         'common/net/net_resource_provider.cc',
         'common/net/net_resource_provider.h',
         'common/net/predictor_common.h',
diff --git a/chrome/chrome_tests_unit.gypi b/chrome/chrome_tests_unit.gypi
index a942574..3651b06 100644
--- a/chrome/chrome_tests_unit.gypi
+++ b/chrome/chrome_tests_unit.gypi
@@ -1565,6 +1565,7 @@
         'common/metrics/metrics_util_unittest.cc',
         'common/metrics/variations/variations_util_unittest.cc',
         'common/multi_process_lock_unittest.cc',
+        'common/net/net_error_tracker_unittest.cc',
         'common/net/x509_certificate_model_unittest.cc',
         'common/pref_names_util_unittest.cc',
         'common/service_process_util_unittest.cc',
diff --git a/chrome/common/net/net_error_tracker.cc b/chrome/common/net/net_error_tracker.cc
new file mode 100644
index 0000000..6cf69ca
--- /dev/null
+++ b/chrome/common/net/net_error_tracker.cc
@@ -0,0 +1,66 @@
+// 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/common/net/net_error_tracker.h"
+
+NetErrorTracker::NetErrorTracker(const Callback& callback)
+    : callback_(callback),
+      load_state_(LOAD_NONE),
+      load_type_(PAGE_NORMAL),
+      error_type_(ERROR_OTHER),
+      dns_error_page_state_(DNS_ERROR_PAGE_NONE) {
+}
+
+NetErrorTracker::~NetErrorTracker() {
+}
+
+void NetErrorTracker::OnStartProvisionalLoad(FrameType frame, PageType page) {
+  if (frame == FRAME_SUB)
+    return;
+
+  load_state_ = LOAD_STARTED;
+  load_type_ = page;
+
+  // TODO(ttuttle): Add support for aborts, then move this to OnCommit.
+  if (load_type_ == PAGE_NORMAL)
+    SetDnsErrorPageState(DNS_ERROR_PAGE_NONE);
+}
+
+void NetErrorTracker::OnCommitProvisionalLoad(FrameType frame) {
+  if (frame == FRAME_SUB)
+    return;
+
+  load_state_ = LOAD_COMMITTED;
+}
+
+void NetErrorTracker::OnFailProvisionalLoad(FrameType frame, ErrorType error) {
+  if (frame == FRAME_SUB)
+    return;
+
+  load_state_ = LOAD_FAILED;
+
+  if (load_type_ == PAGE_NORMAL) {
+    error_type_ = error;
+    if (error_type_ == ERROR_DNS)
+      SetDnsErrorPageState(DNS_ERROR_PAGE_PENDING);
+  }
+}
+
+void NetErrorTracker::OnFinishLoad(FrameType frame) {
+  if (frame == FRAME_SUB)
+    return;
+
+  load_state_ = LOAD_FINISHED;
+
+  if (load_type_ == PAGE_ERROR && error_type_ == ERROR_DNS)
+    SetDnsErrorPageState(DNS_ERROR_PAGE_LOADED);
+}
+
+void NetErrorTracker::SetDnsErrorPageState(DnsErrorPageState state) {
+  if (state == dns_error_page_state_)
+    return;
+
+  dns_error_page_state_ = state;
+  callback_.Run(state);
+}
diff --git a/chrome/common/net/net_error_tracker.h b/chrome/common/net/net_error_tracker.h
new file mode 100644
index 0000000..530abcb
--- /dev/null
+++ b/chrome/common/net/net_error_tracker.h
@@ -0,0 +1,66 @@
+// 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.
+
+#ifndef CHROME_COMMON_NET_NET_ERROR_TRACKER_H_
+#define CHROME_COMMON_NET_NET_ERROR_TRACKER_H_
+
+#include "base/bind.h"
+
+class NetErrorTracker {
+ public:
+  enum FrameType {
+    FRAME_SUB,
+    FRAME_MAIN
+  };
+
+  enum PageType {
+    PAGE_NORMAL,
+    PAGE_ERROR
+  };
+
+  enum ErrorType {
+    ERROR_OTHER,
+    ERROR_DNS
+  };
+
+  enum DnsErrorPageState {
+    DNS_ERROR_PAGE_NONE,
+    DNS_ERROR_PAGE_PENDING,
+    DNS_ERROR_PAGE_LOADED
+  };
+
+  typedef base::Callback<void(DnsErrorPageState state)> Callback;
+
+  explicit NetErrorTracker(const Callback& callback);
+  ~NetErrorTracker();
+
+  void OnStartProvisionalLoad(FrameType frame, PageType page);
+  void OnCommitProvisionalLoad(FrameType frame);
+  void OnFailProvisionalLoad(FrameType frame, ErrorType error);
+  void OnFinishLoad(FrameType frame);
+
+ private:
+  enum LoadState {
+    LOAD_NONE,
+    LOAD_STARTED,
+    LOAD_COMMITTED,
+    LOAD_FAILED,
+    LOAD_FINISHED
+  };
+
+  void SetDnsErrorPageState(DnsErrorPageState state);
+
+  Callback callback_;
+
+  LoadState load_state_;
+  PageType load_type_;
+
+  ErrorType error_type_;
+
+  DnsErrorPageState dns_error_page_state_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetErrorTracker);
+};
+
+#endif  // CHROME_COMMON_NET_NET_ERROR_TRACKER_H_
diff --git a/chrome/common/net/net_error_tracker_unittest.cc b/chrome/common/net/net_error_tracker_unittest.cc
new file mode 100644
index 0000000..b54360e
--- /dev/null
+++ b/chrome/common/net/net_error_tracker_unittest.cc
@@ -0,0 +1,99 @@
+// 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/common/net/net_error_tracker.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+typedef NetErrorTracker::FrameType FrameType;
+typedef NetErrorTracker::PageType PageType;
+typedef NetErrorTracker::ErrorType ErrorType;
+
+const FrameType FRAME_SUB = NetErrorTracker::FRAME_SUB;
+const FrameType FRAME_MAIN = NetErrorTracker::FRAME_MAIN;
+
+const PageType PAGE_NORMAL = NetErrorTracker::PAGE_NORMAL;
+const PageType PAGE_ERROR = NetErrorTracker::PAGE_ERROR;
+
+const ErrorType ERROR_OTHER = NetErrorTracker::ERROR_OTHER;
+const ErrorType ERROR_DNS = NetErrorTracker::ERROR_DNS;
+
+class NetErrorTrackerTest : public testing::Test {
+ public:
+  NetErrorTrackerTest()
+      : ALLOW_THIS_IN_INITIALIZER_LIST(tracker_(
+            base::Bind(&NetErrorTrackerTest::TrackerCallback,
+                       base::Unretained(this)))),
+        callback_state_(NetErrorTracker::DNS_ERROR_PAGE_NONE),
+        callback_count_(0) {
+  }
+
+ protected:
+  NetErrorTracker tracker_;
+  NetErrorTracker::DnsErrorPageState callback_state_;
+  int callback_count_;
+
+ private:
+  void TrackerCallback(NetErrorTracker::DnsErrorPageState state) {
+    callback_state_ = state;
+    ++callback_count_;
+  }
+};
+
+TEST_F(NetErrorTrackerTest, InitialState) {
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(NetErrorTracker::DNS_ERROR_PAGE_NONE, callback_state_);
+}
+
+TEST_F(NetErrorTrackerTest, SuccessfulMainFrameLoad) {
+  tracker_.OnStartProvisionalLoad(FRAME_MAIN, PAGE_NORMAL);
+  tracker_.OnCommitProvisionalLoad(FRAME_MAIN);
+  tracker_.OnFinishLoad(FRAME_MAIN);
+
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(NetErrorTracker::DNS_ERROR_PAGE_NONE, callback_state_);
+}
+
+TEST_F(NetErrorTrackerTest, SuccessfulSubFrameLoad) {
+  tracker_.OnStartProvisionalLoad(FRAME_SUB, PAGE_NORMAL);
+  tracker_.OnCommitProvisionalLoad(FRAME_SUB);
+  tracker_.OnFinishLoad(FRAME_SUB);
+
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(NetErrorTracker::DNS_ERROR_PAGE_NONE, callback_state_);
+}
+
+TEST_F(NetErrorTrackerTest, FailedMainFrameLoad) {
+  tracker_.OnStartProvisionalLoad(FRAME_MAIN, PAGE_NORMAL);
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(NetErrorTracker::DNS_ERROR_PAGE_NONE, callback_state_);
+
+  tracker_.OnFailProvisionalLoad(FRAME_MAIN, ERROR_DNS);
+  EXPECT_EQ(1, callback_count_);
+  EXPECT_EQ(NetErrorTracker::DNS_ERROR_PAGE_PENDING, callback_state_);
+
+  tracker_.OnStartProvisionalLoad(FRAME_MAIN, PAGE_ERROR);
+  tracker_.OnCommitProvisionalLoad(FRAME_MAIN);
+  tracker_.OnFinishLoad(FRAME_MAIN);
+  EXPECT_EQ(2, callback_count_);
+  EXPECT_EQ(NetErrorTracker::DNS_ERROR_PAGE_LOADED, callback_state_);
+
+  tracker_.OnStartProvisionalLoad(FRAME_MAIN, PAGE_NORMAL);
+  EXPECT_EQ(3, callback_count_);
+  EXPECT_EQ(NetErrorTracker::DNS_ERROR_PAGE_NONE, callback_state_);
+}
+
+TEST_F(NetErrorTrackerTest, FailedSubFrameLoad) {
+  tracker_.OnStartProvisionalLoad(FRAME_SUB, PAGE_NORMAL);
+  tracker_.OnFailProvisionalLoad(FRAME_SUB, ERROR_DNS);
+  tracker_.OnStartProvisionalLoad(FRAME_SUB, PAGE_ERROR);
+  tracker_.OnCommitProvisionalLoad(FRAME_SUB);
+  tracker_.OnFinishLoad(FRAME_SUB);
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(NetErrorTracker::DNS_ERROR_PAGE_NONE, callback_state_);
+}
+
+}  // namespace