Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/web/FrameLoaderClientImpl.cpp

 /*
  * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2011 Apple 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 111 matching lines @@
     return frame ? frame->toImplBase()->frame() : nullptr;
 }
 
 } // namespace
 
 FrameLoaderClientImpl::FrameLoaderClientImpl(WebLocalFrameImpl* frame)
     : m_webFrame(frame)
 {
 }
 
-PassOwnPtrWillBeRawPtr<FrameLoaderClientImpl> FrameLoaderClientImpl::create(WebLocalFrameImpl* frame)
+RawPtr<FrameLoaderClientImpl> FrameLoaderClientImpl::create(WebLocalFrameImpl* frame)
 {
-    return adoptPtrWillBeNoop(new FrameLoaderClientImpl(frame));
+    return new FrameLoaderClientImpl(frame);
 }
 
 FrameLoaderClientImpl::~FrameLoaderClientImpl()
 {
 }
 
 DEFINE_TRACE(FrameLoaderClientImpl)
 {
     visitor->trace(m_webFrame);
     FrameLoaderClient::trace(visitor);
@@ skipping 230 matching lines @@
 
 void FrameLoaderClientImpl::willBeDetached()
 {
     m_webFrame->willBeDetached();
 }
 
 void FrameLoaderClientImpl::detached(FrameDetachType type)
 {
     // Alert the client that the frame is being detached. This is the last
     // chance we have to communicate with the client.
-    RefPtrWillBeRawPtr<WebLocalFrameImpl> protector(m_webFrame.get());
+    RawPtr<WebLocalFrameImpl> protector(m_webFrame.get());
 
     WebFrameClient* client = m_webFrame->client();
     if (!client)
         return;
 
     m_webFrame->willDetachParent();
 
     // Signal that no further communication with WebFrameClient should take
     // place at this point since we are no longer associated with the Page.
     m_webFrame->setClient(0);
@@ skipping 331 matching lines @@
     if (m_webFrame->client())
         m_webFrame->client()->didChangePerformanceTiming();
 }
 
 void FrameLoaderClientImpl::selectorMatchChanged(const Vector<String>& addedSelectors, const Vector<String>& removedSelectors)
 {
     if (WebFrameClient* client = m_webFrame->client())
         client->didMatchCSS(m_webFrame, WebVector<WebString>(addedSelectors), WebVector<WebString>(removedSelectors));
 }
 
-PassRefPtrWillBeRawPtr<DocumentLoader> FrameLoaderClientImpl::createDocumentLoader(LocalFrame* frame, const ResourceRequest& request, const SubstituteData& data)
+RawPtr<DocumentLoader> FrameLoaderClientImpl::createDocumentLoader(LocalFrame* frame, const ResourceRequest& request, const SubstituteData& data)
 {
-    RefPtrWillBeRawPtr<WebDataSourceImpl> ds = WebDataSourceImpl::create(frame, request, data);
+    RawPtr<WebDataSourceImpl> ds = WebDataSourceImpl::create(frame, request, data);
     if (m_webFrame->client())
         m_webFrame->client()->didCreateDataSource(m_webFrame, ds.get());
     return ds.release();
 }
 
 String FrameLoaderClientImpl::userAgent()
 {
     WebString override = m_webFrame->client()->userAgentOverride();
     if (!override.isEmpty())
         return override;
@@ skipping 11 matching lines @@
     return String();
 }
 
 // Called when the FrameLoader goes into a state in which a new page load
 // will occur.
 void FrameLoaderClientImpl::transitionToCommittedForNewPage()
 {
     m_webFrame->createFrameView();
 }
 
-PassRefPtrWillBeRawPtr<LocalFrame> FrameLoaderClientImpl::createFrame(
+RawPtr<LocalFrame> FrameLoaderClientImpl::createFrame(
     const FrameLoadRequest& request,
     const AtomicString& name,
     HTMLFrameOwnerElement* ownerElement)
 {
     return m_webFrame->createChildFrame(request, name, ownerElement);
 }
 
 bool FrameLoaderClientImpl::canCreatePluginWithoutRenderer(const String& mimeType) const
 {
     if (!m_webFrame->client())
         return false;
 
     return m_webFrame->client()->canCreatePluginWithoutRenderer(mimeType);
 }
 
-PassRefPtrWillBeRawPtr<Widget> FrameLoaderClientImpl::createPlugin(
+RawPtr<Widget> FrameLoaderClientImpl::createPlugin(
     HTMLPlugInElement* element,
     const KURL& url,
     const Vector<String>& paramNames,
     const Vector<String>& paramValues,
     const String& mimeType,
     bool loadManually,
     DetachedPluginPolicy policy)
 {
     if (!m_webFrame->client())
         return nullptr;
 
     WebPluginParams params;
     params.url = url;
     params.mimeType = mimeType;
     params.attributeNames = paramNames;
     params.attributeValues = paramValues;
     params.loadManually = loadManually;
 
     WebPlugin* webPlugin = m_webFrame->client()->createPlugin(m_webFrame, params);
     if (!webPlugin)
         return nullptr;
 
     // The container takes ownership of the WebPlugin.
-    RefPtrWillBeRawPtr<WebPluginContainerImpl> container =
+    RawPtr<WebPluginContainerImpl> container =
         WebPluginContainerImpl::create(element, webPlugin);
 
     if (!webPlugin->initialize(container.get()))
         return nullptr;
 
     if (policy != AllowDetachedPlugin && !element->layoutObject())
         return nullptr;
 
     return container;
 }
@@ skipping 222 matching lines @@
 }
 
 void FrameLoaderClientImpl::suddenTerminationDisablerChanged(bool present, SuddenTerminationDisablerType type)
 {
     if (m_webFrame->client()) {
         m_webFrame->client()->suddenTerminationDisablerChanged(
             present, static_cast<WebFrameClient::SuddenTerminationDisablerType>(type));
     }
 }
 
-PassOwnPtrWillBeRawPtr<LinkResource> FrameLoaderClientImpl::createServiceWorkerLinkResource(HTMLLinkElement* owner)
+RawPtr<LinkResource> FrameLoaderClientImpl::createServiceWorkerLinkResource(HTMLLinkElement* owner)
 {
     return ServiceWorkerLinkResource::create(owner);
 }
 
 } // namespace blink