src/chrome/browser/chromeos/net/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 "chrome/browser/chromeos/net/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 // TODO (ygorshenin@): reuse net::BackoffEntry for strategies.
  21
  22 class LoginScreenStrategy : public PortalDetectorStrategy {
  23  public:
  24   static const int kMaxAttempts = 3;
  25   static const int kDelayBetweenAttemptsSec = 3;
  26   static const int kBaseAttemptTimeoutSec = 5;
  27
  28   LoginScreenStrategy() {}
  29   virtual ~LoginScreenStrategy() {}
  30
  31  protected:
  32   // PortalDetectorStrategy overrides:
  33   virtual StrategyId Id() const OVERRIDE { return STRATEGY_ID_LOGIN_SCREEN; }
  34   virtual bool CanPerformAttemptImpl() OVERRIDE {
  35     return delegate_->AttemptCount() < kMaxAttempts;
  36   }
  37   virtual base::TimeDelta GetDelayTillNextAttemptImpl() OVERRIDE {
  38     return AdjustDelay(base::TimeDelta::FromSeconds(kDelayBetweenAttemptsSec));
  39   }
  40   virtual base::TimeDelta GetNextAttemptTimeoutImpl() OVERRIDE {
  41     int timeout = DefaultNetwork()
  42                       ? (delegate_->AttemptCount() + 1) * kBaseAttemptTimeoutSec
  43                       : kBaseAttemptTimeoutSec;
  44     return base::TimeDelta::FromSeconds(timeout);
  45   }
  46
  47  private:
  48   DISALLOW_COPY_AND_ASSIGN(LoginScreenStrategy);
  49 };
  50
  51 class ErrorScreenStrategy : public PortalDetectorStrategy {
  52  public:
  53   static const int kDelayBetweenAttemptsSec = 3;
  54   static const int kAttemptTimeoutSec = 15;
  55
  56   ErrorScreenStrategy() {}
  57   virtual ~ErrorScreenStrategy() {}
  58
  59  protected:
  60   // PortalDetectorStrategy overrides:
  61   virtual StrategyId Id() const OVERRIDE { return STRATEGY_ID_ERROR_SCREEN; }
  62   virtual bool CanPerformAttemptImpl() OVERRIDE { return true; }
  63   virtual bool CanPerformAttemptAfterDetectionImpl() OVERRIDE { return true; }
  64   virtual base::TimeDelta GetDelayTillNextAttemptImpl() OVERRIDE {
  65     return AdjustDelay(base::TimeDelta::FromSeconds(kDelayBetweenAttemptsSec));
  66   }
  67   virtual base::TimeDelta GetNextAttemptTimeoutImpl() OVERRIDE {
  68     return base::TimeDelta::FromSeconds(kAttemptTimeoutSec);
  69   }
  70
  71  private:
  72   DISALLOW_COPY_AND_ASSIGN(ErrorScreenStrategy);
  73 };
  74
  75 class SessionStrategy : public PortalDetectorStrategy {
  76  public:
  77   static const int kFastDelayBetweenAttemptsSec = 1;
  78   static const int kMaxFastAttempts = 3;
  79   static const int kFastAttemptTimeoutSec = 3;
  80
  81   static const int kSlowDelayBetweenAttemptsSec = 10;
  82   static const int kSlowAttemptTimeoutSec = 5;
  83
  84   SessionStrategy() {}
  85   virtual ~SessionStrategy() {}
  86
  87  protected:
  88   virtual StrategyId Id() const OVERRIDE { return STRATEGY_ID_SESSION; }
  89   virtual bool CanPerformAttemptImpl() OVERRIDE { return true; }
  90   virtual bool CanPerformAttemptAfterDetectionImpl() OVERRIDE { return true; }
  91   virtual base::TimeDelta GetDelayTillNextAttemptImpl() OVERRIDE {
  92     int delay;
  93     if (delegate_->AttemptCount() < kMaxFastAttempts)
  94       delay = kFastDelayBetweenAttemptsSec;
  95     else
  96       delay = kSlowDelayBetweenAttemptsSec;
  97     return AdjustDelay(base::TimeDelta::FromSeconds(delay));
  98   }
  99   virtual base::TimeDelta GetNextAttemptTimeoutImpl() OVERRIDE {
 100     int timeout;
 101     if (delegate_->AttemptCount() < kMaxFastAttempts)
 102       timeout = kFastAttemptTimeoutSec;
 103     else
 104       timeout = kSlowAttemptTimeoutSec;
 105     return base::TimeDelta::FromSeconds(timeout);
 106   }
 107
 108  private:
 109   DISALLOW_COPY_AND_ASSIGN(SessionStrategy);
 110 };
 111
 112 }  // namespace
 113
 114 // PortalDetectorStrategy -----------------------------------------------------
 115
 116 // static
 117 base::TimeDelta PortalDetectorStrategy::delay_till_next_attempt_for_testing_;
 118
 119 // static
 120 bool PortalDetectorStrategy::delay_till_next_attempt_for_testing_initialized_ =
 121     false;
 122
 123 // static
 124 base::TimeDelta PortalDetectorStrategy::next_attempt_timeout_for_testing_;
 125
 126 // static
 127 bool PortalDetectorStrategy::next_attempt_timeout_for_testing_initialized_ =
 128     false;
 129
 130 PortalDetectorStrategy::PortalDetectorStrategy() : delegate_(NULL) {}
 131
 132 PortalDetectorStrategy::~PortalDetectorStrategy() {}
 133
 134 // statc
 135 scoped_ptr<PortalDetectorStrategy> PortalDetectorStrategy::CreateById(
 136     StrategyId id) {
 137   switch (id) {
 138     case STRATEGY_ID_LOGIN_SCREEN:
 139       return scoped_ptr<PortalDetectorStrategy>(new LoginScreenStrategy());
 140     case STRATEGY_ID_ERROR_SCREEN:
 141       return scoped_ptr<PortalDetectorStrategy>(new ErrorScreenStrategy());
 142     case STRATEGY_ID_SESSION:
 143       return scoped_ptr<PortalDetectorStrategy>(new SessionStrategy());
 144     default:
 145       NOTREACHED();
 146       return scoped_ptr<PortalDetectorStrategy>(
 147           static_cast<PortalDetectorStrategy*>(NULL));
 148   }
 149 }
 150
 151 bool PortalDetectorStrategy::CanPerformAttempt() {
 152   return CanPerformAttemptImpl();
 153 }
 154
 155 bool PortalDetectorStrategy::CanPerformAttemptAfterDetection() {
 156   return CanPerformAttemptAfterDetectionImpl();
 157 }
 158
 159 base::TimeDelta PortalDetectorStrategy::GetDelayTillNextAttempt() {
 160   if (delay_till_next_attempt_for_testing_initialized_)
 161     return delay_till_next_attempt_for_testing_;
 162   return GetDelayTillNextAttemptImpl();
 163 }
 164
 165 base::TimeDelta PortalDetectorStrategy::GetNextAttemptTimeout() {
 166   if (next_attempt_timeout_for_testing_initialized_)
 167     return next_attempt_timeout_for_testing_;
 168   return GetNextAttemptTimeoutImpl();
 169 }
 170
 171 bool PortalDetectorStrategy::CanPerformAttemptImpl() { return false; }
 172
 173 bool PortalDetectorStrategy::CanPerformAttemptAfterDetectionImpl() {
 174   return false;
 175 }
 176
 177 base::TimeDelta PortalDetectorStrategy::GetDelayTillNextAttemptImpl() {
 178   return base::TimeDelta();
 179 }
 180
 181 base::TimeDelta PortalDetectorStrategy::GetNextAttemptTimeoutImpl() {
 182   return base::TimeDelta();
 183 }
 184
 185 base::TimeDelta PortalDetectorStrategy::AdjustDelay(
 186     const base::TimeDelta& delay) {
 187   if (!delegate_->AttemptCount())
 188     return base::TimeDelta();
 189
 190   base::TimeTicks now = delegate_->GetCurrentTimeTicks();
 191   base::TimeDelta elapsed;
 192   if (now > delegate_->AttemptStartTime())
 193     elapsed = now - delegate_->AttemptStartTime();
 194   if (delay > elapsed)
 195     return delay - elapsed;
 196   return base::TimeDelta();
 197 }
 198
 199 }  // namespace chromeos