Oilpan: Change Persistent<> data members to Member<> in HitTestResult.

- Disallow new/delete operations for HitTestResult.
HitTestResult was used
-- with new/delete operators
-- as part objects of ContextMenuController and MouseEventWithHitTestResult.
-- as stack allocated objects

We'd like to avoid to make such classes in Oilpan.
So, this CL disallows new/delete, and WebHitTestResult owns another
class to hold only required data copied from a HitTestResult.

- Move ContextMenuController to Oilpan heap, and trace HitTestResult member.

- Mark MouseEventWithHitTestResults STACK_ALLOCATED.

- We can't get HitTestResult from a WebHitTestResult. So we need to
introduce new function to WebViewImpl for WebSubstringUtil.mm.

Difference from r176393:
Always calling HitTestResult member functions was bad. Some of them are
expensive. So WebHitTestResultPrivate contains a HitTestResult copy, and
WebHitTestResultPrivate is RefCountedWillBeGarbageCollectedFinalized in order to
trace HitTestResult.

BUG=357163

Review URL: https://codereview.chromium.org/413903004

git-svn-id: svn://svn.chromium.org/blink/trunk@178997 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/core/page/ContextMenuController.cpp

@@ -50,9 +50,14 @@ ContextMenuController::~ContextMenuController()
 {
 }
 
-PassOwnPtr<ContextMenuController> ContextMenuController::create(Page* page, ContextMenuClient* client)
+PassOwnPtrWillBeRawPtr<ContextMenuController> ContextMenuController::create(Page* page, ContextMenuClient* client)
 {
-    return adoptPtr(new ContextMenuController(page, client));
+    return adoptPtrWillBeNoop(new ContextMenuController(page, client));
+}
+
+void ContextMenuController::trace(Visitor* visitor)
+{
+    visitor->trace(m_hitTestResult);
 }
 
 void ContextMenuController::clearContextMenu()

third_party/WebKit/Source/core/page/ContextMenuController.h

