Refactor IntersectionGeometry class and move it to core/layout.

third_party/WebKit/Source/core/layout/IntersectionGeometry.h

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef IntersectionGeometry_h
 #define IntersectionGeometry_h
 
 #include "platform/Length.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
-class Node;
 class Element;
 class LayoutObject;
 
-class IntersectionGeometry final
-    : public GarbageCollectedFinalized<IntersectionGeometry> {
+// Computes the intersection between an ancestor (root) element and a
+// descendant (target) element, with overflow and CSS clipping applied, but not
+// paint occlusion.
+//
+// If the root argument to the constructor is null, computes the intersection
+// of the target with the top-level frame viewport (AKA the "implicit root").
+class IntersectionGeometry {
+  STACK_ALLOCATED()
  public:
-  enum ReportRootBounds {
-    kShouldReportRootBounds,
-    kShouldNotReportRootBounds,
-  };
-
-  IntersectionGeometry(Node* root,
-                       Element* target,
+  IntersectionGeometry(Element* root,
+                       Element& target,
                        const Vector<Length>& rootMargin,
-                       ReportRootBounds shouldReportRootBounds);
+                       bool shouldReportRootBounds);
   ~IntersectionGeometry();
 
   void computeGeometry();
+
+  LayoutObject* root() const { return m_root; }
+  LayoutObject* target() const { return m_target; }
+
+  // Client rect in the coordinate system of the frame containing target.
   LayoutRect targetRect() const { return m_targetRect; }
+
+  // Client rect in the coordinate system of the frame containing target.
   LayoutRect intersectionRect() const { return m_intersectionRect; }
+
+  // Client rect in the coordinate system of the frame containing root.
   LayoutRect rootRect() const { return m_rootRect; }
+
   bool doesIntersect() const { return m_doesIntersect; }
 
   IntRect intersectionIntRect() const {
     return pixelSnappedIntRect(m_intersectionRect);
   }
 
   IntRect targetIntRect() const { return pixelSnappedIntRect(m_targetRect); }
 
   IntRect rootIntRect() const { return pixelSnappedIntRect(m_rootRect); }
 
-  DECLARE_TRACE();
-
  private:
+  bool canComputeGeometry(Element* root, Element& target) const;
   void initializeGeometry();
   void initializeTargetRect();
   void initializeRootRect();
   void clipToRoot();
   void mapTargetRectToTargetFrameCoordinates();
   void mapRootRectToRootFrameCoordinates();
-  void mapRootRectToTargetFrameCoordinates();
-  Element* root() const;
-  LayoutObject* getRootLayoutObject() const;
+  void mapIntersectionRectToTargetFrameCoordinates();
   void applyRootMargin();
 
-  Member<Node> m_root;
-  Member<Element> m_target;
+  // Returns true iff it's possible to compute an intersection between root
+  // and target.
+  bool isValid() const { return m_isValid; }

[ojan, 2016/12/12 19:53:31]

Nit: How about a more descriptive name? I wouldn't guess from the name that it
does what the comment describes. It's literally equal to the return value of
canComputeGeometry. How about calling this canComputeGeometry and
s/canComputeGeometry/initializeCanComputeGeometry/ above?

[szager1, 2016/12/12 20:16:11]

Done.

+  bool rootIsImplicit() const { return m_rootIsImplicit; }
+  bool shouldReportRootBounds() const { return m_shouldReportRootBounds; }
+
+  LayoutObject* m_root;
+  LayoutObject* m_target;
   const Vector<Length> m_rootMargin;
-  const ReportRootBounds m_shouldReportRootBounds;
   LayoutRect m_targetRect;
   LayoutRect m_intersectionRect;
   LayoutRect m_rootRect;
-  bool m_doesIntersect = false;
+  unsigned m_doesIntersect : 1;
+  const unsigned m_shouldReportRootBounds : 1;
+  const unsigned m_rootIsImplicit : 1;
+  const unsigned m_isValid : 1;
 };
 
 }  // namespace blink
 
 #endif  // IntersectionGeometry_h