Implemented lazy portal detection.

chrome/browser/chromeos/net/network_portal_detector.h

 // Copyright (c) 2012 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_BROWSER_CHROMEOS_NET_NETWORK_PORTAL_DETECTOR_H_
 #define CHROME_BROWSER_CHROMEOS_NET_NETWORK_PORTAL_DETECTOR_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 68 matching lines @@
   // Returns Captive Portal state for a given |network|.
   CaptivePortalState GetCaptivePortalState(const chromeos::Network* network);
 
   // NetworkLibrary::NetworkManagerObserver implementation:
   virtual void OnNetworkManagerChanged(chromeos::NetworkLibrary* cros) OVERRIDE;
 
   // NetworkLibrary::NetworkObserver implementation:
   virtual void OnNetworkChanged(chromeos::NetworkLibrary* cros,
                                 const chromeos::Network* network) OVERRIDE;
 
+  // Enables lazy detection mode. In this mode portal detection after
+  // first 3 consecutive attemps will be performed once in 30 seconds.
+  void EnableLazyDetection();
+
+  // Dizables lazy detection mode.
+  void DisableLazyDetection();
+
   // Creates an instance of the NetworkPortalDetector.
   static NetworkPortalDetector* CreateInstance();
 
   // Gets the instance of the NetworkPortalDetector.
   static NetworkPortalDetector* GetInstance();
 
   // Returns true is NetworkPortalDetector service is enabled.
   static bool IsEnabled();
 
  private:
@@ skipping 23 matching lines @@
   // calls OnPortalDetectionCompleted() with RESULT_NO_RESPONSE as
   // a result.
   void PortalDetectionTimeout();
 
   void CancelPortalDetection();
 
   // Called by CaptivePortalDetector when detection completes.
   void OnPortalDetectionCompleted(
       const captive_portal::CaptivePortalDetector::Results& results);
 
+  // Tries to perform portal detection in "lazy" mode. Does nothing in
+  // the case of already pending/processing detection request.
+  void TryLazyDetection();
+
   // content::NotificationObserver implementation:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Returns true if we're waiting for portal check.
   bool IsPortalCheckPending() const;
 
   // Returns true if portal check is in progress.
   bool IsCheckingForPortal() const;
@@ skipping 14 matching lines @@
   // Returns current number of portal detection attempts.
   // Used by unit tests.
   int attempt_count_for_testing() { return attempt_count_; }
 
   // Sets minimum time between consecutive portal checks for the same
   // network. Used by unit tests.
   void set_min_time_between_attempts_for_testing(const base::TimeDelta& delta) {
     min_time_between_attempts_ = delta;
   }
 
+  // Sets default interval between consecutive portal checks for a
+  // network in portal state. Used by unit tests.
+  void set_lazy_check_interval_for_testing(const base::TimeDelta& delta) {
+    lazy_check_interval_ = delta;
+  }
+
   // Sets portal detection timeout. Used by unit tests.
   void set_request_timeout_for_testing(const base::TimeDelta& timeout) {
     request_timeout_ = timeout;
   }
 
   // Returns delay before next portal check. Used by unit tests.
   const base::TimeDelta& next_attempt_delay_for_testing() {
     return next_attempt_delay_;
   }
 
@@ skipping 27 matching lines @@
   GURL test_url_;
 
   // Detector for checking active network for a portal state.
   scoped_ptr<captive_portal::CaptivePortalDetector> captive_portal_detector_;
 
   base::WeakPtrFactory<NetworkPortalDetector> weak_ptr_factory_;
 
   // Number of portal detection attemps for an active network.
   int attempt_count_;
 
+  // True if lazy detection is enabled.
+  bool lazy_detection_enabled_;
+
+  // Time between consecutive portal checks for a network in lazy
+  // mode.
+  base::TimeDelta lazy_check_interval_;
+
   // Minimum time between consecutive portal checks for the same
   // active network.
   base::TimeDelta min_time_between_attempts_;
 
   // Start time of portal detection.
   base::TimeTicks detection_start_time_;
 
   // Start time of portal detection attempt.
   base::TimeTicks attempt_start_time_;
 
   // Timeout for a portal detection.
   base::TimeDelta request_timeout_;
 
   // Delay before next portal detection.
   base::TimeDelta next_attempt_delay_;
 
   // Test time ticks used by unit tests.
   base::TimeTicks time_ticks_for_testing_;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkPortalDetector);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_NET_NETWORK_PORTAL_DETECTOR_H_