Oilpan: Tidily dispose of FetchManager loader objects.

Source/modules/fetch/FetchManager.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "modules/fetch/FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 31 matching lines @@
     void trace(Visitor*) override;
 
     void didReceiveResponse(unsigned long, const ResourceResponse&, PassOwnPtr<WebDataConsumerHandle>) override;
     void didReceiveData(const char*, unsigned) override;
     void didFinishLoading(unsigned long, double) override;
     void didFail(const ResourceError&) override;
     void didFailAccessControlCheck(const ResourceError&) override;
     void didFailRedirectCheck() override;
 
     void start();
-    void cleanup();
+    void dispose();
 
 private:
     Loader(ExecutionContext*, FetchManager*, PassRefPtrWillBeRawPtr<ScriptPromiseResolver>, const FetchRequestData*);
 
     void performBasicFetch();
     void performNetworkError(const String& message);
     void performHTTPFetch(bool corsFlag, bool corsPreflightFlag);
     void failed(const String& message);
     void notifyFinished();
 
     RawPtrWillBeMember<FetchManager> m_fetchManager;
     RefPtrWillBeMember<ScriptPromiseResolver> m_resolver;
     PersistentWillBeMember<FetchRequestData> m_request;
     PersistentWillBeMember<BodyStreamBuffer> m_responseBuffer;
     RefPtr<ThreadableLoader> m_loader;
     bool m_failed;
 };
 
 FetchManager::Loader::Loader(ExecutionContext* executionContext, FetchManager* fetchManager, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver, const FetchRequestData* request)
     : ContextLifecycleObserver(executionContext)
     , m_fetchManager(fetchManager)
     , m_resolver(resolver)
     , m_request(request->createCopy())
     , m_failed(false)
 {
 }
 
 FetchManager::Loader::~Loader()
 {
-    if (m_loader)
-        m_loader->cancel();
+    ASSERT(!m_loader);
 }
 
 void FetchManager::Loader::trace(Visitor* visitor)
 {
     visitor->trace(m_fetchManager);
     visitor->trace(m_resolver);
     visitor->trace(m_request);
     visitor->trace(m_responseBuffer);
     ContextLifecycleObserver::trace(visitor);
 }
@@ skipping 155 matching lines @@
     }
 
     // "- Otherwise
     //     Set |request|'s response tainting to |CORS|."
     m_request->setResponseTainting(FetchRequestData::CORSTainting);
     // "The result of performing an HTTP fetch using |request| with the
     // |CORS flag| set."
     performHTTPFetch(true, false);
 }
 
-void FetchManager::Loader::cleanup()
+void FetchManager::Loader::dispose()
 {
     // Prevent notification
-    m_fetchManager = 0;
-
+    m_fetchManager = nullptr;
     if (m_loader) {
         m_loader->cancel();
         m_loader.clear();
     }
 }
 
 void FetchManager::Loader::performBasicFetch()
 {
     // "To perform a basic fetch using |request|, switch on |request|'s url's
     // scheme, and run the associated steps:"
@@ skipping 133 matching lines @@
     OwnPtrWillBeRawPtr<Loader> ownLoader = Loader::create(m_executionContext, this, resolver.release(), request);
     Loader* loader = m_loaders.add(ownLoader.release()).storedValue->get();
     loader->start();
     return promise;
 }
 
 void FetchManager::stop()
 {
     ASSERT(!m_isStopped);
     m_isStopped = true;
-    for (auto& loader : m_loaders) {
-        loader->cleanup();
-    }
+    for (auto& loader : m_loaders)
+        loader->dispose();
 }
 
 void FetchManager::onLoaderFinished(Loader* loader)
 {
     // We don't use remove here, because it may cause recursive deletion.
     OwnPtrWillBeRawPtr<Loader> p = m_loaders.take(loader);
-    ALLOW_UNUSED_LOCAL(p);
+    ASSERT(p);
+    p->dispose();
 }
 
 void FetchManager::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_executionContext);
     visitor->trace(m_loaders);
 #endif
 }
 
 } // namespace blink