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 29 matching lines @@
 
     RefPtrWillBeMember<Document> m_document;
     RefPtrWillBeMember<DocumentFragment> m_fragment;
     bool m_hasInterchangeNewlineAtStart;
     bool m_hasInterchangeNewlineAtEnd;
 };
 
 static bool isInterchangeNewlineNode(const Node *node)
 {
     DEFINE_STATIC_LOCAL(String, interchangeNewlineClassString, (AppleInterchangeNewline));
-    return isHTMLBRElement(node) && toElement(node)->getAttribute(classAttr) == interchangeNewlineClassString;
+    if (!isHTMLBRElement(node) || toElement(node)->getAttribute(classAttr) != interchangeNewlineClassString)
+        return false;
+    UseCounter::count(node->document(), UseCounter::EditingAppleInterchangeNewline);
+    return true;
 }
 
 static bool isInterchangeConvertedSpaceSpan(const Node *node)
 {
     DEFINE_STATIC_LOCAL(String, convertedSpaceSpanClassString, (AppleConvertedSpace));
-    return node->isHTMLElement() && toHTMLElement(node)->getAttribute(classAttr) == convertedSpaceSpanClassString;
+    if (!node->isHTMLElement() || toHTMLElement(node)->getAttribute(classAttr) != convertedSpaceSpanClassString)
+        return false;
+    UseCounter::count(node->document(), UseCounter::EditingAppleConvertedSpace);
+    return true;
 }
 
 static Position positionAvoidingPrecedingNodes(Position pos)
 {
     // If we're already on a break, it's probably a placeholder and we shouldn't change our position.
     if (editingIgnoresContent(pos.deprecatedNode()))
         return pos;
 
     // We also stop when changing block flow elements because even though the visual position is the
     // same.  E.g.,
@@ skipping 294 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 427 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 623 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