Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/loader/DocumentLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * 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 141 matching lines @@
     return m_request;
 }
 
 const KURL& DocumentLoader::url() const
 {
     return m_request.url();
 }
 
 Resource* DocumentLoader::startPreload(Resource::Type type, FetchRequest& request)
 {
-    RefPtrWillBeRawPtr<Resource> resource = nullptr;
+    RawPtr<Resource> resource = nullptr;
     switch (type) {
     case Resource::Image:
         resource = ImageResource::fetch(request, fetcher());
         break;
     case Resource::Script:
         resource = ScriptResource::fetch(request, fetcher());
         break;
     case Resource::CSSStyleSheet:
         resource = CSSStyleSheetResource::fetch(request, fetcher());
         break;
@@ skipping 62 matching lines @@
     frameLoader()->receivedMainResourceError(this, error);
     clearMainResourceHandle();
 }
 
 // Cancels the data source's pending loads.  Conceptually, a data source only loads
 // one document at a time, but one document may have many related resources.
 // stopLoading will stop all loads initiated by the data source,
 // but not loads initiated by child frames' data sources -- that's the WebFrame's job.
 void DocumentLoader::stopLoading()
 {
-    RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame.get());
-    RefPtrWillBeRawPtr<DocumentLoader> protectLoader(this);
+    RawPtr<LocalFrame> protectFrame(m_frame.get());
+    RawPtr<DocumentLoader> protectLoader(this);
 
     if (isLoading())
         cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
     m_fetcher->stopFetching();
 }
 
 void DocumentLoader::commitIfReady()
 {
     if (m_state < Committed) {
         m_state = Committed;
         frameLoader()->commitProvisionalLoad();
     }
 }
 
 bool DocumentLoader::isLoading() const
 {
     if (document() && document()->hasActiveParser())
         return true;
 
     return (m_state > NotStarted && m_state < MainResourceDone) || m_fetcher->isFetching();
 }
 
 void DocumentLoader::notifyFinished(Resource* resource)
 {
     ASSERT_UNUSED(resource, m_mainResource == resource);
     ASSERT(m_mainResource);
 
-    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
+    RawPtr<DocumentLoader> protect(this);
 
     if (!m_mainResource->errorOccurred() && !m_mainResource->wasCanceled()) {
         finishedLoading(m_mainResource->loadFinishTime());
         return;
     }
 
     mainReceivedError(m_mainResource->resourceError());
 }
 
 void DocumentLoader::finishedLoading(double finishTime)
 {
     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading() || InspectorInstrumentation::isDebuggerPaused(m_frame));
 
-    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
+    RawPtr<DocumentLoader> protect(this);
 
     double responseEndTime = finishTime;
     if (!responseEndTime)
         responseEndTime = m_timeOfLastDataReceived;
     if (!responseEndTime)
         responseEndTime = monotonicallyIncreasingTime();
     timing().setResponseEnd(responseEndTime);
 
     commitIfReady();
     if (!frameLoader())
