BackoffEntry is used to compute timeouts between consecutive captive portal checks.

chrome/browser/chromeos/net/network_portal_detector_impl.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/browser/chromeos/net/network_portal_detector_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 15 matching lines @@
 
 using captive_portal::CaptivePortalDetector;
 
 namespace chromeos {
 
 namespace {
 
 // Delay before portal detection caused by changes in proxy settings.
 const int kProxyChangeDelaySec = 1;
 
+// Maximum number of reports from captive portal detector about
+// offline state in a row before notification is sent to observers.
+const int kMaxOfflineResultsBeforeReport = 3;
+
 const NetworkState* DefaultNetwork() {
   return NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
 }
 
 bool InSession() {
   return LoginState::IsInitialized() && LoginState::Get()->IsUserLoggedIn();
 }
 
 void RecordDetectionResult(NetworkPortalDetector::CaptivePortalStatus status) {
   if (InSession()) {
@@ skipping 149 matching lines @@
     set_network_portal_detector(new NetworkPortalDetectorStubImpl());
   else
     set_network_portal_detector(new NetworkPortalDetectorImpl(url_context));
 }
 
 NetworkPortalDetectorImpl::NetworkPortalDetectorImpl(
     const scoped_refptr<net::URLRequestContextGetter>& request_context)
     : state_(STATE_IDLE),
       test_url_(CaptivePortalDetector::kDefaultURL),
       enabled_(false),
-      attempt_count_(0),
       strategy_(PortalDetectorStrategy::CreateById(
           PortalDetectorStrategy::STRATEGY_ID_LOGIN_SCREEN)),
+      last_detection_result_(CAPTIVE_PORTAL_STATUS_UNKNOWN),
+      same_detection_result_count_(0),
+      no_response_result_count_(0),
       weak_factory_(this) {
   captive_portal_detector_.reset(new CaptivePortalDetector(request_context));
   strategy_->set_delegate(this);
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_PROXY_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTH_SUPPLIED,
                  content::NotificationService::AllSources());
@@ skipping 119 matching lines @@
   VLOG(1) << "DefaultNetworkChanged: "
           << "name=" << default_network_name_ << ", "
           << "id=" << default_network_id_ << ", "
           << "state=" << default_connection_state_ << ", "
           << "changed=" << network_changed << ", "
           << "state_changed=" << connection_state_changed;
 
   if (network_changed || connection_state_changed)
     StopDetection();
 
-  if (CanPerformAttempt() &&
-      NetworkState::StateIsConnected(default_connection_state_)) {
+  if (is_idle() && NetworkState::StateIsConnected(default_connection_state_)) {
     // Initiate Captive Portal detection if network's captive
     // portal state is unknown (e.g. for freshly created networks),
     // offline or if network connection state was changed.
     CaptivePortalState state = GetCaptivePortalState(default_network->guid());
     if (state.status == CAPTIVE_PORTAL_STATUS_UNKNOWN ||
         state.status == CAPTIVE_PORTAL_STATUS_OFFLINE ||
         (!network_changed && connection_state_changed)) {
       ScheduleAttempt(base::TimeDelta());
     }
   }
 }
 
-int NetworkPortalDetectorImpl::AttemptCount() { return attempt_count_; }
+int NetworkPortalDetectorImpl::NoResponseResultCount() {
+  return no_response_result_count_;
+}
 
 base::TimeTicks NetworkPortalDetectorImpl::AttemptStartTime() {
   return attempt_start_time_;
 }
 
 base::TimeTicks NetworkPortalDetectorImpl::GetCurrentTimeTicks() {
   if (time_ticks_for_testing_.is_null())
     return base::TimeTicks::Now();
   return time_ticks_for_testing_;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkPortalDetectorImpl, private:
 
 void NetworkPortalDetectorImpl::StartDetection() {
-  attempt_count_ = 0;
-  DCHECK(CanPerformAttempt());
+  DCHECK(is_idle());
+
+  ResetStrategyAndCounters();
   detection_start_time_ = GetCurrentTimeTicks();
   ScheduleAttempt(base::TimeDelta());
 }
 
 void NetworkPortalDetectorImpl::StopDetection() {
   attempt_task_.Cancel();
   attempt_timeout_.Cancel();
   captive_portal_detector_->Cancel();
   state_ = STATE_IDLE;
-  attempt_count_ = 0;
-}
-
-bool NetworkPortalDetectorImpl::CanPerformAttempt() const {
-  return is_idle() && strategy_->CanPerformAttempt();
+  ResetStrategyAndCounters();
 }
 
 void NetworkPortalDetectorImpl::ScheduleAttempt(const base::TimeDelta& delay) {
-  DCHECK(CanPerformAttempt());
+  DCHECK(is_idle());
 
   if (!IsEnabled())
     return;
 
   attempt_task_.Cancel();
   attempt_timeout_.Cancel();
   state_ = STATE_PORTAL_CHECK_PENDING;
 
   next_attempt_delay_ = std::max(delay, strategy_->GetDelayTillNextAttempt());
   attempt_task_.Reset(base::Bind(&NetworkPortalDetectorImpl::StartAttempt,
@@ skipping 30 matching lines @@
           << "id=" << default_network_id_;
 
   captive_portal_detector_->Cancel();
   CaptivePortalDetector::Results results;
   results.result = captive_portal::RESULT_NO_RESPONSE;
   OnAttemptCompleted(results);
 }
 
 void NetworkPortalDetectorImpl::OnAttemptCompleted(
     const CaptivePortalDetector::Results& results) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(is_checking_for_portal());
+
   captive_portal::CaptivePortalResult result = results.result;
   int response_code = results.response_code;
 
-  DCHECK(CalledOnValidThread());
-  DCHECK(is_checking_for_portal());
-
-  DetectionAttemptCompletedReport attempt_completed_report(
-      default_network_name_,
-      default_network_id_,
-      results.result,
-      results.response_code);
-  if (!attempt_completed_report_.Equals(attempt_completed_report)) {
-    attempt_completed_report_ = attempt_completed_report;
-    attempt_completed_report_.Report();
-  }
-
-  state_ = STATE_IDLE;
-  attempt_timeout_.Cancel();
-  ++attempt_count_;
-
   const NetworkState* network = DefaultNetwork();
 
   // If using a fake profile client, also fake being behind a captive portal
   // if the default network is in portal state.
   if (result != captive_portal::RESULT_NO_RESPONSE &&
       DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface() &&
       network && network->connection_state() == shill::kStatePortal) {
     result = captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL;
     response_code = 200;
   }
 
+  DetectionAttemptCompletedReport attempt_completed_report(
+      default_network_name_, default_network_id_, result, response_code);
+  if (!attempt_completed_report_.Equals(attempt_completed_report)) {
+    attempt_completed_report_ = attempt_completed_report;
+    attempt_completed_report_.Report();
+  }
+
+  state_ = STATE_IDLE;
+  attempt_timeout_.Cancel();
+
   CaptivePortalState state;
   state.response_code = response_code;
   state.time = GetCurrentTimeTicks();
   switch (result) {
     case captive_portal::RESULT_NO_RESPONSE:
-      if (CanPerformAttempt()) {
-        ScheduleAttempt(results.retry_after_delta);
-        return;
-      } else if (state.response_code ==
-                 net::HTTP_PROXY_AUTHENTICATION_REQUIRED) {
+      if (state.response_code == net::HTTP_PROXY_AUTHENTICATION_REQUIRED) {
         state.status = CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED;
       } else if (network &&
                  (network->connection_state() == shill::kStatePortal)) {
         // Take into account shill's detection results.
         state.status = CAPTIVE_PORTAL_STATUS_PORTAL;
-        LOG(WARNING) << "Network name=" << network->name() << ", "
-                     << "id=" << network->guid() << " "
-                     << "is marked as "
-                     << CaptivePortalStatusString(state.status) << " "
-                     << "despite the fact that CaptivePortalDetector "
-                     << "received no response";
       } else {
         state.status = CAPTIVE_PORTAL_STATUS_OFFLINE;
       }
       break;
     case captive_portal::RESULT_INTERNET_CONNECTED:
       state.status = CAPTIVE_PORTAL_STATUS_ONLINE;
       break;
     case captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL:
       state.status = CAPTIVE_PORTAL_STATUS_PORTAL;
       break;
     default:
       break;
   }
 
-  OnDetectionCompleted(network, state);
-  if (CanPerformAttempt() && strategy_->CanPerformAttemptAfterDetection())
-    ScheduleAttempt(base::TimeDelta());
+  if (last_detection_result_ != state.status) {
+    last_detection_result_ = state.status;
+    same_detection_result_count_ = 1;
+    strategy_->Reset();
+  } else {
+    ++same_detection_result_count_;
+  }
+  strategy_->OnDetectionCompleted();
+
+  if (result == captive_portal::RESULT_NO_RESPONSE)
+    ++no_response_result_count_;
+  else
+    no_response_result_count_ = 0;
+
+  if (state.status != CAPTIVE_PORTAL_STATUS_OFFLINE ||
+      same_detection_result_count_ >= kMaxOfflineResultsBeforeReport) {
+    OnDetectionCompleted(network, state);
+  }
+  ScheduleAttempt(results.retry_after_delta);
 }
 
 void NetworkPortalDetectorImpl::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_LOGIN_PROXY_CHANGED ||
       type == chrome::NOTIFICATION_AUTH_SUPPLIED ||
       type == chrome::NOTIFICATION_AUTH_CANCELLED) {
     VLOG(1) << "Restarting portal detection due to proxy change.";
-    attempt_count_ = 0;
-    if (is_portal_check_pending())
-      return;
     StopDetection();
     ScheduleAttempt(base::TimeDelta::FromSeconds(kProxyChangeDelaySec));
   }
 }
 
 void NetworkPortalDetectorImpl::OnDetectionCompleted(
     const NetworkState* network,
     const CaptivePortalState& state) {
   if (!network) {
     NotifyDetectionCompleted(network, state);
     return;
   }
 
   CaptivePortalStateMap::const_iterator it =
       portal_state_map_.find(network->guid());
   if (it == portal_state_map_.end() || it->second.status != state.status ||
       it->second.response_code != state.response_code) {
-    VLOG(1) << "Updating Chrome Captive Portal state: "
-            << "name=" << network->name() << ", "
-            << "id=" << network->guid() << ", "
-            << "status=" << CaptivePortalStatusString(state.status) << ", "
-            << "response_code=" << state.response_code;
-
     // Record detection duration iff detection result differs from the
     // previous one for this network. The reason is to record all stats
     // only when network changes it's state.
     RecordDetectionStats(network, state.status);
     if (it != portal_state_map_.end() &&
         it->second.status == CAPTIVE_PORTAL_STATUS_PORTAL &&
         state.status == CAPTIVE_PORTAL_STATUS_ONLINE) {
       RecordPortalToOnlineTransition(state.time - it->second.time);
     }
 
@@ skipping 46 matching lines @@
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
       if (network->connection_state() != shill::kStateOnline)
         RecordDiscrepancyWithShill(network, status);
       break;
     case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT:
       NOTREACHED();
       break;
   }
 }
 
+void NetworkPortalDetectorImpl::ResetStrategyAndCounters() {
+  last_detection_result_ = CAPTIVE_PORTAL_STATUS_UNKNOWN;
+  same_detection_result_count_ = 0;
+  no_response_result_count_ = 0;
+  strategy_->Reset();
+}
+
 }  // namespace chromeos