Make ScriptPromiseResolver RefCountedWillBeRefCountedGarbageCollected.

Source/modules/serviceworkers/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 "FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 11 matching lines @@
 #include "modules/serviceworkers/ResponseInit.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/HashSet.h"
 
 namespace blink {
 
 class FetchManager::Loader : public ThreadableLoaderClient {
 public:
-    Loader(ExecutionContext*, FetchManager*, PassRefPtr<ScriptPromiseResolver>, const FetchRequestData*);
+    Loader(ExecutionContext*, FetchManager*, PassRefPtrWillBeRawPtr<ScriptPromiseResolver>, const FetchRequestData*);
     ~Loader() 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();
 
 private:
     void performBasicFetch();
     void performNetworkError(const String& message);
     void performHTTPFetch();
     void failed(const String& message);
     void notifyFinished();
 
     ExecutionContext* m_executionContext;
     FetchManager* m_fetchManager;
-    RefPtr<ScriptPromiseResolver> m_resolver;
+    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
     Persistent<FetchRequestData> m_request;
     Persistent<BodyStreamBuffer> m_responseBuffer;
     RefPtr<ThreadableLoader> m_loader;
     bool m_corsFlag;
     bool m_corsPreflightFlag;
     bool m_failed;
 };
 
-FetchManager::Loader::Loader(ExecutionContext* executionContext, FetchManager* fetchManager, PassRefPtr<ScriptPromiseResolver> resolver, const FetchRequestData* request)
+FetchManager::Loader::Loader(ExecutionContext* executionContext, FetchManager* fetchManager, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver, const FetchRequestData* request)
     : m_executionContext(executionContext)
     , m_fetchManager(fetchManager)
     , m_resolver(resolver)
     , m_request(request->createCopy())
     , m_corsFlag(false)
     , m_corsPreflightFlag(false)
     , m_failed(false)
 {
 }
 
@@ skipping 279 matching lines @@
 }
 
 FetchManager::~FetchManager()
 {
     if (!m_isStopped)
         stop();
 }
 
 ScriptPromise FetchManager::fetch(ScriptState* scriptState, const FetchRequestData* request)
 {
-    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     OwnPtr<Loader> ownLoader(adoptPtr(new Loader(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();
     }
 }
 
 void FetchManager::onLoaderFinished(Loader* loader)
 {
     // We don't use remove here, becuase it may cause recursive deletion.
     OwnPtr<Loader> p = m_loaders.take(loader);
 }
 
 } // namespace blink