src/chromeos/network/portal_detector/network_portal_detector_strategy.cc

   1 // Copyright 2014 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 #include "chromeos/network/portal_detector/network_portal_detector_strategy.h"
   6
   7 #include "base/logging.h"
   8 #include "chromeos/network/network_handler.h"
   9 #include "chromeos/network/network_state.h"
  10 #include "chromeos/network/network_state_handler.h"
  11
  12 namespace chromeos {
  13
  14 namespace {
  15
  16 const NetworkState* DefaultNetwork() {
  17   return NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
  18 }
  19
  20 class LoginScreenStrategy : public PortalDetectorStrategy {
  21  public:
  22   static const int kBaseAttemptTimeoutSec = 5;
  23   static const int kMaxAttemptTimeoutSec = 30;
  24
  25   explicit LoginScreenStrategy(PortalDetectorStrategy::Delegate* delegate)
  26       : PortalDetectorStrategy(delegate) {}
  27   virtual ~LoginScreenStrategy() {}
  28
  29  protected:
  30   // PortalDetectorStrategy overrides:
  31   virtual StrategyId Id() const override { return STRATEGY_ID_LOGIN_SCREEN; }
  32   virtual base::TimeDelta GetNextAttemptTimeoutImpl() override {
  33     if (DefaultNetwork() && delegate_->NoResponseResultCount() != 0) {
  34       int timeout = kMaxAttemptTimeoutSec;
  35       if (kMaxAttemptTimeoutSec / (delegate_->NoResponseResultCount() + 1) >
  36           kBaseAttemptTimeoutSec) {
  37         timeout =
  38             kBaseAttemptTimeoutSec * (delegate_->NoResponseResultCount() + 1);
  39       }
  40       return base::TimeDelta::FromSeconds(timeout);
  41     }
  42     return base::TimeDelta::FromSeconds(kBaseAttemptTimeoutSec);
  43   }
  44
  45  private:
  46   DISALLOW_COPY_AND_ASSIGN(LoginScreenStrategy);
  47 };
  48
  49 class ErrorScreenStrategy : public PortalDetectorStrategy {
  50  public:
  51   static const int kAttemptTimeoutSec = 15;
  52
  53   explicit ErrorScreenStrategy(PortalDetectorStrategy::Delegate* delegate)
  54       : PortalDetectorStrategy(delegate) {}
  55   virtual ~ErrorScreenStrategy() {}
  56
  57  protected:
  58   // PortalDetectorStrategy overrides:
  59   virtual StrategyId Id() const override { return STRATEGY_ID_ERROR_SCREEN; }
  60   virtual base::TimeDelta GetNextAttemptTimeoutImpl() override {
  61     return base::TimeDelta::FromSeconds(kAttemptTimeoutSec);
  62   }
  63
  64  private:
  65   DISALLOW_COPY_AND_ASSIGN(ErrorScreenStrategy);
  66 };
  67
  68 class SessionStrategy : public PortalDetectorStrategy {
  69  public:
  70   static const int kMaxFastAttempts = 3;
  71   static const int kFastAttemptTimeoutSec = 3;
  72   static const int kSlowAttemptTimeoutSec = 5;
  73
  74   explicit SessionStrategy(PortalDetectorStrategy::Delegate* delegate)
  75       : PortalDetectorStrategy(delegate) {}
  76   virtual ~SessionStrategy() {}
  77
  78  protected:
  79   virtual StrategyId Id() const override { return STRATEGY_ID_SESSION; }
  80   virtual base::TimeDelta GetNextAttemptTimeoutImpl() override {
  81     int timeout;
  82     if (delegate_->NoResponseResultCount() < kMaxFastAttempts)
  83       timeout = kFastAttemptTimeoutSec;
  84     else
  85       timeout = kSlowAttemptTimeoutSec;
  86     return base::TimeDelta::FromSeconds(timeout);
  87   }
  88
  89  private:
  90   DISALLOW_COPY_AND_ASSIGN(SessionStrategy);
  91 };
  92
  93 }  // namespace
  94
  95 // PortalDetectorStrategy::BackoffEntryImpl ------------------------------------
  96
  97 class PortalDetectorStrategy::BackoffEntryImpl : public net::BackoffEntry {
  98  public:
  99   BackoffEntryImpl(const net::BackoffEntry::Policy* const policy,
 100                    PortalDetectorStrategy::Delegate* delegate)
 101       : net::BackoffEntry(policy), delegate_(delegate) {}
 102   virtual ~BackoffEntryImpl() {}
 103
 104   // net::BackoffEntry overrides:
 105   virtual base::TimeTicks ImplGetTimeNow() const override {
 106     return delegate_->GetCurrentTimeTicks();
 107   }
 108
 109  private:
 110   PortalDetectorStrategy::Delegate* delegate_;
 111
 112   DISALLOW_COPY_AND_ASSIGN(BackoffEntryImpl);
 113 };
 114
 115 // PortalDetectorStrategy -----------------------------------------------------
 116
 117 // static
 118 base::TimeDelta PortalDetectorStrategy::delay_till_next_attempt_for_testing_;
 119
 120 // static
 121 bool PortalDetectorStrategy::delay_till_next_attempt_for_testing_initialized_ =
 122     false;
 123
 124 // static
 125 base::TimeDelta PortalDetectorStrategy::next_attempt_timeout_for_testing_;
 126
 127 // static
 128 bool PortalDetectorStrategy::next_attempt_timeout_for_testing_initialized_ =
 129     false;
 130
 131 PortalDetectorStrategy::PortalDetectorStrategy(Delegate* delegate)
 132     : delegate_(delegate) {
 133   // First |policy_.num_errors_to_ignore| attempts with the same
 134   // result are performed with |policy_.initial_delay_ms| between
 135   // them. Delay before every consecutive attempt is multplied by
 136   // |policy_.multiply_factor_|. Also, |policy_.jitter_factor| is used
 137   // for each delay.
 138   policy_.num_errors_to_ignore = 3;
 139   policy_.initial_delay_ms = 600;
 140   policy_.multiply_factor = 2.0;
 141   policy_.jitter_factor = 0.3;
 142   policy_.maximum_backoff_ms = 2 * 60 * 1000;
 143   policy_.entry_lifetime_ms = -1;
 144   policy_.always_use_initial_delay = true;
 145   backoff_entry_.reset(new BackoffEntryImpl(&policy_, delegate_));
 146 }
 147
 148 PortalDetectorStrategy::~PortalDetectorStrategy() {
 149 }
 150
 151 // statc
 152 scoped_ptr<PortalDetectorStrategy> PortalDetectorStrategy::CreateById(
 153     StrategyId id,
 154     Delegate* delegate) {
 155   switch (id) {
 156     case STRATEGY_ID_LOGIN_SCREEN:
 157       return scoped_ptr<PortalDetectorStrategy>(
 158           new LoginScreenStrategy(delegate));
 159     case STRATEGY_ID_ERROR_SCREEN:
 160       return scoped_ptr<PortalDetectorStrategy>(
 161           new ErrorScreenStrategy(delegate));
 162     case STRATEGY_ID_SESSION:
 163       return scoped_ptr<PortalDetectorStrategy>(new SessionStrategy(delegate));
 164     default:
 165       NOTREACHED();
 166       return scoped_ptr<PortalDetectorStrategy>(
 167           static_cast<PortalDetectorStrategy*>(NULL));
 168   }
 169 }
 170
 171 base::TimeDelta PortalDetectorStrategy::GetDelayTillNextAttempt() {
 172   if (delay_till_next_attempt_for_testing_initialized_)
 173     return delay_till_next_attempt_for_testing_;
 174   return backoff_entry_->GetTimeUntilRelease();
 175 }
 176
 177 base::TimeDelta PortalDetectorStrategy::GetNextAttemptTimeout() {
 178   if (next_attempt_timeout_for_testing_initialized_)
 179     return next_attempt_timeout_for_testing_;
 180   return GetNextAttemptTimeoutImpl();
 181 }
 182
 183 void PortalDetectorStrategy::Reset() {
 184   backoff_entry_->Reset();
 185 }
 186
 187 void PortalDetectorStrategy::SetPolicyAndReset(
 188     const net::BackoffEntry::Policy& policy) {
 189   policy_ = policy;
 190   backoff_entry_.reset(new BackoffEntryImpl(&policy_, delegate_));
 191 }
 192
 193 void PortalDetectorStrategy::OnDetectionCompleted() {
 194   backoff_entry_->InformOfRequest(false);
 195 }
 196
 197 base::TimeDelta PortalDetectorStrategy::GetNextAttemptTimeoutImpl() {
 198   return base::TimeDelta();
 199 }
 200
 201 }  // namespace chromeos