@@ -43,11 +43,12 @@ namespace blink {
     class LocalFrame;
     class Page;
 
-    class ContextMenuController {
-        WTF_MAKE_NONCOPYABLE(ContextMenuController); WTF_MAKE_FAST_ALLOCATED;
+    class ContextMenuController : public NoBaseWillBeGarbageCollectedFinalized<ContextMenuController> {
+        WTF_MAKE_NONCOPYABLE(ContextMenuController); WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
     public:
-        static PassOwnPtr<ContextMenuController> create(Page*, ContextMenuClient*);
+        static PassOwnPtrWillBeRawPtr<ContextMenuController> create(Page*, ContextMenuClient*);
         ~ContextMenuController();
+        void trace(Visitor*);
 
         ContextMenu* contextMenu() const { return m_contextMenu.get(); }
         void clearContextMenu();

third_party/WebKit/Source/core/page/Page.cpp

@@ -599,6 +599,7 @@ void Page::trace(Visitor* visitor)
 #if ENABLE(OILPAN)
     visitor->trace(m_dragCaretController);
     visitor->trace(m_dragController);
+    visitor->trace(m_contextMenuController);
     visitor->trace(m_inspectorController);
     visitor->trace(m_pointerLockController);
     visitor->trace(m_undoStack);

third_party/WebKit/Source/core/page/Page.h

@@ -253,7 +253,7 @@ private:
     const OwnPtrWillBeMember<DragCaretController> m_dragCaretController;
     const OwnPtrWillBeMember<DragController> m_dragController;
     const OwnPtr<FocusController> m_focusController;
-    const OwnPtr<ContextMenuController> m_contextMenuController;
+    const OwnPtrWillBeMember<ContextMenuController> m_contextMenuController;
     const OwnPtrWillBeMember<InspectorController> m_inspectorController;
     const OwnPtrWillBeMember<PointerLockController> m_pointerLockController;
     OwnPtr<ScrollingCoordinator> m_scrollingCoordinator;

third_party/WebKit/Source/core/rendering/HitTestResult.cpp

@@ -113,6 +113,17 @@ HitTestResult& HitTestResult::operator=(const HitTestResult& other)
     return *this;
 }
 
+void HitTestResult::trace(Visitor* visitor)
+{
+    visitor->trace(m_innerNode);
+    visitor->trace(m_innerPossiblyPseudoNode);
+    visitor->trace(m_innerNonSharedNode);
+    visitor->trace(m_innerURLElement);
+#if ENABLE(OILPAN)
+    visitor->trace(m_rectBasedTestResult);
+#endif
+}
+
 PositionWithAffinity HitTestResult::position() const
 {
     if (!m_innerPossiblyPseudoNode)

third_party/WebKit/Source/core/rendering/HitTestResult.h

@@ -47,6 +47,7 @@ class PositionWithAffinity;
 class Scrollbar;
 
 class HitTestResult {
+    DISALLOW_ALLOCATION();
 public:
     typedef WillBeHeapListHashSet<RefPtrWillBeMember<Node> > NodeSet;
 
@@ -58,6 +59,7 @@ public:
     HitTestResult(const HitTestResult&);
     ~HitTestResult();
     HitTestResult& operator=(const HitTestResult&);
+    void trace(Visitor*);
 
     Node* innerNode() const { return m_innerNode.get(); }
     Node* innerPossiblyPseudoNode() const { return m_innerPossiblyPseudoNode.get(); }
@@ -135,19 +137,19 @@ private:
 
     HitTestLocation m_hitTestLocation;
 
-    RefPtrWillBePersistent<Node> m_innerNode;
-    RefPtrWillBePersistent<Node> m_innerPossiblyPseudoNode;
-    RefPtrWillBePersistent<Node> m_innerNonSharedNode;
+    RefPtrWillBeMember<Node> m_innerNode;
+    RefPtrWillBeMember<Node> m_innerPossiblyPseudoNode;
+    RefPtrWillBeMember<Node> m_innerNonSharedNode;
     // FIXME: Nothing changes this to a value different from m_hitTestLocation!
     LayoutPoint m_pointInInnerNodeFrame; // The hit-tested point in innerNode frame coordinates.
     LayoutPoint m_localPoint; // A point in the local coordinate space of m_innerNonSharedNode's renderer. Allows us to efficiently
                               // determine where inside the renderer we hit on subsequent operations.
-    RefPtrWillBePersistent<Element> m_innerURLElement;
+    RefPtrWillBeMember<Element> m_innerURLElement;
     RefPtr<Scrollbar> m_scrollbar;
     bool m_isOverWidget; // Returns true if we are over a widget (and not in the border/padding area of a RenderWidget for example).
     bool m_isFirstLetter;
 
-    mutable OwnPtrWillBePersistent<NodeSet> m_rectBasedTestResult;
+    mutable OwnPtrWillBeMember<NodeSet> m_rectBasedTestResult;
 };
 
 } // namespace blink

third_party/WebKit/Source/web/WebHitTestResult.cpp

@@ -41,52 +41,81 @@ using namespace blink;
 
 namespace blink {
 
+class WebHitTestResultPrivate : public RefCountedWillBeGarbageCollectedFinalized<WebHitTestResultPrivate> {
+public:
+    static PassRefPtrWillBeRawPtr<WebHitTestResultPrivate> create(const HitTestResult&);
+    static PassRefPtrWillBeRawPtr<WebHitTestResultPrivate> create(const WebHitTestResultPrivate&);
+    void trace(Visitor* visitor) { visitor->trace(m_result); }
+    const HitTestResult& result() const { return m_result; }
+
+private:
+    WebHitTestResultPrivate(const HitTestResult&);
+    WebHitTestResultPrivate(const WebHitTestResultPrivate&);
+
+    HitTestResult m_result;
+};
+
+inline WebHitTestResultPrivate::WebHitTestResultPrivate(const HitTestResult& result)
+    : m_result(result)
+{
+}
+
+inline WebHitTestResultPrivate::WebHitTestResultPrivate(const WebHitTestResultPrivate& result)
+    : m_result(result.m_result)
+{
+}
+
+PassRefPtrWillBeRawPtr<WebHitTestResultPrivate> WebHitTestResultPrivate::create(const HitTestResult& result)
+{
+    return adoptRefWillBeNoop(new WebHitTestResultPrivate(result));
+}
+
+PassRefPtrWillBeRawPtr<WebHitTestResultPrivate> WebHitTestResultPrivate::create(const WebHitTestResultPrivate& result)
+{
+    return adoptRefWillBeNoop(new WebHitTestResultPrivate(result));
+}
+
 WebNode WebHitTestResult::node() const
 {
-    return WebNode(m_private->innerNode());
+    return WebNode(m_private->result().innerNode());
 }
 
 WebPoint WebHitTestResult::localPoint() const
 {
-    return roundedIntPoint(m_private->localPoint());
+    return roundedIntPoint(m_private->result().localPoint());
 }
 
 WebElement WebHitTestResult::urlElement() const
 {
-    return WebElement(m_private->URLElement());
+    return WebElement(m_private->result().URLElement());
 }
 
 WebURL WebHitTestResult::absoluteImageURL() const
 {
-    return m_private->absoluteImageURL();
+    return m_private->result().absoluteImageURL();
 }
 
 WebURL WebHitTestResult::absoluteLinkURL() const
 {
-    return m_private->absoluteLinkURL();
+    return m_private->result().absoluteLinkURL();
 }
 
 bool WebHitTestResult::isContentEditable() const
 {
-    return m_private->isContentEditable();
+    return m_private->result().isContentEditable();
 }
 
 WebHitTestResult::WebHitTestResult(const HitTestResult& result)
+    : m_private(WebHitTestResultPrivate::create(result))
 {
-    m_private.reset(new HitTestResult(result));
 }
 
 WebHitTestResult& WebHitTestResult::operator=(const HitTestResult& result)
 {
-    m_private.reset(new HitTestResult(result));
+    m_private = WebHitTestResultPrivate::create(result);
     return *this;
 }
 
-WebHitTestResult::operator HitTestResult() const
-{
-    return *m_private.get();
-}
-
 bool WebHitTestResult::isNull() const
 {
     return !m_private.get();
@@ -94,12 +123,15 @@ bool WebHitTestResult::isNull() const
 
 void WebHitTestResult::assign(const WebHitTestResult& info)
 {
-    m_private.reset(new HitTestResult(info));
+    if (info.isNull())
+        m_private.reset();
+    else
+        m_private = WebHitTestResultPrivate::create(*info.m_private.get());
 }
 
 void WebHitTestResult::reset()
 {
-    m_private.reset(0);
+    m_private.reset();
 }
 
 } // namespace blink

third_party/WebKit/Source/web/WebViewImpl.cpp

@@ -3219,6 +3219,11 @@ void WebViewImpl::performPluginAction(const WebPluginAction& action,
 }
 
 WebHitTestResult WebViewImpl::hitTestResultAt(const WebPoint& point)
+{
+    return coreHitTestResultAt(point);
+}
+
+HitTestResult WebViewImpl::coreHitTestResultAt(const WebPoint& point)
 {
     IntPoint scaledPoint = point;
     scaledPoint.scale(1 / pageScaleFactor(), 1 / pageScaleFactor());

third_party/WebKit/Source/web/WebViewImpl.h

@@ -264,6 +264,7 @@ public:
 
     // WebViewImpl
 
+    blink::HitTestResult coreHitTestResultAt(const WebPoint&);
     void suppressInvalidations(bool enable);
     void invalidateRect(const blink::IntRect&);
 

third_party/WebKit/Source/web/mac/WebSubstringUtil.mm

@@ -55,6 +55,7 @@
 #include "public/web/WebRange.h"
 #include "public/web/WebView.h"
 #include "web/WebLocalFrameImpl.h"
+#include "web/WebViewImpl.h"
 
 using namespace blink;
 
@@ -112,7 +113,7 @@ namespace blink {
 
 NSAttributedString* WebSubstringUtil::attributedWordAtPoint(WebView* view, WebPoint point, WebPoint& baselinePoint)
 {
-    HitTestResult result = view->hitTestResultAt(point);
+    HitTestResult result = static_cast<WebViewImpl*>(view)->coreHitTestResultAt(point);
     if (!result.targetNode())
       return nil;
     LocalFrame* frame = result.targetNode()->document().frame();

third_party/WebKit/public/web/WebHitTestResult.h

@@ -26,7 +26,7 @@
 #ifndef WebHitTestResult_h
 #define WebHitTestResult_h
 
-#include "../platform/WebPrivateOwnPtr.h"
+#include "../platform/WebPrivatePtr.h"
 
 namespace blink {
 class HitTestResult;
@@ -35,6 +35,7 @@ class HitTestResult;
 namespace blink {
 
 class WebElement;
+class WebHitTestResultPrivate;
 class WebNode;
 class WebURL;
 struct WebPoint;
@@ -74,11 +75,10 @@ public:
 #if BLINK_IMPLEMENTATION
     WebHitTestResult(const blink::HitTestResult&);
     WebHitTestResult& operator=(const blink::HitTestResult&);
-    operator blink::HitTestResult() const;
 #endif
 
 protected:
-    WebPrivateOwnPtr<blink::HitTestResult> m_private;
+    WebPrivatePtr<WebHitTestResultPrivate> m_private;
 };
 
 } // namespace blink