Oilpan: Prepare moving AXObject to heap

Source/web/WebAXObject.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 54 matching lines @@
 static bool isLayoutClean(Document* document)
 {
     if (!document || !document->view())
         return false;
     return document->lifecycle().state() >= DocumentLifecycle::LayoutClean
         || (document->lifecycle().state() == DocumentLifecycle::StyleClean && !document->view()->needsLayout());
 }
 #endif
 
 WebScopedAXContext::WebScopedAXContext(WebDocument& rootDocument)
-    : m_private(adoptRef(new ScopedAXObjectCache(*rootDocument.unwrap<Document>())))
+    : m_private(adoptPtr(new ScopedAXObjectCache(*rootDocument.unwrap<Document>())))
 {
 }
 
-WebScopedAXContext::~WebScopedAXContext()
-{
-    m_private.reset();
-}
-
 WebAXObject WebScopedAXContext::root() const
 {
     return WebAXObject(static_cast<AXObjectCacheImpl*>(m_private->get())->root());
 }
 
 void WebAXObject::reset()
 {
     m_private.reset();
 }
 
@@ skipping 588 matching lines @@
 
 // FIXME: This method passes in a point that has page scale applied but assumes that (0, 0)
 // is the top left of the visual viewport. In other words, the point has the PinchViewport
 // scale applied, but not the PinchViewport offset. crbug.com/459591.
 WebAXObject WebAXObject::hitTest(const WebPoint& point) const
 {
     if (isDetached())
         return WebAXObject();
 
     IntPoint contentsPoint = m_private->documentFrameView()->soonToBeRemovedUnscaledViewportToContents(point);
-    RefPtr<AXObject> hit = m_private->accessibilityHitTest(contentsPoint);
+    RefPtrWillBeRawPtr<AXObject> hit = m_private->accessibilityHitTest(contentsPoint);
 
     if (hit)
         return WebAXObject(hit);
 
     if (m_private->elementRect().contains(contentsPoint))
         return *this;
 
     return WebAXObject();
 }
 
@@ skipping 274 matching lines @@
 {
     return deprecatedTitleUIElement();
 }
 
 WebString WebAXObject::name(WebAXNameFrom& outNameFrom, WebVector<WebAXObject>& outNameObjects)
 {
     if (isDetached())
         return WebString();
 
     AXNameFrom nameFrom = AXNameFromAttribute;
-    Vector<AXObject*> nameObjects;
+    WillBeHeapVector<RawPtrWillBeMember<AXObject>> nameObjects;
     WebString result = m_private->name(nameFrom, nameObjects);
     outNameFrom = static_cast<WebAXNameFrom>(nameFrom);
 
     WebVector<WebAXObject> webNameObjects(nameObjects.size());
     for (size_t i = 0; i < nameObjects.size(); i++)
         webNameObjects[i] = WebAXObject(nameObjects[i]);
     outNameObjects.swap(webNameObjects);
 
     return result;
 }
 
 WebString WebAXObject::description(WebAXNameFrom nameFrom, WebAXDescriptionFrom& outDescriptionFrom, WebVector<WebAXObject>& outDescriptionObjects)
 {
     if (isDetached())
         return WebString();
 
     AXDescriptionFrom descriptionFrom;
-    Vector<AXObject*> descriptionObjects;
+    WillBeHeapVector<RawPtrWillBeMember<AXObject>> descriptionObjects;
     String result = m_private->description(static_cast<AXNameFrom>(nameFrom), descriptionFrom, descriptionObjects);
     outDescriptionFrom = static_cast<WebAXDescriptionFrom>(descriptionFrom);
 
     WebVector<WebAXObject> webDescriptionObjects(descriptionObjects.size());
     for (size_t i = 0; i < descriptionObjects.size(); i++)
         webDescriptionObjects[i] = WebAXObject(descriptionObjects[i]);
     outDescriptionObjects.swap(webDescriptionObjects);
 
     return result;
 }
@@ skipping 418 matching lines @@
     if (!isDetached())
         m_private->scrollToMakeVisibleWithSubFocus(subfocus);
 }
 
 void WebAXObject::scrollToGlobalPoint(const WebPoint& point) const
 {
     if (!isDetached())
         m_private->scrollToGlobalPoint(point);
 }
 
-WebAXObject::WebAXObject(const WTF::PassRefPtr<AXObject>& object)
+WebAXObject::WebAXObject(const PassRefPtrWillBeRawPtr<AXObject>& object)
     : m_private(object)
 {
 }
 
-WebAXObject& WebAXObject::operator=(const WTF::PassRefPtr<AXObject>& object)
+WebAXObject& WebAXObject::operator=(const PassRefPtrWillBeRawPtr<AXObject>& object)
 {
     m_private = object;
     return *this;
 }
 
-WebAXObject::operator WTF::PassRefPtr<AXObject>() const
+WebAXObject::operator PassRefPtrWillBeRawPtr<AXObject>() const
 {
     return m_private.get();
 }
 
 } // namespace blink