chrome/browser/web_resource/resource_request_allowed_notifier.cc

   1 // Copyright 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 #include "chrome/browser/web_resource/resource_request_allowed_notifier.h"
   6
   7 #include "base/command_line.h"
   8 #include "chrome/common/chrome_switches.h"
   9
  10 ResourceRequestAllowedNotifier::ResourceRequestAllowedNotifier()
  11     : observer_requested_permission_(false),
  12       waiting_for_network_(false),
  13       waiting_for_user_to_accept_eula_(false),
  14       observer_(NULL) {
  15 }
  16
  17 ResourceRequestAllowedNotifier::~ResourceRequestAllowedNotifier() {
  18   if (observer_)
  19     net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
  20 }
  21
  22 void ResourceRequestAllowedNotifier::Init(Observer* observer) {
  23   DCHECK(!observer_ && observer);
  24   observer_ = observer;
  25
  26   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
  27
  28   // Check this state during initialization. It is not expected to change until
  29   // the corresponding notification is received.
  30   waiting_for_network_ = net::NetworkChangeNotifier::IsOffline();
  31
  32   eula_notifier_.reset(CreateEulaNotifier());
  33   if (eula_notifier_) {
  34     eula_notifier_->Init(this);
  35     waiting_for_user_to_accept_eula_ = !eula_notifier_->IsEulaAccepted();
  36   }
  37 }
  38
  39 ResourceRequestAllowedNotifier::State
  40     ResourceRequestAllowedNotifier::GetResourceRequestsAllowedState() {
  41   if (CommandLine::ForCurrentProcess()->HasSwitch(
  42       switches::kDisableBackgroundNetworking)) {
  43     return DISALLOWED_COMMAND_LINE_DISABLED;
  44   }
  45
  46   // The observer requested permission. Return the current criteria state and
  47   // set a flag to remind this class to notify the observer once the criteria
  48   // is met.
  49   observer_requested_permission_ = waiting_for_user_to_accept_eula_ ||
  50                                    waiting_for_network_;
  51   if (!observer_requested_permission_)
  52     return ALLOWED;
  53   return waiting_for_user_to_accept_eula_ ? DISALLOWED_EULA_NOT_ACCEPTED :
  54                                             DISALLOWED_NETWORK_DOWN;
  55 }
  56
  57 bool ResourceRequestAllowedNotifier::ResourceRequestsAllowed() {
  58   return GetResourceRequestsAllowedState() == ALLOWED;
  59 }
  60
  61 void ResourceRequestAllowedNotifier::SetWaitingForNetworkForTesting(
  62     bool waiting) {
  63   waiting_for_network_ = waiting;
  64 }
  65
  66 void ResourceRequestAllowedNotifier::SetWaitingForEulaForTesting(
  67     bool waiting) {
  68   waiting_for_user_to_accept_eula_ = waiting;
  69 }
  70
  71 void ResourceRequestAllowedNotifier::SetObserverRequestedForTesting(
  72     bool requested) {
  73   observer_requested_permission_ = requested;
  74 }
  75
  76 void ResourceRequestAllowedNotifier::MaybeNotifyObserver() {
  77   // Need to ensure that all criteria are met before notifying observers.
  78   if (observer_requested_permission_ && ResourceRequestsAllowed()) {
  79     DVLOG(1) << "Notifying observer of state change.";
  80     observer_->OnResourceRequestsAllowed();
  81     // Reset this so the observer is not informed again unless they check
  82     // ResourceRequestsAllowed again.
  83     observer_requested_permission_ = false;
  84   }
  85 }
  86
  87 EulaAcceptedNotifier* ResourceRequestAllowedNotifier::CreateEulaNotifier() {
  88   return EulaAcceptedNotifier::Create();
  89 }
  90
  91 void ResourceRequestAllowedNotifier::OnEulaAccepted() {
  92   // This flag should have been set if this was waiting on the EULA
  93   // notification.
  94   DCHECK(waiting_for_user_to_accept_eula_);
  95   DVLOG(1) << "EULA was accepted.";
  96   waiting_for_user_to_accept_eula_ = false;
  97   MaybeNotifyObserver();
  98 }
  99
 100 void ResourceRequestAllowedNotifier::OnConnectionTypeChanged(
 101     net::NetworkChangeNotifier::ConnectionType type) {
 102   // Only attempt to notify observers if this was previously waiting for the
 103   // network to reconnect, and new network state is actually available. This
 104   // prevents the notifier from notifying the observer if the notifier was never
 105   // waiting on the network, or if the network changes from one online state
 106   // to another (for example, Wifi to 3G, or Wifi to Wifi, if the network were
 107   // flaky).
 108   if (waiting_for_network_ &&
 109       type != net::NetworkChangeNotifier::CONNECTION_NONE) {
 110     waiting_for_network_ = false;
 111     DVLOG(1) << "Network came back online.";
 112     MaybeNotifyObserver();
 113   } else if (!waiting_for_network_ &&
 114              type == net::NetworkChangeNotifier::CONNECTION_NONE) {
 115     waiting_for_network_ = true;
 116     DVLOG(1) << "Network went offline.";
 117   }
 118 }