Revert 211950 "Display DNS probe results."

chrome/browser/net/net_error_tab_helper.cc

Index: chrome/browser/net/net_error_tab_helper.cc
===================================================================
--- chrome/browser/net/net_error_tab_helper.cc	(revision 212348)
+++ chrome/browser/net/net_error_tab_helper.cc	(working copy)
@@ -18,8 +18,7 @@
 #include "net/base/net_errors.h"
 
 using base::FieldTrialList;
-using chrome_common_net::DnsProbeStatus;
-using chrome_common_net::DnsProbeStatusToString;
+using chrome_common_net::DnsProbeResult;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::PageTransition;
@@ -33,6 +32,9 @@
 
 namespace {
 
+const char kDnsProbeFieldTrialName[] = "DnsProbe-Enable";
+const char kDnsProbeFieldTrialEnableGroupName[] = "enable";
+
 static NetErrorTabHelper::TestingState testing_state_ =
     NetErrorTabHelper::TESTING_DEFAULT;
 
@@ -43,24 +45,48 @@
          net_error == net::ERR_NAME_RESOLUTION_FAILED;
 }
 
+bool GetEnabledByTrial() {
+  return (FieldTrialList::FindFullName(kDnsProbeFieldTrialName)
+          == kDnsProbeFieldTrialEnableGroupName);
+}
+
+NetErrorTracker::FrameType GetFrameType(bool is_main_frame) {
+  return is_main_frame ? NetErrorTracker::FRAME_MAIN
+                       : NetErrorTracker::FRAME_SUB;
+}
+
+NetErrorTracker::PageType GetPageType(bool is_error_page) {
+  return is_error_page ? NetErrorTracker::PAGE_ERROR
+                       : NetErrorTracker::PAGE_NORMAL;
+}
+
+NetErrorTracker::ErrorType GetErrorType(int net_error) {
+  return IsDnsError(net_error) ? NetErrorTracker::ERROR_DNS
+                               : NetErrorTracker::ERROR_OTHER;
+}
+
 void OnDnsProbeFinishedOnIOThread(
-    const base::Callback<void(DnsProbeStatus)>& callback,
-    DnsProbeStatus result) {
+    const base::Callback<void(DnsProbeResult)>& callback,
+    DnsProbeResult result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  DVLOG(1) << "DNS probe finished with result " << result;
+
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(callback, result));
 }
 
-// Can only access g_browser_process->io_thread() from the browser thread,
-// so have to pass it in to the callback instead of dereferencing it here.
+// We can only access g_browser_process->io_thread() from the browser thread,
+// so we have to pass it in to the callback instead of dereferencing it here.
 void StartDnsProbeOnIOThread(
-    const base::Callback<void(DnsProbeStatus)>& callback,
+    const base::Callback<void(DnsProbeResult)>& callback,
     IOThread* io_thread) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  DVLOG(1) << "Starting DNS probe";
+
   DnsProbeService* probe_service =
       io_thread->globals()->dns_probe_service.get();
 
@@ -87,10 +113,8 @@
     RenderViewHost* render_view_host) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (!is_main_frame)
-    return;
-
-  is_error_page_ = is_error_page;
+  tracker_.OnStartProvisionalLoad(GetFrameType(is_main_frame),
+                                  GetPageType(is_error_page));
 }
 
 void NetErrorTabHelper::DidCommitProvisionalLoadForFrame(
@@ -101,21 +125,7 @@
     RenderViewHost* render_view_host) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (!is_main_frame)
-    return;
-
-  // Resend status every time an error page commits; this is somewhat spammy,
-  // but ensures that the status will make it to the real error page, even if
-  // the link doctor loads a blank intermediate page or the tab switches
-  // renderer processes.
-  if (is_error_page_ && dns_error_active_) {
-    dns_error_page_committed_ = true;
-    DVLOG(1) << "Committed error page; resending status.";
-    SendInfo();
-  } else {
-    dns_error_active_ = false;
-    dns_error_page_committed_ = false;
-  }
+  tracker_.OnCommitProvisionalLoad(GetFrameType(is_main_frame));
 }
 
 void NetErrorTabHelper::DidFailProvisionalLoad(
@@ -127,70 +137,75 @@
     RenderViewHost* render_view_host) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (!is_main_frame)
-    return;
+  tracker_.OnFailProvisionalLoad(GetFrameType(is_main_frame),
+                                 GetErrorType(error_code));
+}
 
-  if (IsDnsError(error_code)) {
-    dns_error_active_ = true;
-    OnMainFrameDnsError();
-  }
+void NetErrorTabHelper::DidFinishLoad(
+    int64 frame_id,
+    const GURL& validated_url,
+    bool is_main_frame,
+    RenderViewHost* render_view_host) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  tracker_.OnFinishLoad(GetFrameType(is_main_frame));
 }
 
 NetErrorTabHelper::NetErrorTabHelper(WebContents* contents)
     : WebContentsObserver(contents),
       weak_factory_(this),
