[CANCELED] Ensure clean style for hasEditableLevel when it doesn't break other stuff

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 61 matching lines @@
 
 std::ostream& operator<<(std::ostream& os, PositionMoveType type) {
   static const char* const texts[] = {"CodeUnit", "BackwardDeletion",
                                       "GraphemeCluster"};
   const auto& it = std::begin(texts) + static_cast<size_t>(type);
   DCHECK_GE(it, std::begin(texts)) << "Unknown PositionMoveType value";
   DCHECK_LT(it, std::end(texts)) << "Unknown PositionMoveType value";
   return os << *it;
 }
 
+bool isCheckingEditableStyleFromAX = false;
+
 }  // namespace
 
+bool* checkingEditableStyleFromAXIndicator() {
+  return &isCheckingEditableStyleFromAX;
+}
+
 bool needsLayoutTreeUpdate(const Node& node) {
   const Document& document = node.document();
   if (document.needsLayoutTreeUpdate())
     return true;
   // TODO(yosin): We should make |document::needsLayoutTreeUpdate()| to
   // check |LayoutView::needsLayout()|.
   return document.view() && document.view()->needsLayout();
 }
 
 template <typename PositionType>
@@ skipping 170 matching lines @@
 int comparePositions(const PositionWithAffinity& a,
                      const PositionWithAffinity& b) {
   return comparePositions(a.position(), b.position());
 }
 
 int comparePositions(const VisiblePosition& a, const VisiblePosition& b) {
   return comparePositions(a.deepEquivalent(), b.deepEquivalent());
 }
 
 enum EditableLevel { Editable, RichlyEditable };
-static bool hasEditableLevel(const Node& node, EditableLevel editableLevel) {
-  DCHECK(node.document().isActive());
-  // TODO(editing-dev): We should have this check:
-  // DCHECK_GE(node.document().lifecycle().state(),
-  //           DocumentLifecycle::StyleClean);
+
+// TODO(editing-dev): Eliminate the code paths entering this function with dirty
+// style, and replace it with hasEditableLevel.  See crbug.com/667575
+static bool hasEditableLevelDeprecated(const Node& node,
+                                       EditableLevel editableLevel) {
   if (node.isPseudoElement())
     return false;
 
-  // Ideally we'd call DCHECK(!needsStyleRecalc()) here, but
-  // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion
-  // would fire in the middle of Document::setFocusedNode().
-
   for (const Node& ancestor : NodeTraversal::inclusiveAncestorsOf(node)) {
     if ((ancestor.isHTMLElement() || ancestor.isDocumentNode()) &&
         ancestor.layoutObject()) {
       switch (ancestor.layoutObject()->style()->userModify()) {
         case READ_ONLY:
           return false;
         case READ_WRITE:
           return true;
         case READ_WRITE_PLAINTEXT_ONLY:
           return editableLevel != RichlyEditable;
       }
       NOTREACHED();
       return false;
     }
   }
 
   return false;
 }
 
+static bool hasEditableLevel(const Node& node, EditableLevel editableLevel) {
+  DCHECK(node.document().isActive());
+  DCHECK_GE(node.document().lifecycle().state(), DocumentLifecycle::StyleClean);
+  return hasEditableLevelDeprecated(node, editableLevel);
+}
+
+bool canCheckEditableStyleCorrectly(const Node& node) {
+  Document& document = node.document();
+  if (document.lifecycle().state() >= DocumentLifecycle::StyleClean)
+    return true;
+  if (isCheckingEditableStyleFromAX) {
+    // See crbug.com/668590 for details.
+    // Reached by:
+    // fast/events/onchange-text-form-field.html
+    // fast/dom/search-shadow-host-crash.html
+    // editing/pasteboard/style-from-rules.html
+    // editing/style/inline-style-extend-run.html
+    // editing/undo/remove-css-property-and-remove-style.html
+    // editing/selection/first-letter-selection-crash.html
+    // editing/selection/extend-by-word-002.html
+    // fast/dynamic/checkbox-selection-crash.html
+    return false;
+  }
+  if (document.lifecycle().inDetach()) {
+    // fast/text/custom-font-data-crash2.html reaches here.
+    // See crbug.com/668586 for details.
+    return false;
+  }
+  if (document.nthIndexCache()) {
+    // imported/wpt/html/semantics/selectors/pseudo-classes/
+    // readwrite-readonly.html reaches here.
+    // See crbug.com/668592 for details.
+    return false;
+  }
+  return true;
+}
+
 bool hasEditableStyle(const Node& node) {
   // TODO(editing-dev): We shouldn't check editable style in inactive documents.
   // We should hoist this check in the call stack, replace it by a DCHECK of
   // active document and ultimately cleanup the code paths with inactive
   // documents.  See crbug.com/667681
   if (!node.document().isActive())
     return false;
 
+  if (!canCheckEditableStyleCorrectly(node))
+    return hasEditableLevelDeprecated(node, Editable);
+
+  if (node.document().lifecycle().state() < DocumentLifecycle::StyleClean)
+    node.document().updateStyleAndLayoutTree();
   return hasEditableLevel(node, Editable);
 }
 
 bool hasRichlyEditableStyle(const Node& node) {
   // TODO(editing-dev): We shouldn't check editable style in inactive documents.
   // We should hoist this check in the call stack, replace it by a DCHECK of
   // active document and ultimately cleanup the code paths with inactive
   // documents.  See crbug.com/667681
   if (!node.document().isActive())
     return false;
 
+  if (node.document().lifecycle().state() < DocumentLifecycle::StyleClean)
+    node.document().updateStyleAndLayoutTree();
+
   return hasEditableLevel(node, RichlyEditable);
 }
 
 bool isRootEditableElement(const Node& node) {
   return hasEditableStyle(node) && node.isElementNode() &&
          (!node.parentNode() || !hasEditableStyle(*node.parentNode()) ||
           !node.parentNode()->isElementNode() ||
           &node == node.document().body());
 }
 
@@ skipping 1808 matching lines @@
         return InputType::DeleteWordBackward;
       if (granularity == LineBoundary)
         return InputType::DeleteLineBackward;
       return InputType::DeleteContentBackward;
     default:
       return InputType::None;
   }
 }
 
 }  // namespace blink