Remove unused/unneeded code from core/editing.

Source/core/editing/Caret.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 22 matching lines @@
 #include "core/frame/Settings.h"
 #include "core/html/HTMLTextFormControlElement.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderView.h"
 #include "platform/graphics/GraphicsContext.h"
 
 namespace blink {
 
 CaretBase::CaretBase(CaretVisibility visibility)
-    : m_caretRectNeedsUpdate(true)
-    , m_caretVisibility(visibility)
+    : m_caretVisibility(visibility)
 {
 }
 
 DragCaretController::DragCaretController()
     : CaretBase(Visible)
 {
 }
 
 PassOwnPtrWillBeRawPtr<DragCaretController> DragCaretController::create()
 {
     return adoptPtrWillBeNoop(new DragCaretController);
 }
 
 bool DragCaretController::isContentRichlyEditable() const
 {
     return isRichlyEditablePosition(m_position.deepEquivalent());
 }
 
 void DragCaretController::setCaretPosition(const VisiblePosition& position)
 {
     // for querying RenderLayer::compositingState()
     // This code is probably correct, since it doesn't occur in a stack that involves updating compositing state.
     DisableCompositingQueryAsserts disabler;
 
     if (Node* node = m_position.deepEquivalent().deprecatedNode())
         invalidateCaretRect(node);
     m_position = position;
-    setCaretRectNeedsUpdate();
     Document* document = nullptr;
     if (Node* node = m_position.deepEquivalent().deprecatedNode()) {
         invalidateCaretRect(node);
         document = &node->document();
     }
     if (m_position.isNull() || m_position.isOrphan()) {
         clearCaretRect();
     } else {
         document->updateRenderTreeIfNeeded();
         updateCaretRect(document, m_position);
@@ skipping 76 matching lines @@
     }
 
     if (unrooted)
         caretRect = LayoutRect();
 }
 
 bool CaretBase::updateCaretRect(Document* document, const PositionWithAffinity& caretPosition)
 {
     m_caretLocalRect = LayoutRect();
 
-    m_caretRectNeedsUpdate = false;
-
     if (caretPosition.position().isNull())
         return false;
 
     ASSERT(caretPosition.position().deprecatedNode()->renderer());
 
     // First compute a rect local to the renderer at the selection start.
     RenderObject* renderer;
     m_caretLocalRect = localCaretRectOfPosition(caretPosition, renderer);
 
     // Get the renderer that will be responsible for painting the caret
@@ skipping 49 matching lines @@
     bool caretBrowsing = false;
     if (FrameView* frameView = view->frameView()) {
         LocalFrame& frame = frameView->frame(); // The frame where the selection started
         caretBrowsing = frame.settings() && frame.settings()->caretBrowsingEnabled();
     }
     return (caretBrowsing || isContentEditable);
 }
 
 void CaretBase::invalidateCaretRect(Node* node, bool caretRectChanged)
 {
-    // EDIT FIXME: This is an unfortunate hack.
-    // Basically, we can't trust this layout position since we
-    // can't guarantee that the check to see if we are in unrendered
-    // content will work at this point. We may have to wait for
-    // a layout and re-render of the document to happen. So, resetting this
-    // flag will cause another caret layout to happen the first time
-    // that we try to paint the caret after this call. That one will work since
-    // it happens after the document has accounted for any editing
-    // changes which may have been done.
-    // And, we need to leave this layout here so the caret moves right
-    // away after clicking.
-    m_caretRectNeedsUpdate = true;
-
     if (caretRectChanged)
         return;
 
     if (RenderView* view = node->document().renderView()) {
         if (shouldRepaintCaret(view, node->isContentEditable(Node::UserSelectAllIsAlwaysNonEditable)))
             invalidateLocalCaretRect(node, localCaretRectWithoutUpdate());
     }
 }
 
 void CaretBase::paintCaret(Node* node, GraphicsContext* context, const LayoutPoint& paintOffset, const LayoutRect& clipRect) const
@@ skipping 23 matching lines @@
     context->fillRect(caret, caretColor);
 }
 
 void DragCaretController::paintDragCaret(LocalFrame* frame, GraphicsContext* p, const LayoutPoint& paintOffset, const LayoutRect& clipRect) const
 {
     if (m_position.deepEquivalent().deprecatedNode()->document().frame() == frame)
         paintCaret(m_position.deepEquivalent().deprecatedNode(), p, paintOffset, clipRect);
 }
 
 }