@@ skipping 87 matching lines @@
     // The load event might have detached this frame. In that case, the load will already have been cancelled during detach.
     if (frameLoader())
         cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
     return;
 }
 
 void DocumentLoader::responseReceived(Resource* resource, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
 {
     ASSERT_UNUSED(resource, m_mainResource == resource);
     ASSERT_UNUSED(handle, !handle);
-    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
+    RawPtr<DocumentLoader> protect(this);
     ASSERT(frame());
 
     m_applicationCacheHost->didReceiveResponseForMainResource(response);
 
     // The memory cache doesn't understand the application cache or its caching rules. So if a main resource is served
     // from the application cache, ensure we don't save the result for future use. All responses loaded
     // from appcache will have a non-zero appCacheID().
     if (response.appCacheID())
         memoryCache()->remove(m_mainResource.get());
 
     m_contentSecurityPolicy = ContentSecurityPolicy::create();
     m_contentSecurityPolicy->setOverrideURLForSelf(response.url());
     m_contentSecurityPolicy->didReceiveHeaders(ContentSecurityPolicyResponseHeaders(response));
     if (!m_contentSecurityPolicy->allowAncestors(m_frame, response.url())) {
         cancelLoadAfterXFrameOptionsOrCSPDenied(response);
         return;
     }
 
     // 'frame-ancestors' obviates 'x-frame-options': https://w3c.github.io/webappsec/specs/content-security-policy/#frame-ancestors-and-frame-options
     if (!m_contentSecurityPolicy->isFrameAncestorsEnforced()) {
         HTTPHeaderMap::const_iterator it = response.httpHeaderFields().find(HTTPNames::X_Frame_Options);
         if (it != response.httpHeaderFields().end()) {
             String content = it->value;
             if (frameLoader()->shouldInterruptLoadForXFrameOptions(content, response.url(), mainResourceIdentifier())) {
                 String message = "Refused to display '" + response.url().elidedString() + "' in a frame because it set 'X-Frame-Options' to '" + content + "'.";
-                RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, message);
+                RawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, message);
                 consoleMessage->setRequestIdentifier(mainResourceIdentifier());
                 frame()->document()->addConsoleMessage(consoleMessage.release());
 
                 cancelLoadAfterXFrameOptionsOrCSPDenied(response);
                 return;
             }
         }
     }
 
     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading());
@@ skipping 79 matching lines @@
         // loop:
         // - alert(), confirm(), prompt()
         // - Detach of plugin elements.
         // - Synchronous XMLHTTPRequest
         m_dataBuffer->append(data, length);
         return;
     }
 
     // Both unloading the old page and parsing the new page may execute JavaScript which destroys the datasource
     // by starting a new load, so retain temporarily.
-    RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame.get());
-    RefPtrWillBeRawPtr<DocumentLoader> protectLoader(this);
+    RawPtr<LocalFrame> protectFrame(m_frame.get());
+    RawPtr<DocumentLoader> protectLoader(this);
 
     TemporaryChange<bool> reentrancyProtector(m_inDataReceived, true);
     processData(data, length);
 
     // Process data received in reentrant invocations. Note that the
     // invocations of processData() may queue more data in reentrant
     // invocations, so iterate until it's empty.
     const char* segment;
     size_t pos = 0;
     while (size_t length = m_dataBuffer->getSomeData(segment, pos)) {
@@ skipping 33 matching lines @@
 }
 
 bool DocumentLoader::loadingMultipartContent() const
 {
     return mainResourceLoader() ? mainResourceLoader()->loadingMultipartContent() : false;
 }
 
 void DocumentLoader::detachFromFrame()
 {
     ASSERT(m_frame);
-    RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame.get());
-    RefPtrWillBeRawPtr<DocumentLoader> protectLoader(this);
+    RawPtr<LocalFrame> protectFrame(m_frame.get());
+    RawPtr<DocumentLoader> protectLoader(this);
 
     // It never makes sense to have a document loader that is detached from its
     // frame have any loads active, so go ahead and kill all the loads.
     stopLoading();
 
     // If that load cancellation triggered another detach, leave.
     // (fast/frames/detach-frame-nested-no-crash.html is an example of this.)
     if (!m_frame)
         return;
 
