Oilpan: fix build after r178904.

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"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/fileapi/Blob.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/xml/XMLHttpRequest.h"
 #include "modules/serviceworkers/FetchRequestData.h"
 #include "modules/serviceworkers/Response.h"
 #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>, PassRefPtr<FetchRequestData>);
+    Loader(ExecutionContext*, FetchManager*, PassRefPtr<ScriptPromiseResolver>, PassRefPtrWillBeRawPtr<FetchRequestData>);
     ~Loader();
     virtual void didReceiveResponse(unsigned long, const ResourceResponse&);
     virtual void didFinishLoading(unsigned long, double);
     virtual void didFail(const ResourceError&);
     virtual void didFailAccessControlCheck(const ResourceError&);
     virtual void didFailRedirectCheck();
     virtual void didDownloadData(int);
 
     void start();
     void cleanup();
 
 private:
     void performBasicFetch();
     void performNetworkError();
     void performHTTPFetch();
     void failed();
     void notifyFinished();
 
     ExecutionContext* m_executionContext;
     FetchManager* m_fetchManager;
     RefPtr<ScriptPromiseResolver> m_resolver;
-    RefPtr<FetchRequestData> m_request;
+    RefPtrWillBePersistent<FetchRequestData> m_request;
     RefPtr<ThreadableLoader> m_loader;
     ResourceResponse m_response;
     long long m_downloadedBlobLength;
     bool m_corsFlag;
     bool m_corsPreflightFlag;
     bool m_failed;
 };
 
-FetchManager::Loader::Loader(ExecutionContext* executionContext, FetchManager* fetchManager, PassRefPtr<ScriptPromiseResolver> resolver, PassRefPtr<FetchRequestData> request)
+FetchManager::Loader::Loader(ExecutionContext* executionContext, FetchManager* fetchManager, PassRefPtr<ScriptPromiseResolver> resolver, PassRefPtrWillBeRawPtr<FetchRequestData> request)
     : m_executionContext(executionContext)
     , m_fetchManager(fetchManager)
     , m_resolver(resolver)
     , m_request(request->createCopy())
     , m_downloadedBlobLength(0)
     , m_corsFlag(false)
     , m_corsPreflightFlag(false)
     , m_failed(false)
 {
 }
@@ skipping 10 matching lines @@
 }
 
 void FetchManager::Loader::didFinishLoading(unsigned long, double)
 {
     OwnPtr<BlobData> blobData = BlobData::create();
     String filePath = m_response.downloadedFilePath();
     if (!filePath.isEmpty() && m_downloadedBlobLength) {
         blobData->appendFile(filePath);
         blobData->setContentType(m_response.mimeType());
     }
-    RefPtr<FetchResponseData> response(FetchResponseData::create());
+    RefPtrWillBeRawPtr<FetchResponseData> response(FetchResponseData::create());
     response->setStatus(m_response.httpStatusCode());
     response->setStatusMessage(m_response.httpStatusText());
     HTTPHeaderMap::const_iterator end = m_response.httpHeaderFields().end();
     for (HTTPHeaderMap::const_iterator it = m_response.httpHeaderFields().begin(); it != end; ++it) {
         response->headerList()->append(it->key, it->value);
     }
     response->setBlobDataHandle(BlobDataHandle::create(blobData.release(), m_downloadedBlobLength));
     response->setURL(m_request->url());
 
     switch (m_request->tainting()) {
@@ skipping 227 matching lines @@
 {
 }
 
 FetchManager::~FetchManager()
 {
     for (HashSet<OwnPtr<Loader> >::iterator it = m_loaders.begin(); it != m_loaders.end(); ++it) {
         (*it)->cleanup();
     }
 }
 
-ScriptPromise FetchManager::fetch(ScriptState* scriptState, PassRefPtr<FetchRequestData> request)
+ScriptPromise FetchManager::fetch(ScriptState* scriptState, PassRefPtrWillBeRawPtr<FetchRequestData> request)
 {
     RefPtr<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;
 }
 
@@ skipping 17 matching lines @@
 
 bool FetchManager::isUsefulMethod(const String& method)
 {
     // "A useful method is a method that is not a forbidden method."
     // "A forbidden method is a method that is a byte case-insensitive match for
     // one of `CONNECT`, `TRACE`, and `TRACK`."
     return XMLHttpRequest::isAllowedHTTPMethod(method);
 }
 
 } // namespace blink