-      is_error_page_(false),
-      dns_error_active_(false),
-      dns_error_page_committed_(false),
-      dns_probe_status_(chrome_common_net::DNS_PROBE_POSSIBLE),
-      enabled_by_trial_(chrome_common_net::DnsProbesEnabledByFieldTrial()) {
+      tracker_(base::Bind(&NetErrorTabHelper::TrackerCallback,
+                          weak_factory_.GetWeakPtr())),
+      dns_error_page_state_(NetErrorTracker::DNS_ERROR_PAGE_NONE),
+      dns_probe_state_(DNS_PROBE_NONE),
+      enabled_by_trial_(GetEnabledByTrial()) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // If this helper is under test, it won't have a WebContents.
-  if (contents)
-    InitializePref(contents);
+  InitializePref(contents);
 }
 
-void NetErrorTabHelper::OnMainFrameDnsError() {
-  if (ProbesAllowed()) {
-    // Don't start more than one probe at a time.
-    if (dns_probe_status_ != chrome_common_net::DNS_PROBE_STARTED) {
-      StartDnsProbe();
-      dns_probe_status_ = chrome_common_net::DNS_PROBE_STARTED;
-    }
-  } else {
-    dns_probe_status_ = chrome_common_net::DNS_PROBE_NOT_RUN;
-  }
+void NetErrorTabHelper::TrackerCallback(
+    NetErrorTracker::DnsErrorPageState state) {
+  dns_error_page_state_ = state;
+
+  MaybePostStartDnsProbeTask();
+  MaybeSendInfo();
 }
 
-void NetErrorTabHelper::StartDnsProbe() {
+void NetErrorTabHelper::MaybePostStartDnsProbeTask() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(dns_error_active_);
-  DCHECK_NE(chrome_common_net::DNS_PROBE_STARTED, dns_probe_status_);
 
-  DVLOG(1) << "Starting DNS probe.";
-
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&StartDnsProbeOnIOThread,
-                 base::Bind(&NetErrorTabHelper::OnDnsProbeFinished,
-                            weak_factory_.GetWeakPtr()),
-                 g_browser_process->io_thread()));
+  if (dns_error_page_state_ != NetErrorTracker::DNS_ERROR_PAGE_NONE &&
+      dns_probe_state_ != DNS_PROBE_STARTED &&
+      ProbesAllowed()) {
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&StartDnsProbeOnIOThread,
+                   base::Bind(&NetErrorTabHelper::OnDnsProbeFinished,
+                              weak_factory_.GetWeakPtr()),
+                   g_browser_process->io_thread()));
+    dns_probe_state_ = DNS_PROBE_STARTED;
+  }
 }
 
-void NetErrorTabHelper::OnDnsProbeFinished(DnsProbeStatus result) {
+void NetErrorTabHelper::OnDnsProbeFinished(DnsProbeResult result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(chrome_common_net::DNS_PROBE_STARTED, dns_probe_status_);
-  DCHECK(chrome_common_net::DnsProbeStatusIsFinished(result));
+  DCHECK_EQ(DNS_PROBE_STARTED, dns_probe_state_);
 
-  DVLOG(1) << "Finished DNS probe with result "
-           << DnsProbeStatusToString(result) << ".";
+  dns_probe_result_ = result;
+  dns_probe_state_ = DNS_PROBE_FINISHED;
 
-  dns_probe_status_ = result;
+  MaybeSendInfo();
+}
 
-  if (dns_error_page_committed_)
-    SendInfo();
+void NetErrorTabHelper::MaybeSendInfo() {
+  if (dns_error_page_state_ == NetErrorTracker::DNS_ERROR_PAGE_LOADED &&
+      dns_probe_state_ == DNS_PROBE_FINISHED) {
+    DVLOG(1) << "Sending result " << dns_probe_result_ << " to renderer";
+    Send(new ChromeViewMsg_NetErrorInfo(routing_id(), dns_probe_result_));
+    dns_probe_state_ = DNS_PROBE_NONE;
+  }
 }
 
 void NetErrorTabHelper::InitializePref(WebContents* contents) {
@@ -211,15 +226,4 @@
   return enabled_by_trial_ && *resolve_errors_with_web_service_;
 }
 
-void NetErrorTabHelper::SendInfo() {
-  DCHECK_NE(chrome_common_net::DNS_PROBE_POSSIBLE, dns_probe_status_);
-  DCHECK(dns_error_page_committed_);
-
-  DVLOG(1) << "Sending status " << DnsProbeStatusToString(dns_probe_status_);
-  Send(new ChromeViewMsg_NetErrorInfo(routing_id(), dns_probe_status_));
-
-  if (!dns_probe_status_snoop_callback_.is_null())
-    dns_probe_status_snoop_callback_.Run(dns_probe_status_);
-}
-
 }  // namespace chrome_browser_net