@@ skipping 64 matching lines @@
 
     if (m_request.url().isEmpty() && !frameLoader()->stateMachine()->creatingInitialEmptyDocument())
         m_request.setURL(blankURL());
     m_response = ResourceResponse(m_request.url(), "text/html", 0, nullAtom, String());
     finishedLoading(monotonicallyIncreasingTime());
     return true;
 }
 
 void DocumentLoader::startLoadingMainResource()
 {
-    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
+    RawPtr<DocumentLoader> protect(this);
     timing().markNavigationStart();
     ASSERT(!m_mainResource);
     ASSERT(m_state == NotStarted);
     m_state = Provisional;
 
     if (maybeLoadEmpty())
         return;
 
     ASSERT(timing().navigationStart());
     ASSERT(!timing().fetchStart());
@@ skipping 24 matching lines @@
         request = mainResourceLoader()->originalRequest();
     // If there was a fragment identifier on m_request, the cache will have stripped it. m_request should include
     // the fragment identifier, so add that back in.
     if (equalIgnoringFragmentIdentifier(m_request.url(), request.url()))
         request.setURL(m_request.url());
     m_request = request;
 }
 
 void DocumentLoader::cancelMainResourceLoad(const ResourceError& resourceError)
 {
-    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
+    RawPtr<DocumentLoader> protect(this);
     ResourceError error = resourceError.isNull() ? ResourceError::cancelledError(m_request.url()) : resourceError;
 
     if (mainResourceLoader())
         mainResourceLoader()->cancel(error);
 
     mainReceivedError(error);
 }
 
-void DocumentLoader::attachThreadedDataReceiver(PassRefPtrWillBeRawPtr<ThreadedDataReceiver> threadedDataReceiver)
+void DocumentLoader::attachThreadedDataReceiver(RawPtr<ThreadedDataReceiver> threadedDataReceiver)
 {
     if (mainResourceLoader())
         mainResourceLoader()->attachThreadedDataReceiver(threadedDataReceiver);
 }
 
 void DocumentLoader::acceptDataFromThreadedReceiver(const char* data, int dataLength, int encodedDataLength)
 {
     m_fetcher->acceptDataFromThreadedReceiver(mainResourceIdentifier(), data, dataLength, encodedDataLength);
 }
 
 void DocumentLoader::endWriting(DocumentWriter* writer)
 {
     ASSERT_UNUSED(writer, m_writer == writer);
     m_writer->end();
     m_writer.clear();
 }
 
-PassRefPtrWillBeRawPtr<DocumentWriter> DocumentLoader::createWriterFor(const Document* ownerDocument, const DocumentInit& init, const AtomicString& mimeType, const AtomicString& encoding, bool dispatch, ParserSynchronizationPolicy parsingPolicy)
+RawPtr<DocumentWriter> DocumentLoader::createWriterFor(const Document* ownerDocument, const DocumentInit& init, const AtomicString& mimeType, const AtomicString& encoding, bool dispatch, ParserSynchronizationPolicy parsingPolicy)
 {
     LocalFrame* frame = init.frame();
 
     ASSERT(!frame->document() || !frame->document()->isActive());
     ASSERT(frame->tree().childCount() == 0);
 
     if (!init.shouldReuseDefaultView())
         frame->setDOMWindow(LocalDOMWindow::create(*frame));
 
-    RefPtrWillBeRawPtr<Document> document = frame->localDOMWindow()->installNewDocument(mimeType, init);
+    RawPtr<Document> document = frame->localDOMWindow()->installNewDocument(mimeType, init);
     if (ownerDocument) {
         document->setCookieURL(ownerDocument->cookieURL());
         document->setSecurityOrigin(ownerDocument->securityOrigin());
     }
 
     frame->loader().didBeginDocument(dispatch);
 
     return DocumentWriter::create(document.get(), parsingPolicy, mimeType, encoding);
 }
 
 const AtomicString& DocumentLoader::mimeType() const
 {
     if (m_writer)
         return m_writer->mimeType();
     return m_response.mimeType();
 }
 
 // This is only called by FrameLoader::replaceDocumentWhileExecutingJavaScriptURL()
 void DocumentLoader::replaceDocumentWhileExecutingJavaScriptURL(const DocumentInit& init, const String& source, Document* ownerDocument)
 {
     m_writer = createWriterFor(ownerDocument, init, mimeType(), m_writer ? m_writer->encoding() : emptyAtom, true, ForceSynchronousParsing);
     if (!source.isNull())
         m_writer->appendReplacingData(source);
     endWriting(m_writer.get());
 }
 
 DEFINE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 } // namespace blink