Remove Page dependency from NetworkStateNotifier

third_party/WebKit/Source/core/page/NetworkStateNotifier.h

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 10 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef NetworkStateNotifier_h
 #define NetworkStateNotifier_h
 
 #include <memory>
 #include "core/CoreExport.h"
+#include "platform/CrossThreadCopier.h"
 #include "platform/WebTaskRunner.h"
 #include "public/platform/WebConnectionType.h"
 #include "wtf/Allocator.h"
 #include "wtf/HashMap.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 class CORE_EXPORT NetworkStateNotifier {
   WTF_MAKE_NONCOPYABLE(NetworkStateNotifier);
   USING_FAST_MALLOC(NetworkStateNotifier);
 
  public:
   class NetworkStateObserver {
    public:
-    // Will be called on the task runner that is passed in addObserver.
-    virtual void connectionChange(WebConnectionType,
-                                  double maxBandwidthMbps) = 0;
+    // Will be called on the task runner that is passed in add*Observer.
+    virtual void connectionChange(WebConnectionType, double maxBandwidthMbps) {}
+    virtual void onLineStateChange(bool onLine) {}
   };
 
   NetworkStateNotifier() : m_hasOverride(false) {}
 
   // Can be called on any thread.
   bool onLine() const {
     MutexLocker locker(m_mutex);
     const NetworkState& state = m_hasOverride ? m_override : m_state;
     DCHECK(state.onLineInitialized);
     return state.onLine;
@@ skipping 46 matching lines @@
   //
   // Since this class is a singleton, tests must clear override when completed
   // to avoid indeterminate state across the test harness.
   void setOverride(bool onLine, WebConnectionType, double maxBandwidthMbps);
   void clearOverride();
 
   // Must be called on the given task runner. An added observer must be removed
   // before the observer or its execution context goes away. It's possible for
   // an observer to be called twice for the same event if it is first removed
   // and then added during notification.
-  void addObserver(NetworkStateObserver*, WebTaskRunner*);
-  void removeObserver(NetworkStateObserver*, WebTaskRunner*);
+  void addConnectionObserver(NetworkStateObserver*, PassRefPtr<WebTaskRunner>);
+  void addOnLineObserver(NetworkStateObserver*, PassRefPtr<WebTaskRunner>);
+  void removeConnectionObserver(NetworkStateObserver*,
+                                PassRefPtr<WebTaskRunner>);
+  void removeOnLineObserver(NetworkStateObserver*, PassRefPtr<WebTaskRunner>);
 
  private:
   struct ObserverList {
     ObserverList() : iterating(false) {}
     bool iterating;
     Vector<NetworkStateObserver*> observers;
     Vector<size_t> zeroedObservers;  // Indices in observers that are 0.
   };
 
   struct NetworkState {
     static const int kInvalidMaxBandwidth = -1;
     bool onLineInitialized = false;
     bool onLine = true;
     bool connectionInitialized = false;
     WebConnectionType type = WebConnectionTypeOther;
     double maxBandwidthMbps = kInvalidMaxBandwidth;
   };
+  friend CrossThreadCopier<NetworkStateNotifier::NetworkState>;
 
   // This helper scope issues required notifications when mutating the state if
   // something has changed.  It's only possible to mutate the state on the main
   // thread.  Note that ScopedNotifier must be destroyed when not holding a lock
   // so that onLine notifications can be dispatched without a deadlock.
   class ScopedNotifier {
    public:
     explicit ScopedNotifier(NetworkStateNotifier&);
     ~ScopedNotifier();
 
    private:
     NetworkStateNotifier& m_notifier;
     NetworkState m_before;
   };
 
+  enum class ObserverType {
+    ONLINE_STATE,
+    CONNECTION_TYPE,
+  };
+
   // The ObserverListMap is cross-thread accessed, adding/removing Observers
   // running on a task runner.
   using ObserverListMap =
-      HashMap<WebTaskRunner*, std::unique_ptr<ObserverList>>;
+      HashMap<RefPtr<WebTaskRunner>, std::unique_ptr<ObserverList>>;
 
-  void notifyObservers(WebConnectionType, double maxBandwidthMbps);
-  void notifyObserversOfConnectionChangeOnTaskRunner(WebConnectionType,
-                                                     double maxBandwidthMbps,
-                                                     WebTaskRunner*);
+  void notifyObservers(ObserverListMap&, ObserverType, const NetworkState&);
+  void notifyObserversOnTaskRunner(ObserverListMap*,
+                                   ObserverType,
+                                   PassRefPtr<WebTaskRunner>,
+                                   const NetworkState&);
 
-  ObserverList* lockAndFindObserverList(WebTaskRunner*);
+  void addObserver(ObserverListMap&,
+                   NetworkStateObserver*,
+                   PassRefPtr<WebTaskRunner>);
+  void removeObserver(ObserverListMap&,
+                      NetworkStateObserver*,
+                      PassRefPtr<WebTaskRunner>);
+
+  ObserverList* lockAndFindObserverList(ObserverListMap&,
+                                        PassRefPtr<WebTaskRunner>);
 
   // Removed observers are nulled out in the list in case the list is being
   // iterated over. Once done iterating, call this to clean up nulled
   // observers.
-  void collectZeroedObservers(ObserverList*, WebTaskRunner*);
+  void collectZeroedObservers(ObserverListMap&,
+                              ObserverList*,
+                              PassRefPtr<WebTaskRunner>);
 
   mutable Mutex m_mutex;
   NetworkState m_state;
   bool m_hasOverride;
   NetworkState m_override;
-  ObserverListMap m_observers;
+
+  ObserverListMap m_connectionObservers;
+  ObserverListMap m_onLineStateObservers;
 };
 
 CORE_EXPORT NetworkStateNotifier& networkStateNotifier();
 
 }  // namespace blink
 
 #endif  // NetworkStateNotifier_h