Remove RawPtr from Source/web/

third_party/WebKit/Source/web/WebLocalFrameImpl.cpp

 /*
  * Copyright (C) 2009 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 525 matching lines @@
     return frameForContext(context);
 }
 
 WebLocalFrame* WebLocalFrame::frameForContext(v8::Local<v8::Context> context)
 {
     return WebLocalFrameImpl::fromFrame(toLocalFrame(toFrameIfNotDetached(context)));
 }
 
 WebLocalFrame* WebLocalFrame::fromFrameOwnerElement(const WebElement& element)
 {
-    return WebLocalFrameImpl::fromFrameOwnerElement(RawPtr<Element>(element).get());
+    return WebLocalFrameImpl::fromFrameOwnerElement(element);
 }
 
 bool WebLocalFrameImpl::isWebLocalFrame() const
 {
     return true;
 }
 
 WebLocalFrame* WebLocalFrameImpl::toWebLocalFrame()
 {
     return this;
@@ skipping 431 matching lines @@
     frame()->inputMethodController().cancelComposition();
 }
 
 bool WebLocalFrameImpl::hasMarkedText() const
 {
     return frame()->inputMethodController().hasComposition();
 }
 
 WebRange WebLocalFrameImpl::markedRange() const
 {
-    return frame()->inputMethodController().compositionRange();
+    return frame()->inputMethodController().compositionRange().get();
 }
 
 bool WebLocalFrameImpl::firstRectForCharacterRange(unsigned location, unsigned length, WebRect& rectInViewport) const
 {
     if ((location + length < location) && (location + length))
         length = 0;
 
     Element* editable = frame()->selection().rootEditableElementOrDocumentElement();
     if (!editable)
         return false;
@@ skipping 100 matching lines @@
     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
     if (pluginContainer)
         return pluginContainer->plugin()->hasSelection();
 
     // frame()->selection()->isNone() never returns true.
     return frame()->selection().start() != frame()->selection().end();
 }
 
 WebRange WebLocalFrameImpl::selectionRange() const
 {
-    return createRange(frame()->selection().selection().toNormalizedEphemeralRange());
+    return createRange(frame()->selection().selection().toNormalizedEphemeralRange()).get();
 }
 
 WebString WebLocalFrameImpl::selectionAsText() const
 {
     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
     if (pluginContainer)
         return pluginContainer->plugin()->selectionAsText();
 
     String text = frame()->selection().selectedText(TextIteratorEmitsObjectReplacementCharacter);
 #if OS(WIN)
@@ skipping 28 matching lines @@
 }
 
 void WebLocalFrameImpl::selectRange(const WebPoint& baseInViewport, const WebPoint& extentInViewport)
 {
     moveRangeSelection(baseInViewport, extentInViewport);
 }
 
 void WebLocalFrameImpl::selectRange(const WebRange& webRange)
 {
     TRACE_EVENT0("blink", "WebLocalFrameImpl::selectRange");
-    if (RawPtr<Range> range = static_cast<RawPtr<Range>>(webRange))
-        frame()->selection().setSelectedRange(range.get(), VP_DEFAULT_AFFINITY, SelectionDirectionalMode::NonDirectional, NotUserTriggered);
+    if (Range* range = static_cast<Range*>(webRange))
+        frame()->selection().setSelectedRange(range, VP_DEFAULT_AFFINITY, SelectionDirectionalMode::NonDirectional, NotUserTriggered);
 }
 
 void WebLocalFrameImpl::moveRangeSelectionExtent(const WebPoint& point)
 {
     TRACE_EVENT0("blink", "WebLocalFrameImpl::moveRangeSelectionExtent");
     frame()->selection().moveRangeSelectionExtent(frame()->view()->viewportToContents(point));
 }
 
 void WebLocalFrameImpl::moveRangeSelection(const WebPoint& baseInViewport, const WebPoint& extentInViewport, WebFrame::TextGranularity granularity)
 {
@@ skipping 230 matching lines @@
     frame->setOpener(opener);
 #if ENABLE(OILPAN)
     return frame;
 #else
     return adoptRef(frame).leakRef();
 #endif
 }
 
 WebLocalFrameImpl* WebLocalFrameImpl::createProvisional(WebFrameClient* client, WebRemoteFrame* oldWebFrame, WebSandboxFlags flags, const WebFrameOwnerProperties& frameOwnerProperties)
 {
-    RawPtr<WebLocalFrameImpl> webFrame = new WebLocalFrameImpl(oldWebFrame, client);
+    WebLocalFrameImpl* webFrame = new WebLocalFrameImpl(oldWebFrame, client);
     Frame* oldFrame = oldWebFrame->toImplBase()->frame();
     webFrame->setParent(oldWebFrame->parent());
     webFrame->setOpener(oldWebFrame->opener());
     // Note: this *always* temporarily sets a frame owner, even for main frames!
     // When a core Frame is created with no owner, it attempts to set itself as
     // the main frame of the Page. However, this is a provisional frame, and may
     // disappear, so Page::m_mainFrame can't be updated just yet.
-    RawPtr<FrameOwner> tempOwner = DummyFrameOwner::create();
+    FrameOwner* tempOwner = DummyFrameOwner::create();
     // TODO(dcheng): This block is very similar to initializeCoreFrame. Try to reuse it here.
-    RawPtr<LocalFrame> frame = LocalFrame::create(webFrame->m_frameLoaderClientImpl.get(), oldFrame->host(), tempOwner.get(), client ? client->serviceRegistry() : nullptr);
+    LocalFrame* frame = LocalFrame::create(webFrame->m_frameLoaderClientImpl.get(), oldFrame->host(), tempOwner, client ? client->serviceRegistry() : nullptr);
     // Set the name and unique name directly, bypassing any of the normal logic
     // to calculate unique name.
     frame->tree().setPrecalculatedName(toWebRemoteFrameImpl(oldWebFrame)->frame()->tree().name(), toWebRemoteFrameImpl(oldWebFrame)->frame()->tree().uniqueName());
     webFrame->setCoreFrame(frame);
 
     frame->setOwner(oldFrame->owner());
 
     if (frame->owner() && frame->owner()->isRemote()) {
         toRemoteFrameOwner(frame->owner())->setSandboxFlags(static_cast<SandboxFlags>(flags));
         // Since a remote frame doesn't get the notifications about frame owner
         // property modifications, we need to sync up those properties here.
         webFrame->setFrameOwnerProperties(frameOwnerProperties);
     }
 
     // We must call init() after m_frame is assigned because it is referenced
     // during init(). Note that this may dispatch JS events; the frame may be
     // detached after init() returns.
     frame->init();
-#if ENABLE(OILPAN)
-    return webFrame.get();
-#else
-    return webFrame.release().leakRef();
-#endif
+    return webFrame;
 }
 
 
 WebLocalFrameImpl::WebLocalFrameImpl(WebTreeScopeType scope, WebFrameClient* client)
     : WebLocalFrame(scope)
     , m_frameLoaderClientImpl(FrameLoaderClientImpl::create(this))
     , m_frameWidget(0)
     , m_client(client)
     , m_autofillClient(0)
     , m_contentSettingsClient(0)
@@ skipping 33 matching lines @@
     visitor->trace(m_devToolsAgent);
     visitor->trace(m_textFinder);
     visitor->trace(m_printContext);
     visitor->trace(m_geolocationClientProxy);
     visitor->template registerWeakMembers<WebFrame, &WebFrame::clearWeakFrames>(this);
     WebFrame::traceFrames(visitor, this);
     WebFrameImplBase::trace(visitor);
 }
 #endif
 
-void WebLocalFrameImpl::setCoreFrame(RawPtr<LocalFrame> frame)
+void WebLocalFrameImpl::setCoreFrame(LocalFrame* frame)
 {
     m_frame = frame;
 
     // FIXME: we shouldn't add overhead to every frame by registering these objects when they're not used.
     if (!m_frame)
         return;
 
     if (m_client)
         providePushControllerTo(*m_frame, m_client->pushClient());
 
@@ skipping 36 matching lines @@
     setCoreFrame(LocalFrame::create(m_frameLoaderClientImpl.get(), host, owner, client() ? client()->serviceRegistry() : nullptr));
     frame()->tree().setPrecalculatedName(name, uniqueName);
     // We must call init() after m_frame is assigned because it is referenced
     // during init(). Note that this may dispatch JS events; the frame may be
     // detached after init() returns.
     frame()->init();
     if (frame() && frame()->loader().stateMachine()->isDisplayingInitialEmptyDocument() && !parent() && !opener() && frame()->settings()->shouldReuseGlobalForUnownedMainFrame())
         frame()->document()->getSecurityOrigin()->grantUniversalAccess();
 }
 
-RawPtr<LocalFrame> WebLocalFrameImpl::createChildFrame(const FrameLoadRequest& request,
+LocalFrame* WebLocalFrameImpl::createChildFrame(const FrameLoadRequest& request,
     const AtomicString& name, HTMLFrameOwnerElement* ownerElement)
 {
     DCHECK(m_client);
     TRACE_EVENT0("blink", "WebLocalFrameImpl::createChildframe");
     WebTreeScopeType scope = frame()->document() == ownerElement->treeScope()
         ? WebTreeScopeType::Document
         : WebTreeScopeType::Shadow;
     WebFrameOwnerProperties ownerProperties(ownerElement->scrollingMode(), ownerElement->marginWidth(), ownerElement->marginHeight());
     // FIXME: Using subResourceAttributeName as fallback is not a perfect
     // solution. subResourceAttributeName returns just one attribute name. The
     // element might not have the attribute, and there might be other attributes
     // which can identify the element.
     AtomicString uniqueName = frame()->tree().calculateUniqueNameForNewChildFrame(
         name, ownerElement->getAttribute(ownerElement->subResourceAttributeName()));
-    RawPtr<WebLocalFrameImpl> webframeChild = toWebLocalFrameImpl(m_client->createChildFrame(this, scope, name, uniqueName, static_cast<WebSandboxFlags>(ownerElement->getSandboxFlags()), ownerProperties));
+    WebLocalFrameImpl* webframeChild = toWebLocalFrameImpl(m_client->createChildFrame(this, scope, name, uniqueName, static_cast<WebSandboxFlags>(ownerElement->getSandboxFlags()), ownerProperties));
     if (!webframeChild)
         return nullptr;
 
     webframeChild->initializeCoreFrame(frame()->host(), ownerElement, name, uniqueName);
     // Initializing the core frame may cause the new child to be detached, since
     // it may dispatch a load event in the parent.
     if (!webframeChild->parent())
         return nullptr;
 
     // If we're moving in the back/forward list, we might want to replace the content
     // of this child frame with whatever was there at that point.
-    RawPtr<HistoryItem> childItem = nullptr;
+    HistoryItem* childItem = nullptr;
     if (isBackForwardLoadType(frame()->loader().loadType()) && !frame()->document()->loadEventFinished())
-        childItem = RawPtr<HistoryItem>(webframeChild->client()->historyItemForNewChildFrame());
+        childItem = webframeChild->client()->historyItemForNewChildFrame();
 
     FrameLoadRequest newRequest = request;
     FrameLoadType loadType = FrameLoadTypeStandard;
     if (childItem) {
         newRequest = FrameLoadRequest(request.originDocument(),
-            FrameLoader::resourceRequestFromHistoryItem(childItem.get(), WebCachePolicy::UseProtocolCachePolicy));
+            FrameLoader::resourceRequestFromHistoryItem(childItem, WebCachePolicy::UseProtocolCachePolicy));
         loadType = FrameLoadTypeInitialHistoryLoad;
     }
-    webframeChild->frame()->loader().load(newRequest, loadType, childItem.get());
+    webframeChild->frame()->loader().load(newRequest, loadType, childItem);
 
     // Note a synchronous navigation (about:blank) would have already processed
     // onload, so it is possible for the child frame to have already been
     // detached by script in the page.
     if (!webframeChild->parent())
         return nullptr;
     return webframeChild->frame();
 }
 
 void WebLocalFrameImpl::didChangeContentsSize(const IntSize& size)
@@ skipping 181 matching lines @@
     // Unfortunately, we cannot just use that method since it is private, and
     // it also doesn't quite behave as we require it to for bookmarklets. The
     // key difference is that we need to suppress loading the string result
     // from evaluating the JS URL if executing the JS URL resulted in a
     // location change. We also allow a JS URL to be loaded even if scripts on
     // the page are otherwise disabled.
 
     if (!frame()->document() || !frame()->page())
         return;
 
-    RawPtr<Document> ownerDocument(frame()->document());
+    Document* ownerDocument(frame()->document());
 
     // Protect privileged pages against bookmarklets and other javascript manipulations.
     if (SchemeRegistry::shouldTreatURLSchemeAsNotAllowingJavascriptURLs(frame()->document()->url().protocol()))
         return;
 
     String script = decodeURLEscapeSequences(url.getString().substring(strlen("javascript:")));
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     v8::HandleScope handleScope(toIsolate(frame()));
     v8::Local<v8::Value> result = frame()->script().executeScriptInMainWorldAndReturnValue(ScriptSourceCode(script));
     if (result.IsEmpty() || !result->IsString())
         return;
     String scriptResult = toCoreString(v8::Local<v8::String>::Cast(result));
     if (!frame()->navigationScheduler().locationChangePending())
-        frame()->loader().replaceDocumentWhileExecutingJavaScriptURL(scriptResult, ownerDocument.get());
+        frame()->loader().replaceDocumentWhileExecutingJavaScriptURL(scriptResult, ownerDocument);
 }
 
 static void ensureFrameLoaderHasCommitted(FrameLoader& frameLoader)
 {
     // Internally, Blink uses CommittedMultipleRealLoads to track whether the
     // next commit should create a new history item or not. Ensure we have
     // reached that state.
     if (frameLoader.stateMachine()->committedMultipleRealLoads())
         return;
     frameLoader.stateMachine()->advanceTo(FrameLoaderStateMachine::CommittedMultipleRealLoads);
@@ skipping 61 matching lines @@
 void WebLocalFrameImpl::sendPings(const WebNode& contextNode, const WebURL& destinationURL)
 {
     DCHECK(frame());
     Element* anchor = contextNode.constUnwrap<Node>()->enclosingLinkEventParentOrSelf();
     if (isHTMLAnchorElement(anchor))
         toHTMLAnchorElement(anchor)->sendPings(destinationURL);
 }
 
 WebURLRequest WebLocalFrameImpl::requestFromHistoryItem(const WebHistoryItem& item, WebCachePolicy cachePolicy) const
 {
-    RawPtr<HistoryItem> historyItem = RawPtr<HistoryItem>(item);
+    HistoryItem* historyItem = item;
     ResourceRequest request = FrameLoader::resourceRequestFromHistoryItem(
-        historyItem.get(), cachePolicy);
+        historyItem, cachePolicy);
     return WrappedResourceRequest(request);
 }
 
 WebURLRequest WebLocalFrameImpl::requestForReload(WebFrameLoadType loadType,
     const WebURL& overrideUrl) const
 {
     DCHECK(frame());
     ResourceRequest request = frame()->loader().resourceRequestForReload(
         static_cast<FrameLoadType>(loadType), overrideUrl);
     return WrappedResourceRequest(request);
 }
 
 void WebLocalFrameImpl::load(const WebURLRequest& request, WebFrameLoadType webFrameLoadType,
     const WebHistoryItem& item, WebHistoryLoadType webHistoryLoadType, bool isClientRedirect)
 {
     DCHECK(frame());
     DCHECK(!request.isNull());
     const ResourceRequest& resourceRequest = request.toResourceRequest();
 
     if (resourceRequest.url().protocolIs("javascript")
         && webFrameLoadType == WebFrameLoadType::Standard) {
         loadJavaScriptURL(resourceRequest.url());
         return;
     }
 
     FrameLoadRequest frameRequest = FrameLoadRequest(nullptr, resourceRequest);
     if (isClientRedirect)
         frameRequest.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
-    RawPtr<HistoryItem> historyItem = RawPtr<HistoryItem>(item);
+    HistoryItem* historyItem = item;
     frame()->loader().load(
-        frameRequest, static_cast<FrameLoadType>(webFrameLoadType), historyItem.get(),
+        frameRequest, static_cast<FrameLoadType>(webFrameLoadType), historyItem,
         static_cast<HistoryLoadType>(webHistoryLoadType));
 }
 
 void WebLocalFrameImpl::loadData(const WebData& data, const WebString& mimeType,
     const WebString& textEncoding, const WebURL& baseURL, const WebURL& unreachableURL, bool replace,
     WebFrameLoadType webFrameLoadType, const WebHistoryItem& item,
     WebHistoryLoadType webHistoryLoadType, bool isClientRedirect)
 {
     DCHECK(frame());
 
     // If we are loading substitute data to replace an existing load, then
     // inherit all of the properties of that original request. This way,
     // reload will re-attempt the original request. It is essential that
     // we only do this when there is an unreachableURL since a non-empty
     // unreachableURL informs FrameLoader::reload to load unreachableURL
     // instead of the currently loaded URL.
     ResourceRequest request;
     if (replace && !unreachableURL.isEmpty() && frame()->loader().provisionalDocumentLoader())
         request = frame()->loader().provisionalDocumentLoader()->originalRequest();
     request.setURL(baseURL);
     request.setCheckForBrowserSideNavigation(false);
 
     FrameLoadRequest frameRequest(0, request, SubstituteData(data, mimeType, textEncoding, unreachableURL));
     DCHECK(frameRequest.substituteData().isValid());
     frameRequest.setReplacesCurrentItem(replace);
     if (isClientRedirect)
         frameRequest.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
 
-    RawPtr<HistoryItem> historyItem = RawPtr<HistoryItem>(item);
+    HistoryItem* historyItem = item;
     frame()->loader().load(
-        frameRequest, static_cast<FrameLoadType>(webFrameLoadType), historyItem.get(),
+        frameRequest, static_cast<FrameLoadType>(webFrameLoadType), historyItem,
         static_cast<HistoryLoadType>(webHistoryLoadType));
 }
 
 bool WebLocalFrameImpl::isLoading() const
 {
     if (!frame() || !frame()->document())
         return false;
     return frame()->loader().stateMachine()->isDisplayingInitialEmptyDocument() || frame()->loader().provisionalDocumentLoader() || !frame()->document()->loadEventFinished();
 }
 
@@ skipping 197 matching lines @@
         return WebSandboxFlags::None;
     return static_cast<WebSandboxFlags>(frame()->loader().effectiveSandboxFlags());
 }
 
 void WebLocalFrameImpl::forceSandboxFlags(WebSandboxFlags flags)
 {
     frame()->loader().forceSandboxFlags(static_cast<SandboxFlags>(flags));
 }
 
 } // namespace blink