Adds type information to the NetworkStateNotifier. Also allows for registration of observers.

Source/core/page/NetworkStateNotifier.cpp

 /*
  * 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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * 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.
  */
 
 #include "config.h"
 #include "core/page/NetworkStateNotifier.h"
 
+#include "core/dom/ExecutionContext.h"
 #include "core/page/Page.h"
 #include "wtf/Assertions.h"
+#include "wtf/Functional.h"
 #include "wtf/MainThread.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Threading.h"
 
 namespace WebCore {
 
 NetworkStateNotifier& networkStateNotifier()
 {
     AtomicallyInitializedStatic(NetworkStateNotifier*, networkStateNotifier = new NetworkStateNotifier);
     return *networkStateNotifier;
 }
 
 void NetworkStateNotifier::setOnLine(bool onLine)
 {
     ASSERT(isMainThread());
 
     {
         MutexLocker locker(m_mutex);
         if (m_isOnLine == onLine)
             return;
 
         m_isOnLine = onLine;
     }
 
     Page::networkStateChanged(onLine);
 }
 
+void NetworkStateNotifier::setWebConnectionType(blink::WebNetworkConnection::ConnectionType type)
+{
+    ASSERT(isMainThread());
+
+    MutexLocker locker(m_mutex);
+    if (m_type == type)
+        return;
+    m_type = type;
+
+    for (ObserverListMap::iterator it = m_observers.begin(); it != m_observers.end(); ++it) {

[adamk, 2014/05/20 15:00:36]

What guarantees that the ExecutionContexts in this map are still alive when this
code runs?

[jkarlin, 2014/05/20 16:20:23]

The observer must call removeObserver before the ExecutionContext dissappears. 
Since removeObserver is called on the ExecutionContext's thread this is safe. 
Added a comment to this effect.

+        ExecutionContext* context = it->key;
+        context->postTask(bind(&NetworkStateNotifier::notifyObserversOnContext, this, context, type));
+    }
 }
+
+void NetworkStateNotifier::notifyObserversOnContext(ExecutionContext* context, blink::WebNetworkConnection::ConnectionType type)
+{
+    ASSERT(context->isContextThread());
+
+    ObserverList* observerList = 0;
+
+    {
+        // The context could have been removed before we got here
+        MutexLocker locker(m_mutex);

[adamk, 2014/05/20 15:12:50]

I think you need to lock for this entire method, else your observerList may
become invalid if m_observers moves it around in memory while you're iterating
(this could happen if another thread calls addObserver or removeObserver).

But locking this whole methods doesn't seem ideal. If you instead make the
values in m_observers OwnPtr<Vector<NetworkStateObserver*>>, then you should be
guaranteed that the pointer won't change while you're on the context thread.

[jkarlin, 2014/05/20 16:20:23]

Nice catch, thanks. Made an alternate fix where the value of the hash table is
now a pointer.

+        ObserverListMap::iterator it = m_observers.find(context);
+        if (it == m_observers.end())
+            return;
+        observerList = &(it->value);
+    }
+
+    observerList->iterating = true;
+
+    for (Vector<ObserverType>::iterator it = observerList->observers.begin(); it != observerList->observers.end(); ++it)
+        (*it)->connectionTypeChange(type);
+
+    observerList->iterating = false;
+}
+
+void NetworkStateNotifier::addObserver(ObserverType observer, ExecutionContext* context)
+{
+    ASSERT(context->isContextThread());
+    ASSERT(observer);
+
+    MutexLocker locker(m_mutex);
+    ObserverListMap::iterator it = m_observers.find(context);
+    if (it == m_observers.end()) {
+        m_observers.set(context, ObserverList());
+        it = m_observers.find(context);
+    }
+    ASSERT(!it->value.iterating); // Don't mutate observer list while notifying.
+    it->value.observers.append(observer);
+}
+
+void NetworkStateNotifier::removeObserver(ObserverType observer, ExecutionContext* context)
+{
+    ASSERT(context->isContextThread());
+    ASSERT(observer);
+
+    MutexLocker locker(m_mutex);
+    ObserverListMap::iterator it = m_observers.find(context);
+    if (it == m_observers.end())
+        return;
+
+    ASSERT(!it->value.iterating); // Don't mutate observer list while notifying.
+
+    Vector<ObserverType>* observers = &it->value.observers;
+
+    for (size_t i = 0; i < observers->size(); ++i) {

[adamk, 2014/05/20 15:00:36]

Vector has a find() method (returning kNotFound if the item is not found) you
can use instead of this loop.

[jkarlin, 2014/05/20 16:20:23]

Done.

+        if (observers->at(i) == observer) {
+            observers->remove(i);
+            break;
+        }
+    }
+
+    if (observers->isEmpty())
+        m_observers.remove(it);
+}
+
+} // namespace WebCore