chrome/browser/chromeos/net/network_portal_detector_impl.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_CHROMEOS_NET_NETWORK_PORTAL_DETECTOR_IMPL_H_
   6 #define CHROME_BROWSER_CHROMEOS_NET_NETWORK_PORTAL_DETECTOR_IMPL_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/cancelable_callback.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/containers/hash_tables.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/memory/weak_ptr.h"
  17 #include "base/observer_list.h"
  18 #include "base/threading/non_thread_safe.h"
  19 #include "base/time/time.h"
  20 #include "chrome/browser/chromeos/net/network_portal_notification_controller.h"
  21 #include "chromeos/network/network_state_handler_observer.h"
  22 #include "chromeos/network/portal_detector/network_portal_detector.h"
  23 #include "chromeos/network/portal_detector/network_portal_detector_strategy.h"
  24 #include "components/captive_portal/captive_portal_detector.h"
  25 #include "components/captive_portal/captive_portal_types.h"
  26 #include "content/public/browser/notification_observer.h"
  27 #include "content/public/browser/notification_registrar.h"
  28 #include "net/url_request/url_fetcher.h"
  29 #include "url/gurl.h"
  30
  31 class NetworkingConfigTest;
  32
  33 namespace net {
  34 class URLRequestContextGetter;
  35 }
  36
  37 namespace chromeos {
  38
  39 class NetworkState;
  40
  41 // This class handles all notifications about network changes from
  42 // NetworkStateHandler and delegates portal detection for the default
  43 // network to CaptivePortalService.
  44 class NetworkPortalDetectorImpl
  45     : public NetworkPortalDetector,
  46       public base::NonThreadSafe,
  47       public chromeos::NetworkStateHandlerObserver,
  48       public content::NotificationObserver,
  49       public PortalDetectorStrategy::Delegate {
  50  public:
  51   static const char kOobeDetectionResultHistogram[];
  52   static const char kOobeDetectionDurationHistogram[];
  53   static const char kOobeShillOnlineHistogram[];
  54   static const char kOobeShillPortalHistogram[];
  55   static const char kOobeShillOfflineHistogram[];
  56   static const char kOobePortalToOnlineHistogram[];
  57
  58   static const char kSessionDetectionResultHistogram[];
  59   static const char kSessionDetectionDurationHistogram[];
  60   static const char kSessionShillOnlineHistogram[];
  61   static const char kSessionShillPortalHistogram[];
  62   static const char kSessionShillOfflineHistogram[];
  63   static const char kSessionPortalToOnlineHistogram[];
  64
  65   // Creates an instance of NetworkPortalDetectorImpl.
  66   static void Initialize(net::URLRequestContextGetter* url_context);
  67
  68   explicit NetworkPortalDetectorImpl(
  69       const scoped_refptr<net::URLRequestContextGetter>& request_context);
  70   ~NetworkPortalDetectorImpl() override;
  71
  72   // NetworkPortalDetector implementation:
  73   void AddObserver(Observer* observer) override;
  74   void AddAndFireObserver(Observer* observer) override;
  75   void RemoveObserver(Observer* observer) override;
  76   CaptivePortalState GetCaptivePortalState(const std::string& guid) override;
  77   bool IsEnabled() override;
  78   void Enable(bool start_detection) override;
  79   bool StartDetectionIfIdle() override;
  80   void SetStrategy(PortalDetectorStrategy::StrategyId id) override;
  81   void OnLockScreenRequest() override;
  82
  83   // NetworkStateHandlerObserver implementation:
  84   void DefaultNetworkChanged(const NetworkState* network) override;
  85
  86   // PortalDetectorStrategy::Delegate implementation:
  87   int NoResponseResultCount() override;
  88   base::TimeTicks AttemptStartTime() override;
  89   base::TimeTicks NowTicks() override;
  90
  91  private:
  92   friend class ::NetworkingConfigTest;
  93   friend class NetworkPortalDetectorImplTest;
  94   friend class NetworkPortalDetectorImplBrowserTest;
  95
  96   struct DetectionAttemptCompletedReport {
  97     DetectionAttemptCompletedReport();
  98
  99     DetectionAttemptCompletedReport(const std::string network_name,
 100                                     const std::string network_id,
 101                                     captive_portal::CaptivePortalResult result,
 102                                     int response_code);
 103
 104     void Report() const;
 105
 106     bool Equals(const DetectionAttemptCompletedReport& o) const;
 107
 108     std::string network_name;
 109     std::string network_id;
 110     captive_portal::CaptivePortalResult result;
 111     int response_code;
 112   };
 113
 114   typedef std::string NetworkId;
 115   typedef base::hash_map<NetworkId, CaptivePortalState> CaptivePortalStateMap;
 116
 117   enum State {
 118     // No portal check is running.
 119     STATE_IDLE = 0,
 120     // Waiting for portal check.
 121     STATE_PORTAL_CHECK_PENDING,
 122     // Portal check is in progress.
 123     STATE_CHECKING_FOR_PORTAL,
 124   };
 125
 126   // Starts detection process.
 127   void StartDetection();
 128
 129   // Stops whole detection process.
 130   void StopDetection();
 131
 132   // Stops and restarts the detection process.
 133   void RetryDetection();
 134
 135   // Initiates Captive Portal detection attempt after |delay|.
 136   void ScheduleAttempt(const base::TimeDelta& delay);
 137
 138   // Starts detection attempt.
 139   void StartAttempt();
 140
 141   // Called when portal check is timed out. Cancels portal check and calls
 142   // OnPortalDetectionCompleted() with RESULT_NO_RESPONSE as a result.
 143   void OnAttemptTimeout();
 144
 145   // Called by CaptivePortalDetector when detection attempt completes.
 146   void OnAttemptCompleted(
 147       const captive_portal::CaptivePortalDetector::Results& results);
 148
 149   // content::NotificationObserver implementation:
 150   void Observe(int type,
 151                const content::NotificationSource& source,
 152                const content::NotificationDetails& details) override;
 153
 154   // Stores captive portal state for a |network| and notifies observers.
 155   void OnDetectionCompleted(const NetworkState* network,
 156                             const CaptivePortalState& results);
 157
 158   // Notifies observers that portal detection is completed for a |network|.
 159   void NotifyDetectionCompleted(const NetworkState* network,
 160                                 const CaptivePortalState& state);
 161
 162   State state() const { return state_; }
 163
 164   bool is_idle() const {
 165     return state_ == STATE_IDLE;
 166   }
 167   bool is_portal_check_pending() const {
 168     return state_ == STATE_PORTAL_CHECK_PENDING;
 169   }
 170   bool is_checking_for_portal() const {
 171     return state_ == STATE_CHECKING_FOR_PORTAL;
 172   }
 173
 174   int same_detection_result_count_for_testing() const {
 175     return same_detection_result_count_;
 176   }
 177
 178   int no_response_result_count_for_testing() const {
 179     return no_response_result_count_;
 180   }
 181
 182   void set_no_response_result_count_for_testing(int count) {
 183     no_response_result_count_ = count;
 184   }
 185
 186   // Returns delay before next portal check. Used by unit tests.
 187   const base::TimeDelta& next_attempt_delay_for_testing() const {
 188     return next_attempt_delay_;
 189   }
 190
 191   // Returns true if attempt timeout callback isn't fired or
 192   // cancelled.
 193   bool AttemptTimeoutIsCancelledForTesting() const;
 194
 195   // Record detection stats such as detection duration and detection
 196   // result in UMA.
 197   void RecordDetectionStats(const NetworkState* network,
 198                             CaptivePortalStatus status);
 199
 200   // Resets strategy and all counters used in computations of
 201   // timeouts.
 202   void ResetStrategyAndCounters();
 203
 204   // Sets current test time ticks. Used by unit tests.
 205   void set_time_ticks_for_testing(const base::TimeTicks& time_ticks) {
 206     time_ticks_for_testing_ = time_ticks;
 207   }
 208
 209   // Advances current test time ticks. Used by unit tests.
 210   void advance_time_ticks_for_testing(const base::TimeDelta& delta) {
 211     time_ticks_for_testing_ += delta;
 212   }
 213
 214   // Name of the default network.
 215   std::string default_network_name_;
 216
 217   // Unique identifier of the default network.
 218   std::string default_network_id_;
 219
 220   // Connection state of the default network.
 221   std::string default_connection_state_;
 222
 223   State state_;
 224   CaptivePortalStateMap portal_state_map_;
 225   base::ObserverList<Observer> observers_;
 226
 227   base::CancelableClosure attempt_task_;
 228   base::CancelableClosure attempt_timeout_;
 229
 230   // URL that returns a 204 response code when connected to the Internet.
 231   GURL test_url_;
 232
 233   // Detector for checking default network for a portal state.
 234   scoped_ptr<captive_portal::CaptivePortalDetector> captive_portal_detector_;
 235
 236   // True if the NetworkPortalDetector is enabled.
 237   bool enabled_;
 238
 239   // Start time of portal detection.
 240   base::TimeTicks detection_start_time_;
 241
 242   // Start time of detection attempt.
 243   base::TimeTicks attempt_start_time_;
 244
 245   // Delay before next portal detection.
 246   base::TimeDelta next_attempt_delay_;
 247
 248   // Current detection strategy.
 249   scoped_ptr<PortalDetectorStrategy> strategy_;
 250
 251   // Last received result from captive portal detector.
 252   CaptivePortalStatus last_detection_result_;
 253
 254   // Number of detection attempts with same result in a row.
 255   int same_detection_result_count_;
 256
 257   // Number of detection attempts in a row with NO RESPONSE result.
 258   int no_response_result_count_;
 259
 260   // UI notification controller about captive portal state.
 261   NetworkPortalNotificationController notification_controller_;
 262
 263   content::NotificationRegistrar registrar_;
 264
 265   // Test time ticks used by unit tests.
 266   base::TimeTicks time_ticks_for_testing_;
 267
 268   // Contents of a last log message about completed detection attempt.
 269   DetectionAttemptCompletedReport attempt_completed_report_;
 270
 271   base::WeakPtrFactory<NetworkPortalDetectorImpl> weak_factory_;
 272
 273   DISALLOW_COPY_AND_ASSIGN(NetworkPortalDetectorImpl);
 274 };
 275
 276 }  // namespace chromeos
 277
 278 #endif  // CHROME_BROWSER_CHROMEOS_NET_NETWORK_PORTAL_DETECTOR_IMPL_H_