[DevTools] Network.emulateNetworkConditions now affects NetworkStateNotifier.

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

Index: third_party/WebKit/Source/core/page/NetworkStateNotifier.cpp
diff --git a/third_party/WebKit/Source/core/page/NetworkStateNotifier.cpp b/third_party/WebKit/Source/core/page/NetworkStateNotifier.cpp
index 628b377de6a04f3f2954bf2f6754bb7eb38ceb58..77482a28d18827619f0b72ee8d623a43b40ecd8a 100644
--- a/third_party/WebKit/Source/core/page/NetworkStateNotifier.cpp
+++ b/third_party/WebKit/Source/core/page/NetworkStateNotifier.cpp
@@ -42,28 +42,41 @@ NetworkStateNotifier& networkStateNotifier()
     return networkStateNotifier;
 }
 
-void NetworkStateNotifier::setOnLine(bool onLine)
+NetworkStateNotifier::ScopedNotifier::ScopedNotifier(NetworkStateNotifier& notifier)
+    : m_notifier(notifier)
 {
-    ASSERT(isMainThread());
-
-    {
-        MutexLocker locker(m_mutex);
-        if (m_isOnLine == onLine)
-            return;
+    DCHECK(isMainThread());
+    m_notifier.m_mutex.lock();
+    m_before = m_notifier.m_hasOverride ? m_notifier.m_override : m_notifier.m_state;

[jkarlin, 2016/06/28 17:57:12]

m_before can be set before acquiring the mutex since we're on the main thread.
Slight reduction in time that the lock has to be held.

[dgozman, 2016/06/29 01:17:33]

Done.

+}
 
-        m_isOnLine = onLine;
-    }
+NetworkStateNotifier::ScopedNotifier::~ScopedNotifier()
+{
+    const NetworkState& after = m_notifier.m_hasOverride ? m_notifier.m_override : m_notifier.m_state;
+    if (after.type != m_before.type || after.maxBandwidthMbps != m_before.maxBandwidthMbps || (after.connectionInitialized && !m_before.connectionInitialized))
+        m_notifier.notifyObservers(after.type, after.maxBandwidthMbps);
+    bool onLineValue = after.onLine;

[jkarlin, 2016/06/28 17:57:11]

Why make this copy? The value won't change while in this function since we're on
the main thread.

[dgozman, 2016/06/29 01:17:33]

Done.

+    bool onLineChanged = after.onLine != m_before.onLine || (after.onLineInitialized && !m_before.onLineInitialized);
+    m_notifier.m_mutex.unlock();

[jkarlin, 2016/06/28 17:57:11]

Can you add a comment somewhere around here that we must unlock before calling
Page::NetworkStateChanged to prevent deadlock? That, or, preferably PostTask the
networkStateChanged call so we don't have to worry about it. 

[dgozman, 2016/06/29 01:17:33]

I've added a comment about this. Doing a PostTask is unnecessary, so I'd rather
avoid it.

+    if (onLineChanged)
+        Page::networkStateChanged(onLineValue);
+}
 
-    Page::networkStateChanged(onLine);
+void NetworkStateNotifier::setOnLine(bool onLine)
+{
+    DCHECK(isMainThread());
+    ScopedNotifier notifier(*this);
+    m_state.onLineInitialized = true;
+    m_state.onLine = onLine;
 }
 
 void NetworkStateNotifier::setWebConnection(WebConnectionType type, double maxBandwidthMbps)
 {
-    ASSERT(isMainThread());
-    if (m_testUpdatesOnly)
-        return;
-
-    setWebConnectionImpl(type, maxBandwidthMbps);
+    DCHECK(isMainThread());
+    ScopedNotifier notifier(*this);
+    m_state.connectionInitialized = true;
+    m_state.type = type;
+    m_state.maxBandwidthMbps = maxBandwidthMbps;
 }
 
 void NetworkStateNotifier::addObserver(NetworkStateObserver* observer, ExecutionContext* context)
@@ -100,40 +113,28 @@ void NetworkStateNotifier::removeObserver(NetworkStateObserver* observer, Execut
         collectZeroedObservers(observerList, context);
 }
 
-void NetworkStateNotifier::setTestUpdatesOnly(bool updatesOnly)
+void NetworkStateNotifier::setOverride(bool onLine, WebConnectionType type, double maxBandwidthMbps)
 {
-    ASSERT(isMainThread());
-    MutexLocker locker(m_mutex);
-
-    // Reset state to default when entering or leaving test mode.
-    if (updatesOnly != m_testUpdatesOnly) {
-        m_isOnLine = true;
-        m_type = WebConnectionTypeOther;
-        m_maxBandwidthMbps = std::numeric_limits<double>::infinity();
-    }
-
-    m_testUpdatesOnly = updatesOnly;
+    DCHECK(isMainThread());
+    ScopedNotifier notifier(*this);
+    m_hasOverride = true;
+    m_override.onLineInitialized = true;
+    m_override.onLine = onLine;
+    m_override.connectionInitialized = true;
+    m_override.type = type;
+    m_override.maxBandwidthMbps = maxBandwidthMbps;
 }
 
-void NetworkStateNotifier::setWebConnectionForTest(WebConnectionType type, double maxBandwidthMbps)
+void NetworkStateNotifier::clearOverride()
 {
-    ASSERT(isMainThread());
-    ASSERT(m_testUpdatesOnly);
-    setWebConnectionImpl(type, maxBandwidthMbps);
+    DCHECK(isMainThread());
+    ScopedNotifier notifier(*this);
+    m_hasOverride = false;
 }
 
-void NetworkStateNotifier::setWebConnectionImpl(WebConnectionType type, double maxBandwidthMbps)
+void NetworkStateNotifier::notifyObservers(WebConnectionType type, double maxBandwidthMbps)
 {
-    ASSERT(isMainThread());
-
-    MutexLocker locker(m_mutex);
-    m_initialized = true;
-
-    if (m_type == type && m_maxBandwidthMbps == maxBandwidthMbps)
-        return;
-    m_type = type;
-    m_maxBandwidthMbps = maxBandwidthMbps;
-
+    DCHECK(isMainThread());
     for (const auto& entry : m_observers) {
         ExecutionContext* context = entry.key;
         context->postTask(BLINK_FROM_HERE, createCrossThreadTask(&NetworkStateNotifier::notifyObserversOfConnectionChangeOnContext, crossThreadUnretained(this), type, maxBandwidthMbps));