| // Copyright 2013 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_WEB_RESOURCE_RESOURCE_REQUEST_ALLOWED_NOTIFIER_H_ |
| #define CHROME_BROWSER_WEB_RESOURCE_RESOURCE_REQUEST_ALLOWED_NOTIFIER_H_ |
| |
| #include "chrome/browser/web_resource/eula_accepted_notifier.h" |
| #include "net/base/network_change_notifier.h" |
| |
| // This class informs an interested observer when resource requests over the |
| // network are permitted. |
| // |
| // Currently, the criteria for allowing resource requests are: |
| // 1. The network is currently available, |
| // 2. The EULA was accepted by the user (ChromeOS only), and |
| // 3. The --disable-background-networking command line switch is not set. |
| // |
| // Interested services should add themselves as an observer of |
| // ResourceRequestAllowedNotifier and check ResourceRequestsAllowed() to see if |
| // requests are permitted. If it returns true, they can go ahead and make their |
| // request. If it returns false, ResourceRequestAllowedNotifier will notify the |
| // service when the criteria is met. |
| // |
| // If ResourceRequestsAllowed returns true the first time, |
| // ResourceRequestAllowedNotifier will not notify the service in the future. |
| // |
| // Note that this class handles the criteria state for a single service, so |
| // services should keep their own instance of this class rather than sharing a |
| // global instance. |
| class ResourceRequestAllowedNotifier |
| : public EulaAcceptedNotifier::Observer, |
| public net::NetworkChangeNotifier::ConnectionTypeObserver { |
| public: |
| // Observes resource request allowed state changes. |
| class Observer { |
| public: |
| virtual void OnResourceRequestsAllowed() = 0; |
| }; |
| |
| // Specifies the resource request allowed state. |
| enum State { |
| ALLOWED, |
| DISALLOWED_EULA_NOT_ACCEPTED, |
| DISALLOWED_NETWORK_DOWN, |
| DISALLOWED_COMMAND_LINE_DISABLED, |
| }; |
| |
| ResourceRequestAllowedNotifier(); |
| virtual ~ResourceRequestAllowedNotifier(); |
| |
| // Sets |observer| as the service to be notified by this instance, and |
| // performs initial checks on the criteria. |observer| may not be NULL. |
| // This is to be called immediately after construction of an instance of |
| // ResourceRequestAllowedNotifier to pass it the interested service. |
| void Init(Observer* observer); |
| |
| // Returns whether resource requests are allowed, per the various criteria. |
| // If not, this call will set some flags so it knows to notify the observer |
| // if the criteria change. Note that the observer will not be notified unless |
| // it calls this method first. |
| // This is virtual so it can be overridden for tests. |
| virtual State GetResourceRequestsAllowedState(); |
| |
| // Convenience function, equivalent to: |
| // GetResourceRequestsAllowedState() == ALLOWED. |
| bool ResourceRequestsAllowed(); |
| |
| void SetWaitingForNetworkForTesting(bool waiting); |
| void SetWaitingForEulaForTesting(bool waiting); |
| void SetObserverRequestedForTesting(bool requested); |
| |
| protected: |
| // Notifies the observer if all criteria needed for resource requests are met. |
| // This is protected so it can be called from subclasses for testing. |
| void MaybeNotifyObserver(); |
| |
| private: |
| // Creates the EulaAcceptNotifier or NULL if one is not needed. Virtual so |
| // that it can be overridden by test subclasses. |
| virtual EulaAcceptedNotifier* CreateEulaNotifier(); |
| |
| // EulaAcceptedNotifier::Observer overrides: |
| virtual void OnEulaAccepted() OVERRIDE; |
| |
| // net::NetworkChangeNotifier::ConnectionTypeObserver overrides: |
| virtual void OnConnectionTypeChanged( |
| net::NetworkChangeNotifier::ConnectionType type) OVERRIDE; |
| |
| // Tracks whether or not the observer/service depending on this class actually |
| // requested permission to make a request or not. If it did not, then this |
| // class should not notify it even if the criteria is met. |
| bool observer_requested_permission_; |
| |
| // Tracks network connectivity criteria. |
| bool waiting_for_network_; |
| |
| // Tracks EULA acceptance criteria. |
| bool waiting_for_user_to_accept_eula_; |
| |
| // Platform-specific notifier of EULA acceptance, or NULL if not needed. |
| scoped_ptr<EulaAcceptedNotifier> eula_notifier_; |
| |
| // Observing service interested in request permissions. |
| Observer* observer_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ResourceRequestAllowedNotifier); |
| }; |
| |
| #endif // CHROME_BROWSER_WEB_RESOURCE_RESOURCE_REQUEST_ALLOWED_NOTIFIER_H_ |