Increased delay before next portal detection attempt in the case of !ONLINE -> ONLINE transition.

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 19 matching lines @@
 
 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;
 
+// Delay before portal detection attempt after !ONLINE -> !ONLINE
+// transition.
+const int kShortInitialDelayBetweenAttemptsMs = 600;
+
+// Maximum timeout before portal detection attempts after !ONLINE ->
+// !ONLINE transition.
+const int kShortMaximumDelayBetweenAttemptsMs = 2 * 60 * 1000;
+
+// Delay before portal detection attempt after !ONLINE -> ONLINE
+// transition.
+const int kLongInitialDelayBetweenAttemptsMs = 30 * 1000;
+
+// Maximum timeout before portal detection attempts after !ONLINE ->
+// ONLINE transition.
+const int kLongMaximumDelayBetweenAttemptsMs = 5 * 60 * 1000;
+
 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 150 matching lines @@
   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),
       strategy_(PortalDetectorStrategy::CreateById(
-          PortalDetectorStrategy::STRATEGY_ID_LOGIN_SCREEN)),
+          PortalDetectorStrategy::STRATEGY_ID_LOGIN_SCREEN, this)),
       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());
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTH_CANCELLED,
                  content::NotificationService::AllSources());
@@ skipping 75 matching lines @@
   if (!is_idle())
     return false;
   StartDetection();
   return true;
 }
 
 void NetworkPortalDetectorImpl::SetStrategy(
     PortalDetectorStrategy::StrategyId id) {
   if (id == strategy_->Id())
     return;
-  strategy_.reset(PortalDetectorStrategy::CreateById(id).release());
-  strategy_->set_delegate(this);
+  strategy_ = PortalDetectorStrategy::CreateById(id, this).Pass();
   StopDetection();
   StartDetectionIfIdle();
 }
 
 void NetworkPortalDetectorImpl::DefaultNetworkChanged(
     const NetworkState* default_network) {
   DCHECK(CalledOnValidThread());
 
   if (!default_network) {
     VLOG(1) << "DefaultNetworkChanged: None.";
@@ skipping 173 matching lines @@
     case captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL:
       state.status = CAPTIVE_PORTAL_STATUS_PORTAL;
       break;
     default:
       break;
   }
 
   if (last_detection_result_ != state.status) {
     last_detection_result_ = state.status;
     same_detection_result_count_ = 1;
-    strategy_->Reset();
+    net::BackoffEntry::Policy policy = strategy_->policy();
+    if (state.status == CAPTIVE_PORTAL_STATUS_ONLINE) {
+      policy.initial_delay_ms = kLongInitialDelayBetweenAttemptsMs;
+      policy.maximum_backoff_ms = kLongMaximumDelayBetweenAttemptsMs;
+    } else {
+      policy.initial_delay_ms = kShortInitialDelayBetweenAttemptsMs;
+      policy.maximum_backoff_ms = kShortMaximumDelayBetweenAttemptsMs;
+    }
+    strategy_->SetPolicyAndReset(policy);
   } else {
     ++same_detection_result_count_;
   }
   strategy_->OnDetectionCompleted();
 
   if (result == captive_portal::RESULT_NO_RESPONSE)
     ++no_response_result_count_;
   else
     no_response_result_count_ = 0;
 
@@ skipping 96 matching lines @@
 }
 
 void NetworkPortalDetectorImpl::ResetStrategyAndCounters() {
   last_detection_result_ = CAPTIVE_PORTAL_STATUS_UNKNOWN;
   same_detection_result_count_ = 0;
   no_response_result_count_ = 0;
   strategy_->Reset();
 }
 
 }  // namespace chromeos