Remove dependency from NetworkStateNotifier to ExecutionContext

third_party/WebKit/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 "core/page/NetworkStateNotifier.h"
 
-#include "core/dom/ExecutionContext.h"
-#include "core/dom/ExecutionContextTask.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/page/Page.h"
+#include "platform/CrossThreadFunctional.h"
 #include "wtf/Assertions.h"
 #include "wtf/Functional.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Threading.h"
 
 namespace blink {
 
 NetworkStateNotifier& networkStateNotifier() {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(NetworkStateNotifier, networkStateNotifier,
@@ skipping 37 matching lines @@
   ScopedNotifier notifier(*this);
   {
     MutexLocker locker(m_mutex);
     m_state.connectionInitialized = true;
     m_state.type = type;
     m_state.maxBandwidthMbps = maxBandwidthMbps;
   }
 }
 
 void NetworkStateNotifier::addObserver(NetworkStateObserver* observer,
-                                       ExecutionContext* context) {
-  ASSERT(context->isContextThread());
-  ASSERT(observer);
+                                       WebTaskRunner* taskRunner) {
+  DCHECK(taskRunner->runsTasksOnCurrentThread());
+  DCHECK(observer);
 
   MutexLocker locker(m_mutex);
-  ObserverListMap::AddResult result = m_observers.insert(context, nullptr);
+  ObserverListMap::AddResult result = m_observers.insert(taskRunner, nullptr);
   if (result.isNewEntry)
     result.storedValue->value = WTF::wrapUnique(new ObserverList);
 
-  ASSERT(result.storedValue->value->observers.find(observer) == kNotFound);
+  DCHECK(result.storedValue->value->observers.find(observer) == kNotFound);
   result.storedValue->value->observers.push_back(observer);
 }
 
 void NetworkStateNotifier::removeObserver(NetworkStateObserver* observer,
-                                          ExecutionContext* context) {
-  ASSERT(context->isContextThread());
-  ASSERT(observer);
+                                          WebTaskRunner* taskRunner) {
+  DCHECK(taskRunner->runsTasksOnCurrentThread());
+  DCHECK(observer);
 
-  ObserverList* observerList = lockAndFindObserverList(context);
+  ObserverList* observerList = lockAndFindObserverList(taskRunner);
   if (!observerList)
     return;
 
   Vector<NetworkStateObserver*>& observers = observerList->observers;
   size_t index = observers.find(observer);
   if (index != kNotFound) {
     observers[index] = 0;
     observerList->zeroedObservers.push_back(index);
   }
 
   if (!observerList->iterating && !observerList->zeroedObservers.isEmpty())
-    collectZeroedObservers(observerList, context);
+    collectZeroedObservers(observerList, taskRunner);
 }
 
 void NetworkStateNotifier::setOverride(bool onLine,
                                        WebConnectionType type,
                                        double maxBandwidthMbps) {
   DCHECK(isMainThread());
   ScopedNotifier notifier(*this);
   {
     MutexLocker locker(m_mutex);
     m_hasOverride = true;
@@ skipping 10 matching lines @@
   ScopedNotifier notifier(*this);
   {
     MutexLocker locker(m_mutex);
     m_hasOverride = false;
   }
 }
 
 void NetworkStateNotifier::notifyObservers(WebConnectionType type,
                                            double maxBandwidthMbps) {
   DCHECK(isMainThread());
+  MutexLocker locker(m_mutex);

[jkarlin, 2017/02/15 19:26:33]

Phew. Thanks for this! Looks like it got deleted in a previous patch and I
missed it.

   for (const auto& entry : m_observers) {
-    ExecutionContext* context = entry.key;
-    context->postTask(
-        TaskType::Networking, BLINK_FROM_HERE,
-        createCrossThreadTask(
+    WebTaskRunner* taskRunner = entry.key;
+    taskRunner->postTask(
+        BLINK_FROM_HERE,
+        crossThreadBind(
             &NetworkStateNotifier::notifyObserversOfConnectionChangeOnContext,
-            crossThreadUnretained(this), type, maxBandwidthMbps));
+            crossThreadUnretained(this), type, maxBandwidthMbps,
+            crossThreadUnretained(taskRunner)));
   }
 }
 
 void NetworkStateNotifier::notifyObserversOfConnectionChangeOnContext(

[jkarlin, 2017/02/15 19:26:33]

Please rename this to ...OnTaskRunner

[kinuko, 2017/02/16 03:55:00]

Done. Thanks =)

     WebConnectionType type,
     double maxBandwidthMbps,
-    ExecutionContext* context) {
-  ObserverList* observerList = lockAndFindObserverList(context);
+    WebTaskRunner* taskRunner) {
+  ObserverList* observerList = lockAndFindObserverList(taskRunner);
 
   // The context could have been removed before the notification task got to
   // run.
   if (!observerList)
     return;
 
-  ASSERT(context->isContextThread());
+  DCHECK(taskRunner->runsTasksOnCurrentThread());
 
   observerList->iterating = true;
 
   for (size_t i = 0; i < observerList->observers.size(); ++i) {
     // Observers removed during iteration are zeroed out, skip them.
     if (observerList->observers[i])
       observerList->observers[i]->connectionChange(type, maxBandwidthMbps);
   }
 
   observerList->iterating = false;
 
   if (!observerList->zeroedObservers.isEmpty())
-    collectZeroedObservers(observerList, context);
+    collectZeroedObservers(observerList, taskRunner);
 }
 
 NetworkStateNotifier::ObserverList*
-NetworkStateNotifier::lockAndFindObserverList(ExecutionContext* context) {
+NetworkStateNotifier::lockAndFindObserverList(WebTaskRunner* taskRunner) {
   MutexLocker locker(m_mutex);
-  ObserverListMap::iterator it = m_observers.find(context);
+  ObserverListMap::iterator it = m_observers.find(taskRunner);
   return it == m_observers.end() ? nullptr : it->value.get();
 }
 
 void NetworkStateNotifier::collectZeroedObservers(ObserverList* list,
-                                                  ExecutionContext* context) {
-  ASSERT(context->isContextThread());
-  ASSERT(!list->iterating);
+                                                  WebTaskRunner* taskRunner) {
+  DCHECK(taskRunner->runsTasksOnCurrentThread());
+  DCHECK(!list->iterating);
 
   // If any observers were removed during the iteration they will have
   // 0 values, clean them up.
   for (size_t i = 0; i < list->zeroedObservers.size(); ++i)
     list->observers.remove(list->zeroedObservers[i]);
 
   list->zeroedObservers.clear();
 
   if (list->observers.isEmpty()) {
     MutexLocker locker(m_mutex);
-    m_observers.erase(context);  // deletes list
+    m_observers.erase(taskRunner);  // deletes list
   }
 }
 
 }  // namespace blink