Introduce use counters for Blink specific CSS classes for editing

Source/core/editing/ReplaceSelectionCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010, 2011 Google 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
@@ skipping 30 matching lines @@
 #include "core/editing/FrameSelection.h"
 #include "core/editing/HTMLInterchange.h"
 #include "core/editing/SimplifyMarkupCommand.h"
 #include "core/editing/SmartReplace.h"
 #include "core/editing/TextIterator.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/htmlediting.h"
 #include "core/editing/markup.h"
 #include "core/events/BeforeTextInsertedEvent.h"
 #include "core/frame/LocalFrame.h"
+#include "core/frame/UseCounter.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/rendering/RenderObject.h"
 #include "core/rendering/RenderText.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
@@ skipping 221 matching lines @@
 void ReplacementFragment::removeInterchangeNodes(Node* container)
 {
     m_hasInterchangeNewlineAtStart = false;
     m_hasInterchangeNewlineAtEnd = false;
 
     // Interchange newlines at the "start" of the incoming fragment must be
     // either the first node in the fragment or the first leaf in the fragment.
     Node* node = container->firstChild();
     while (node) {
         if (isInterchangeNewlineNode(node)) {
+            UseCounter::count(node->document(), UseCounter::EditingAppleInterchangeNewline);

[Yuta Kitamura, 2014/06/12 07:55:23]

You add some count() calls in predicate functions named
isXXXXNode(), while some in other places (like here).

I'm okay with putting count() calls in either types of
places (inside predicate functions vs use site of
predicate functions), but at least I'd like them to be
placed in a consistent manner.

[yosin_UTC9, 2014/06/12 08:46:06]

You're right. I move count() call to predicate.

             m_hasInterchangeNewlineAtStart = true;
             removeNode(node);
             break;
         }
         node = node->firstChild();
     }
     if (!container->hasChildren())
         return;
     // Interchange newlines at the "end" of the incoming fragment must be
     // either the last node in the fragment or the last leaf in the fragment.
     node = container->lastChild();
     while (node) {
         if (isInterchangeNewlineNode(node)) {
+            UseCounter::count(node->document(), UseCounter::EditingAppleInterchangeNewline);
             m_hasInterchangeNewlineAtEnd = true;
             removeNode(node);
             break;
         }
         node = node->lastChild();
     }
 
     node = container->firstChild();
     while (node) {
         RefPtrWillBeRawPtr<Node> next = NodeTraversal::next(*node);
@@ skipping 96 matching lines @@
         return false;
 
     return !selectionEndWasEndOfParagraph
         && isEndOfParagraph(endOfInsertedContent)
         && !isHTMLBRElement(*endOfInsertedContent.deepEquivalent().deprecatedNode())
         && shouldMerge(endOfInsertedContent, next);
 }
 
 static bool isMailPasteAsQuotationNode(const Node* node)
 {
-    return node && node->hasTagName(blockquoteTag) && toElement(node)->getAttribute(classAttr) == ApplePasteAsQuotation;
+    if (!node || !node->hasTagName(blockquoteTag) || toElement(node)->getAttribute(classAttr) != ApplePasteAsQuotation)
+        return false;
+    UseCounter::count(node->document(), UseCounter::EditingApplePasteAsQuotation);
+    return true;
 }
 
 static bool isHeaderElement(const Node* a)
 {
     if (!a)
         return false;
 
     return a->hasTagName(h1Tag)
         || a->hasTagName(h2Tag)
         || a->hasTagName(h3Tag)
@@ skipping 93 matching lines @@
             removeNodePreservingChildren(element);
             continue;
         }
 
         if (element->parentNode() && element->parentNode()->rendererIsRichlyEditable())
             removeNodeAttribute(element, contenteditableAttr);
 
         // WebKit used to not add display: inline and float: none on copy.
         // Keep this code around for backward compatibility
         if (isLegacyAppleStyleSpan(element)) {
+            UseCounter::count(document(), UseCounter::EditingAppleStyleSpanClass);
             if (!element->firstChild()) {
                 insertedNodes.willRemoveNodePreservingChildren(*element);
                 removeNodePreservingChildren(element);
                 continue;
             }
             // There are other styles that style rules can give to style spans,
             // but these are the two important ones because they'll prevent
             // inserted content from appearing in the right paragraph.
             // FIXME: Hyatt is concerned that selectively using display:inline will give inconsistent
             // results. We already know one issue because td elements ignore their display property
@@ skipping 176 matching lines @@
     // Handling the case where we are doing Paste as Quotation or pasting into quoted content is more complicated (see handleStyleSpans)
     // and doesn't receive the optimization.
     if (isMailPasteAsQuotationNode(topNode) || enclosingNodeOfType(firstPositionInOrBeforeNode(topNode), isMailBlockquote, CanCrossEditingBoundary))
         return false;
 
     // Either there are no style spans in the fragment or a WebKit client has added content to the fragment
     // before inserting it.  Look for and handle style spans after insertion.
     if (!isLegacyAppleStyleSpan(topNode))
         return false;
 
+    UseCounter::count(topNode->document(), UseCounter::EditingAppleStyleSpanClass);
     Node* wrappingStyleSpan = topNode;
     RefPtrWillBeRawPtr<EditingStyle> styleAtInsertionPos = EditingStyle::create(insertionPos.parentAnchoredEquivalent());
     String styleText = styleAtInsertionPos->style()->asText();
 
     // FIXME: This string comparison is a naive way of comparing two styles.
     // We should be taking the diff and check that the diff is empty.
     if (styleText != toElement(wrappingStyleSpan)->getAttribute(styleAttr))
         return false;
 
     fragment.removeNodePreservingChildren(wrappingStyleSpan);
     return true;
 }
 
 // At copy time, WebKit wraps copied content in a span that contains the source document's
 // default styles.  If the copied Range inherits any other styles from its ancestors, we put
 // those styles on a second span.
 // This function removes redundant styles from those spans, and removes the spans if all their
 // styles are redundant.
 // We should remove the Apple-style-span class when we're done, see <rdar://problem/5685600>.
 // We should remove styles from spans that are overridden by all of their children, either here
 // or at copy time.
 void ReplaceSelectionCommand::handleStyleSpans(InsertedNodes& insertedNodes)
 {
     HTMLElement* wrappingStyleSpan = 0;
     // The style span that contains the source document's default style should be at
     // the top of the fragment, but Mail sometimes adds a wrapper (for Paste As Quotation),
     // so search for the top level style span instead of assuming it's at the top.
     for (Node* node = insertedNodes.firstNodeInserted(); node; node = NodeTraversal::next(*node)) {
         if (isLegacyAppleStyleSpan(node)) {
+            UseCounter::count(document(), UseCounter::EditingAppleStyleSpanClass);
             wrappingStyleSpan = toHTMLElement(node);
             break;
         }
     }
 
     // There might not be any style spans if we're pasting from another application or if
     // we are here because of a document.execCommand("InsertHTML", ...) call.
     if (!wrappingStyleSpan)
         return;
 
@@ skipping 89 matching lines @@
     if (isBlock(node))
         return false;
 
     if (!node->isHTMLElement())
         return false;
 
     // We can skip over elements whose class attribute is
     // one of our internal classes.
     const HTMLElement* element = toHTMLElement(node);
     const AtomicString& classAttributeValue = element->getAttribute(classAttr);
-    if (classAttributeValue == AppleTabSpanClass
-        || classAttributeValue == AppleConvertedSpace
-        || classAttributeValue == ApplePasteAsQuotation)
+    if (classAttributeValue == AppleTabSpanClass) {
+        UseCounter::count(node->document(), UseCounter::EditingAppleTabSpanClass);
         return true;
+    }
+    if (classAttributeValue == AppleConvertedSpace) {
+        UseCounter::count(node->document(), UseCounter::EditingAppleConvertedSpace);
+        return true;
+    }
+    if (classAttributeValue == ApplePasteAsQuotation) {
+        UseCounter::count(node->document(), UseCounter::EditingApplePasteAsQuotation);
+        return true;
+    }
 
     return EditingStyle::elementIsStyledSpanOrHTMLEquivalent(element);
 }
 
 inline Node* nodeToSplitToAvoidPastingIntoInlineNodesWithStyle(const Position& insertionPos)
 {
     Node* containgBlock = enclosingBlock(insertionPos.containerNode());
     return highestEnclosingNodeOfType(insertionPos, isInlineNodeWithStyle, CannotCrossEditingBoundary, containgBlock);
 }
 
@@ skipping 185 matching lines @@
 
     InsertedNodes insertedNodes;
     RefPtrWillBeRawPtr<Node> refNode = fragment.firstChild();
     ASSERT(refNode);
     RefPtrWillBeRawPtr<Node> node = refNode->nextSibling();
 
     fragment.removeNode(refNode);
 
     Node* blockStart = enclosingBlock(insertionPos.deprecatedNode());
     if ((isListElement(refNode.get()) || (isLegacyAppleStyleSpan(refNode.get()) && isListElement(refNode->firstChild())))
-        && blockStart && blockStart->renderer()->isListItem())
+        && blockStart && blockStart->renderer()->isListItem()) {
+        if (isLegacyAppleStyleSpan(refNode.get()))
+            UseCounter::count(document(), UseCounter::EditingAppleStyleSpanClass);
         refNode = insertAsListItems(toHTMLElement(refNode), blockStart, insertionPos, insertedNodes);
-    else {
+    } else {
         insertNodeAt(refNode, insertionPos);
         insertedNodes.respondToNodeInsertion(*refNode);
     }
 
     // Mutation events (bug 22634) may have already removed the inserted content
     if (!refNode->inDocument())
         return;
 
     bool plainTextFragment = isPlainTextMarkup(refNode.get());
 
@@ skipping 415 matching lines @@
 void ReplaceSelectionCommand::trace(Visitor* visitor)
 {
     visitor->trace(m_startOfInsertedContent);
     visitor->trace(m_endOfInsertedContent);
     visitor->trace(m_insertionStyle);
     visitor->trace(m_documentFragment);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace WebCore