Make WebTaskRunner ThreadSafeRefCounted

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

 /*
  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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.
@@ skipping 54 matching lines @@
 ResourceLoader::~ResourceLoader() {
   DCHECK(!m_loader);
 }
 
 DEFINE_TRACE(ResourceLoader) {
   visitor->trace(m_fetcher);
   visitor->trace(m_resource);
 }
 
 void ResourceLoader::start(const ResourceRequest& request,
-                           WebTaskRunner* loadingTaskRunner,
+                           RefPtr<WebTaskRunner> loadingTaskRunner,
                            bool defersLoading) {
   DCHECK(!m_loader);
   if (m_resource->options().synchronousPolicy == RequestSynchronously &&
       defersLoading) {
     cancel();
     return;
   }
 
   m_loader = wrapUnique(Platform::current()->createURLLoader());
   DCHECK(m_loader);
   m_loader->setDefersLoading(defersLoading);
-  m_loader->setLoadingTaskRunner(loadingTaskRunner);
+  m_loader->setLoadingTaskRunner(loadingTaskRunner.get());

[haraken, 2016/12/08 01:49:02]

Why do we need get()?

[tzik, 2016/12/12 12:18:52]

eOn 2016/12/08 01:49:02, haraken wrote:
Since WebURLLoader is in public/platform, we are using a raw pointer there, so
we need a conversion from the RefPtr to the raw pointer.

 
   if (m_isCacheAwareLoadingActivated) {
     // Override cache policy for cache-aware loading. If this request fails, a
     // reload with original request will be triggered in didFail().
     ResourceRequest cacheAwareRequest(request);
     cacheAwareRequest.setCachePolicy(WebCachePolicy::ReturnCacheDataIfValid);
     m_loader->loadAsynchronously(WrappedResourceRequest(cacheAwareRequest),
                                  this);
     return;
   }
 
   if (m_resource->options().synchronousPolicy == RequestSynchronously)
     requestSynchronously(request);
   else
     m_loader->loadAsynchronously(WrappedResourceRequest(request), this);
 }
 
 void ResourceLoader::restart(const ResourceRequest& request,
-                             WebTaskRunner* loadingTaskRunner,
+                             RefPtr<WebTaskRunner> loadingTaskRunner,
                              bool defersLoading) {
   CHECK_EQ(m_resource->options().synchronousPolicy, RequestAsynchronously);
   m_loader.reset();
-  start(request, loadingTaskRunner, defersLoading);
+  start(request, std::move(loadingTaskRunner), defersLoading);
 }
 
 void ResourceLoader::setDefersLoading(bool defers) {
   DCHECK(m_loader);
   m_loader->setDefersLoading(defers);
 }
 
 void ResourceLoader::didDownloadData(int length, int encodedDataLength) {
   m_fetcher->didDownloadData(m_resource.get(), length, encodedDataLength);
   m_resource->didDownloadData(length);
@@ skipping 191 matching lines @@
     return;
 
   // Don't activate if cache policy is explicitly set.
   if (request.getCachePolicy() != WebCachePolicy::UseProtocolCachePolicy)
     return;
 
   m_isCacheAwareLoadingActivated = true;
 }
 
 }  // namespace blink