Get rid of CaretBase::m_caretLocalRect

third_party/WebKit/Source/core/editing/CaretBase.cpp

 /*
  * Copyright (C) 2004, 2008, 2009, 2010 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 29 matching lines @@
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 
 namespace blink {
 
 CaretBase::CaretBase() = default;
 CaretBase::~CaretBase() = default;
 
 DEFINE_TRACE(CaretBase) {}
 
-void CaretBase::clearCaretRect() {
-  m_caretLocalRect = LayoutRect();
-}
-
 static inline bool caretRendersInsideNode(Node* node) {
   return node && !isDisplayInsideTable(node) && !editingIgnoresContent(*node);
 }
 
 LayoutBlock* CaretBase::caretLayoutObject(Node* node) {
   if (!node)
     return nullptr;
 
   LayoutObject* layoutObject = node->layoutObject();
   if (!layoutObject)
     return nullptr;
 
   // if caretNode is a block and caret is inside it then caret should be painted
   // by that block
   bool paintedByBlock =
       layoutObject->isLayoutBlock() && caretRendersInsideNode(node);
   // TODO(yoichio): This function is called at least
   // DocumentLifeCycle::LayoutClean but caretRendersInsideNode above can
   // layout. Thus |node->layoutObject()| can be changed then this is bad
   // design. We should make caret painting algorithm clean.
   CHECK_EQ(layoutObject, node->layoutObject())
       << "Layout tree should not changed";
   return paintedByBlock ? toLayoutBlock(layoutObject)
                         : layoutObject->containingBlock();
 }
 
-static void mapCaretRectToCaretPainter(LayoutItem caretLayoutItem,
-                                       LayoutBlockItem caretPainterItem,
-                                       LayoutRect& caretRect) {
+static LayoutRect mapCaretRectToCaretPainter(
+    LayoutItem caretLayoutItem,
+    LayoutBlockItem caretPainterItem,
+    const LayoutRect& passedCaretRect) {
   // FIXME: This shouldn't be called on un-rooted subtrees.
   // FIXME: This should probably just use mapLocalToAncestor.
   // Compute an offset between the caretLayoutItem and the caretPainterItem.
 
   DCHECK(caretLayoutItem.isDescendantOf(caretPainterItem));
 
-  bool unrooted = false;
+  LayoutRect caretRect = passedCaretRect;
   while (caretLayoutItem != caretPainterItem) {
     LayoutItem containerItem = caretLayoutItem.container();
-    if (containerItem.isNull()) {
-      unrooted = true;
-      break;
-    }
+    if (containerItem.isNull())
+      return LayoutRect();
     caretRect.move(caretLayoutItem.offsetFromContainer(containerItem));
     caretLayoutItem = containerItem;
   }
-
-  if (unrooted)
-    caretRect = LayoutRect();
+  return caretRect;
 }
 
-void CaretBase::updateCaretRect(const PositionWithAffinity& caretPosition) {
-  m_caretLocalRect = LayoutRect();
-
+LayoutRect CaretBase::computeCaretRect(
+    const PositionWithAffinity& caretPosition) {
   if (caretPosition.isNull())
-    return;
+    return LayoutRect();
 
   DCHECK(caretPosition.anchorNode()->layoutObject());
 
   // First compute a rect local to the layoutObject at the selection start.
   LayoutObject* layoutObject;
-  m_caretLocalRect = localCaretRectOfPosition(caretPosition, layoutObject);
+  LayoutRect caretLocalRect =

[yoichio, 2017/01/12 09:22:22]

nit: const LayoutRect

+      localCaretRectOfPosition(caretPosition, layoutObject);
 
   // Get the layoutObject that will be responsible for painting the caret
   // (which is either the layoutObject we just found, or one of its containers).
   LayoutBlockItem caretPainterItem =
       LayoutBlockItem(caretLayoutObject(caretPosition.anchorNode()));
 
-  mapCaretRectToCaretPainter(LayoutItem(layoutObject), caretPainterItem,
-                             m_caretLocalRect);
+  return mapCaretRectToCaretPainter(LayoutItem(layoutObject), caretPainterItem,
+                                    caretLocalRect);
 }
 
-void CaretBase::updateCaretRect(const VisiblePosition& caretPosition) {
-  updateCaretRect(caretPosition.toPositionWithAffinity());
+LayoutRect CaretBase::computeCaretRect(const VisiblePosition& caretPosition) {
+  return computeCaretRect(caretPosition.toPositionWithAffinity());
 }
 
 IntRect CaretBase::absoluteBoundsForLocalRect(Node* node,
                                               const LayoutRect& rect) const {
   LayoutBlock* caretPainter = caretLayoutObject(node);
   if (!caretPainter)
     return IntRect();
 
   LayoutRect localRect(rect);
   caretPainter->flipForWritingMode(localRect);
@@ skipping 24 matching lines @@
 
 bool CaretBase::shouldRepaintCaret(Node& node) const {
   // If PositionAnchorType::BeforeAnchor or PositionAnchorType::AfterAnchor,
   // carets need to be repainted not only when the node is contentEditable but
   // also when its parentNode() is contentEditable.
   node.document().updateStyleAndLayoutTree();
   return hasEditableStyle(node) ||
          (node.parentNode() && hasEditableStyle(*node.parentNode()));
 }
 
-void CaretBase::invalidateCaretRect(Node* node) {
+void CaretBase::invalidateCaretRect(Node* node,
+                                    const LayoutRect& caretLocalRect) {
   node->document().updateStyleAndLayoutTree();
   if (hasEditableStyle(*node))
-    invalidateLocalCaretRect(node, localCaretRectWithoutUpdate());
+    invalidateLocalCaretRect(node, caretLocalRect);
 }
 
 void CaretBase::paintCaret(Node* node,
                            GraphicsContext& context,
+                           const DisplayItemClient& client,
+                           const LayoutRect& caretLocalRect,
                            const LayoutPoint& paintOffset,
-                           DisplayItem::Type displayItemType) const {
-  if (DrawingRecorder::useCachedDrawingIfPossible(context, *this,
+                           DisplayItem::Type displayItemType) {
+  if (DrawingRecorder::useCachedDrawingIfPossible(context, client,
                                                   displayItemType))
     return;
 
-  LayoutRect drawingRect = localCaretRectWithoutUpdate();
+  LayoutRect drawingRect = caretLocalRect;
   if (LayoutBlock* layoutObject = caretLayoutObject(node))
     layoutObject->flipForWritingMode(drawingRect);
   drawingRect.moveBy(paintOffset);
 
   const Color caretColor =
       node->layoutObject()->resolveColor(CSSPropertyCaretColor);
   IntRect paintRect = pixelSnappedIntRect(drawingRect);
-  DrawingRecorder drawingRecorder(context, *this, DisplayItem::kCaret,
+  DrawingRecorder drawingRecorder(context, client, DisplayItem::kCaret,
                                   paintRect);
   context.fillRect(paintRect, caretColor);
 }
 
 String CaretBase::debugName() const {
   return "Caret";
 }
 
 LayoutRect CaretBase::visualRect() const {
   return m_visualRect;
 }
 
 }  // namespace blink