Move Frame to the Oilpan heap.

Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 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 31 matching lines @@
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/HTMLInterchange.h"
 #include "core/editing/InputMethodController.h"
 #include "core/editing/TextIterator.h"
 #include "core/editing/markup.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameHost.h"
+#include "core/frame/FrameProtector.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/PinchViewport.h"
 #include "core/frame/RemoteFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/SmartClip.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/html/HTMLTextAreaElement.h"
@@ skipping 139 matching lines @@
 // Change the text zoom level by kTextSizeMultiplierRatio each time the user
 // zooms text in or out (ie., change by 20%).  The min and max values limit
 // text zoom to half and 3x the original text size.  These three values match
 // those in Apple's port in WebKit/WebKit/WebView/WebView.mm
 const double WebView::textSizeMultiplierRatio = 1.2;
 const double WebView::minTextSizeMultiplier = 0.5;
 const double WebView::maxTextSizeMultiplier = 3.0;
 
 // Used to defer all page activity in cases where the embedder wishes to run
 // a nested event loop. Using a stack enables nesting of message loop invocations.
-static Vector<ScopedPageLoadDeferrer*>& pageLoadDeferrerStack()
+static WillBeHeapVector<RawPtrWillBeMember<ScopedPageLoadDeferrer> >& pageLoadDeferrerStack()
 {
-    DEFINE_STATIC_LOCAL(Vector<ScopedPageLoadDeferrer*>, deferrerStack, ());
-    return deferrerStack;
+    DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<WillBeHeapVector<RawPtrWillBeMember<ScopedPageLoadDeferrer> > >, deferrerStack, (adoptPtrWillBeNoop(new WillBeHeapVector<RawPtrWillBeMember<ScopedPageLoadDeferrer> > ())));
+    return *deferrerStack;
 }
 
 // Ensure that the WebDragOperation enum values stay in sync with the original
 // DragOperation constants.
 #define COMPILE_ASSERT_MATCHING_ENUM(coreName) \
     COMPILE_ASSERT(int(coreName) == int(Web##coreName), dummy##coreName)
 COMPILE_ASSERT_MATCHING_ENUM(DragOperationNone);
 COMPILE_ASSERT_MATCHING_ENUM(DragOperationCopy);
 COMPILE_ASSERT_MATCHING_ENUM(DragOperationLink);
 COMPILE_ASSERT_MATCHING_ENUM(DragOperationGeneric);
@@ skipping 82 matching lines @@
 
 void WebView::willEnterModalLoop()
 {
     pageLoadDeferrerStack().append(new ScopedPageLoadDeferrer());
 }
 
 void WebView::didExitModalLoop()
 {
     ASSERT(pageLoadDeferrerStack().size());
 
-    delete pageLoadDeferrerStack().last();
+    ScopedPageLoadDeferrer* deferrer = pageLoadDeferrerStack().last();
+#if ENABLE(OILPAN)
+    deferrer->dispose();
+#else
+    delete deferrer;
+#endif
     pageLoadDeferrerStack().removeLast();
 }
 
 void WebViewImpl::setMainFrame(WebFrame* frame)
 {
-    if (frame->isWebLocalFrame())
+    if (frame->isWebLocalFrame()) {
+#if ENABLE(OILPAN)
+        m_localMainFrame = toWebLocalFrameImpl(frame);
+        m_remoteMainFrame.clear();
+#endif
         toWebLocalFrameImpl(frame)->initializeCoreFrame(&page()->frameHost(), 0, nullAtom, nullAtom);
-    else
+    } else {
+#if ENABLE(OILPAN)
+        m_localMainFrame.clear();
+        m_remoteMainFrame = toWebRemoteFrameImpl(frame);
+#endif
         toWebRemoteFrameImpl(frame)->initializeCoreFrame(&page()->frameHost(), 0, nullAtom);
+    }
 }
 
 void WebViewImpl::setAutofillClient(WebAutofillClient* autofillClient)
 {
     m_autofillClient = autofillClient;
 }
 
 void WebViewImpl::setCredentialManagerClient(WebCredentialManagerClient* webCredentialManagerClient)
 {
     ASSERT(m_page);
@@ skipping 609 matching lines @@
         return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
     if (m_pagePopup) {
         m_pagePopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
         // We need to ignore the next Char event after this otherwise pressing
         // enter when selecting an item in the popup will go to the page.
         if (WebInputEvent::RawKeyDown == event.type)
             m_suppressNextKeypressEvent = true;
         return true;
     }
 
-    RefPtr<Frame> focusedFrame = focusedCoreFrame();
+    Frame* focusedFrame = focusedCoreFrame();
+    FrameProtector protect(focusedFrame);
     if (focusedFrame && focusedFrame->isRemoteFrameTemporary()) {
-        WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(toLocalFrameTemporary(focusedFrame.get()));
+        WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(toLocalFrameTemporary(focusedFrame));
         webFrame->client()->forwardInputEvent(&event);
         return true;
     }
 
     if (!focusedFrame || !focusedFrame->isLocalFrame())
         return false;
 
-    RefPtr<LocalFrame> frame = toLocalFrame(focusedFrame.get());
+    LocalFrame* frame = toLocalFrame(focusedFrame);
 
     PlatformKeyboardEventBuilder evt(event);
 
     if (frame->eventHandler().keyEvent(evt)) {
         if (WebInputEvent::RawKeyDown == event.type) {
             // Suppress the next keypress event unless the focused node is a plug-in node.
             // (Flash needs these keypress events to handle non-US keyboards.)
             Element* element = focusedElement();
             if (!element || !element->renderer() || !element->renderer()->isEmbeddedObject())
                 m_suppressNextKeypressEvent = true;
@@ skipping 1028 matching lines @@
 {
     TRACE_EVENT_ASYNC_END0("input", "capturing mouse", this);
     m_mouseCaptureNode = nullptr;
 }
 
 void WebViewImpl::setFocus(bool enable)
 {
     m_page->focusController().setFocused(enable);
     if (enable) {
         m_page->focusController().setActive(true);
-        RefPtr<Frame> focusedFrame = m_page->focusController().focusedFrame();
+        Frame* focusedFrame = m_page->focusController().focusedFrame();
+        FrameProtector protect(focusedFrame);
         if (focusedFrame && focusedFrame->isLocalFrame()) {
-            LocalFrame* localFrame = toLocalFrame(focusedFrame.get());
+            LocalFrame* localFrame = toLocalFrame(focusedFrame);
             Element* element = localFrame->document()->focusedElement();
             if (element && localFrame->selection().selection().isNone()) {
                 // If the selection was cleared while the WebView was not
                 // focused, then the focus element shows with a focus ring but
                 // no caret and does respond to keyboard inputs.
                 if (element->isTextFormControl()) {
                     element->updateFocusAppearance(true);
                 } else if (element->isContentEditable()) {
                     // updateFocusAppearance() selects all the text of
                     // contentseditable DIVs. So we set the selection explicitly
@@ skipping 10 matching lines @@
 
         // Clear focus on the currently focused frame if any.
         if (!m_page)
             return;
 
         LocalFrame* frame = m_page->mainFrame() && m_page->mainFrame()->isLocalFrame()
             ? m_page->deprecatedLocalMainFrame() : 0;
         if (!frame)
             return;
 
-        RefPtr<Frame> focusedFrame = m_page->focusController().focusedFrame();
+        Frame* focusedFrame = m_page->focusController().focusedFrame();
+        FrameProtector protect(focusedFrame);
         if (focusedFrame && focusedFrame->isLocalFrame()) {
             // Finish an ongoing composition to delete the composition node.
-            if (toLocalFrame(focusedFrame.get())->inputMethodController().hasComposition()) {
+            if (toLocalFrame(focusedFrame)->inputMethodController().hasComposition()) {
                 if (m_autofillClient)
                     m_autofillClient->setIgnoreTextChanges(true);
 
-                toLocalFrame(focusedFrame.get())->inputMethodController().confirmComposition();
+                toLocalFrame(focusedFrame)->inputMethodController().confirmComposition();
 
                 if (m_autofillClient)
                     m_autofillClient->setIgnoreTextChanges(false);
             }
             m_imeAcceptEvents = false;
         }
     }
 }
 
 bool WebViewImpl::setComposition(
@@ skipping 581 matching lines @@
     Frame* frame = page()->focusController().focusedOrMainFrame();
     if (frame->isLocalFrame()) {
         if (Document* document = toLocalFrame(frame)->document())
             document->setFocusedElement(nullptr);
     }
     page()->focusController().setInitialFocus(reverse ? FocusTypeBackward : FocusTypeForward);
 }
 
 void WebViewImpl::clearFocusedElement()
 {
-    RefPtr<Frame> frame = focusedCoreFrame();
+    Frame* frame = focusedCoreFrame();
     if (!frame || !frame->isLocalFrame())
         return;
 
-    LocalFrame* localFrame = toLocalFrame(frame.get());
+    FrameProtector protect(frame);
+    LocalFrame* localFrame = toLocalFrame(frame);
 
     RefPtrWillBeRawPtr<Document> document = localFrame->document();
     if (!document)
         return;
 
     RefPtrWillBeRawPtr<Element> oldFocusedElement = document->focusedElement();
 
     // Clear the focused node.
     document->setFocusedElement(nullptr);
 
@@ skipping 426 matching lines @@
         if (TextAutosizer* textAutosizer = frame->document()->textAutosizer())
             textAutosizer->updatePageInfoInAllFrames();
     }
 }
 
 void WebViewImpl::updateMainFrameLayoutSize()
 {
     if (m_fixedLayoutSizeLock || m_shouldAutoResize || !mainFrameImpl())
         return;
 
-    RefPtr<FrameView> view = mainFrameImpl()->frameView();
+    FrameView* view = mainFrameImpl()->frameView();
+    FrameViewProtector protect(view);
     if (!view)
         return;
 
     WebSize layoutSize = m_size;
 
     if (settings()->viewportEnabled())
         layoutSize = flooredIntSize(m_pageScaleConstraintsSet.pageDefinedConstraints().layoutSize);
 
     if (page()->settings().forceZeroLayoutHeight())
         layoutSize.height = 0;
@@ skipping 57 matching lines @@
 
 void WebViewImpl::setFixedLayoutSize(const WebSize& layoutSize)
 {
     if (!page() || !page()->mainFrame()->isLocalFrame())
         return;
 
     LocalFrame* frame = page()->deprecatedLocalMainFrame();
     if (!frame)
         return;
 
-    RefPtr<FrameView> view = frame->view();
+    FrameView* view = frame->view();
+    FrameViewProtector protect(view);
     if (!view)
         return;
 
     m_fixedLayoutSizeLock = layoutSize.width || layoutSize.height;
 
     if (m_fixedLayoutSizeLock)
         view->setLayoutSize(layoutSize);
     else
         updateMainFrameLayoutSize();
 }
@@ skipping 1068 matching lines @@
     const PageScaleConstraints& constraints = m_pageScaleConstraintsSet.pageDefinedConstraints();
 
     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
         return false;
 
     return mainFrameImpl()->frameView()->layoutSize().width() == m_size.width
         || (constraints.minimumScale == constraints.maximumScale && constraints.minimumScale != -1);
 }
 
 } // namespace blink