Have Node::document() return a reference instead of a pointer

Source/core/page/TouchAdjustment.cpp

 /*
  * Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 302 matching lines @@
     }
 }
 
 // This returns quotient of the target area and its intersection with the touch area.
 // This will prioritize largest intersection and smallest area, while balancing the two against each other.
 float zoomableIntersectionQuotient(const IntPoint& touchHotspot, const IntRect& touchArea, const SubtargetGeometry& subtarget)
 {
     IntRect rect = subtarget.boundingBox();
 
     // Convert from frame coordinates to window coordinates.
-    rect = subtarget.node()->document()->view()->contentsToWindow(rect);
+    rect = subtarget.node()->document().view()->contentsToWindow(rect);
 
     // Check the rectangle is meaningful zoom target. It should at least contain the hotspot.
     if (!rect.contains(touchHotspot))
         return std::numeric_limits<float>::infinity();
     IntRect intersection = rect;
     intersection.intersect(touchArea);
 
     // Return the quotient of the intersection.
     return rect.size().area() / (float)intersection.size().area();
 }
 
 // Uses a hybrid of distance to adjust and intersect ratio, normalizing each score between 0 and 1
 // and combining them. The distance to adjust works best for disambiguating clicks on targets such
 // as links, where the width may be significantly larger than the touch width. Using area of overlap
 // in such cases can lead to a bias towards shorter links. Conversely, percentage of overlap can
 // provide strong confidence in tapping on a small target, where the overlap is often quite high,
 // and works well for tightly packed controls.
 float hybridDistanceFunction(const IntPoint& touchHotspot, const IntRect& touchRect, const SubtargetGeometry& subtarget)
 {
     IntRect rect = subtarget.boundingBox();
 
     // Convert from frame coordinates to window coordinates.
-    rect = subtarget.node()->document()->view()->contentsToWindow(rect);
+    rect = subtarget.node()->document().view()->contentsToWindow(rect);
 
     float radiusSquared = 0.25f * (touchRect.size().diagonalLengthSquared());
     float distanceToAdjustScore = rect.distanceSquaredToPoint(touchHotspot) / radiusSquared;
 
     int maxOverlapWidth = std::min(touchRect.width(), rect.width());
     int maxOverlapHeight = std::min(touchRect.height(), rect.height());
     float maxOverlapArea = std::max(maxOverlapWidth * maxOverlapHeight, 1);
     rect.intersect(touchRect);
     float intersectArea = rect.size().area();
     float intersectionScore = 1 - intersectArea / maxOverlapArea;
@@ skipping 20 matching lines @@
         point.setX(rect.maxX());
 
     if (point.y() < rect.y())
         point.setY(rect.y());
     else if (point.y() > rect.maxY())
         point.setY(rect.maxY());
 }
 
 bool snapTo(const SubtargetGeometry& geom, const IntPoint& touchPoint, const IntRect& touchArea, IntPoint& adjustedPoint)
 {
-    FrameView* view = geom.node()->document()->view();
+    FrameView* view = geom.node()->document().view();
     FloatQuad quad = geom.quad();
 
     if (quad.isRectilinear()) {
         IntRect contentBounds = geom.boundingBox();
         // Convert from frame coordinates to window coordinates.
         IntRect bounds = view->contentsToWindow(contentBounds);
         if (bounds.contains(touchPoint)) {
             adjustedPoint = touchPoint;
             return true;
         }
@@ skipping 57 matching lines @@
                 if (node->isDescendantOf(targetNode)) {
                     // Try to always return the inner-most element.
                     targetPoint = adjustedPoint;
                     targetNode = node;
                     targetArea = it->boundingBox();
                 }
             }
         }
     }
     if (targetNode) {
-        targetArea = targetNode->document()->view()->contentsToWindow(targetArea);
+        targetArea = targetNode->document().view()->contentsToWindow(targetArea);
     }
     return (targetNode);
 }
 
 } // namespace TouchAdjustment
 
 bool findBestClickableCandidate(Node*& targetNode, IntPoint &targetPoint, const IntPoint &touchHotspot, const IntRect &touchArea, const Vector<RefPtr<Node> >& nodes)
 {
     IntRect targetArea;
     TouchAdjustment::SubtargetGeometryList subtargets;
@@ skipping 11 matching lines @@
 
 bool findBestZoomableArea(Node*& targetNode, IntRect& targetArea, const IntPoint& touchHotspot, const IntRect& touchArea, const Vector<RefPtr<Node> >& nodes)
 {
     IntPoint targetPoint;
     TouchAdjustment::SubtargetGeometryList subtargets;
     TouchAdjustment::compileZoomableSubtargets(nodes, subtargets);
     return TouchAdjustment::findNodeWithLowestDistanceMetric(targetNode, targetPoint, targetArea, touchHotspot, touchArea, subtargets, TouchAdjustment::zoomableIntersectionQuotient);
 }
 
 } // namespace WebCore