Scheduler: Deprecate CancellableTaskFactory in favor of WebTaskRunner::postCancellableTask

third_party/WebKit/Source/core/fetch/Resource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
@@ skipping 19 matching lines @@
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/IntegrityMetadata.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceClient.h"
 #include "core/fetch/ResourceClientWalker.h"
 #include "core/fetch/ResourceLoader.h"
 #include "platform/Histogram.h"
 #include "platform/InstanceCounters.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
+#include "platform/WebTaskRunner.h"
 #include "platform/network/HTTPParsers.h"
 #include "platform/tracing/TraceEvent.h"
 #include "platform/weborigin/KURL.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
@@ skipping 196 matching lines @@
  public:
   static ResourceCallback& callbackHandler();
   void schedule(Resource*);
   void cancel(Resource*);
   bool isScheduled(Resource*) const;
 
  private:
   ResourceCallback();
 
   void runTask();
-  std::unique_ptr<CancellableTaskFactory> m_callbackTaskFactory;
+  TaskHandle m_taskHandle;
   HashSet<Persistent<Resource>> m_resourcesWithPendingClients;
 };
 
 Resource::ResourceCallback& Resource::ResourceCallback::callbackHandler() {
   DEFINE_STATIC_LOCAL(ResourceCallback, callbackHandler, ());
   return callbackHandler;
 }
 
-Resource::ResourceCallback::ResourceCallback()
-    : m_callbackTaskFactory(
-          CancellableTaskFactory::create(this, &ResourceCallback::runTask)) {}
+Resource::ResourceCallback::ResourceCallback() {}
 
 void Resource::ResourceCallback::schedule(Resource* resource) {
-  if (!m_callbackTaskFactory->isPending()) {
-    Platform::current()
-        ->currentThread()
-        ->scheduler()
-        ->loadingTaskRunner()
-        ->postTask(BLINK_FROM_HERE, m_callbackTaskFactory->cancelAndCreate());
+  if (!m_taskHandle.isActive()) {
+    // unretained(this) is safe because a posted task is canceled when
+    // |m_taskHandle| is destroyed on the dtor of this ResourceCallback.

[haraken, 2016/11/16 04:22:55]

tzik@: We prefer using wrapWeakPersistent(), right?

[tzik, 2016/11/16 04:45:33]

Since ResourceCallback is not GCed object, we need unretained here rather than
wrapWeakPersistent.

[haraken, 2016/11/16 05:02:55]

Makes sense.

BTW, what happens if we post a cancellable task with a wrapPersistent and keep
holding a task handle on |this| object? Will it cause a leak?

[nhiroki, 2016/11/16 05:54:01]

I guess the task just runs and then releases the reference to |this| on its
dtor.

+    m_taskHandle =
+        Platform::current()

[haraken, 2016/11/15 16:15:28]

Can we use TaskRunnerHelper or ParentFrameTaskRunner? Our plan is to also
deprecate Platform::current()->currentThread()->...->postTask() with
TaskRunnerHelper/ParentFrameTaskRunner.

[nhiroki, 2016/11/15 22:31:49]

I'd prefer to work on it in a separate CL because seemingly it needs more
extensive work to get Document/ExecutionContext/etc here for accessing a task
runner.

+            ->currentThread()
+            ->scheduler()
+            ->loadingTaskRunner()
+            ->postCancellableTask(
+                BLINK_FROM_HERE,
+                WTF::bind(&ResourceCallback::runTask, WTF::unretained(this)));
   }
   m_resourcesWithPendingClients.add(resource);
 }
 
 void Resource::ResourceCallback::cancel(Resource* resource) {
   m_resourcesWithPendingClients.remove(resource);
-  if (m_callbackTaskFactory->isPending() &&
-      m_resourcesWithPendingClients.isEmpty())
-    m_callbackTaskFactory->cancel();
+  if (m_taskHandle.isActive() && m_resourcesWithPendingClients.isEmpty())
+    m_taskHandle.cancel();
 }
 
 bool Resource::ResourceCallback::isScheduled(Resource* resource) const {
   return m_resourcesWithPendingClients.contains(resource);
 }
 
 void Resource::ResourceCallback::runTask() {
   HeapVector<Member<Resource>> resources;
   for (const Member<Resource>& resource : m_resourcesWithPendingClients)
     resources.append(resource.get());
@@ skipping 813 matching lines @@
     case Resource::TextTrack:
     case Resource::Media:
     case Resource::Manifest:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace blink