Remove webkit- prefix from classes used by View Source

Source/core/html/HTMLViewSourceDocument.cpp

 /*
  * Copyright (C) 2006, 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 63 matching lines @@
     RefPtrWillBeRawPtr<HTMLHtmlElement> html = HTMLHtmlElement::create(*this);
     parserAppendChild(html);
     RefPtrWillBeRawPtr<HTMLHeadElement> head = HTMLHeadElement::create(*this);
     html->parserAppendChild(head);
     RefPtrWillBeRawPtr<HTMLBodyElement> body = HTMLBodyElement::create(*this);
     html->parserAppendChild(body);
 
     // Create a line gutter div that can be used to make sure the gutter extends down the height of the whole
     // document.
     RefPtrWillBeRawPtr<HTMLDivElement> div = HTMLDivElement::create(*this);
-    div->setAttribute(classAttr, "webkit-line-gutter-backdrop");
+    div->setAttribute(classAttr, "line-gutter-backdrop");
     body->parserAppendChild(div);
 
     RefPtrWillBeRawPtr<HTMLTableElement> table = HTMLTableElement::create(*this);
     body->parserAppendChild(table);
     m_tbody = HTMLTableSectionElement::create(tbodyTag, *this);
     table->parserAppendChild(m_tbody);
     m_current = m_tbody;
     m_lineNumber = 0;
 }
 
@@ skipping 20 matching lines @@
         processCommentToken(source, token);
         break;
     case HTMLToken::Character:
         processCharacterToken(source, token, annotation);
         break;
     }
 }
 
 void HTMLViewSourceDocument::processDoctypeToken(const String& source, HTMLToken&)
 {
-    m_current = addSpanWithClassName("webkit-html-doctype");
-    addText(source, "webkit-html-doctype");
+    m_current = addSpanWithClassName("html-doctype");
+    addText(source, "html-doctype");
     m_current = m_td;
 }
 
 void HTMLViewSourceDocument::processEndOfFileToken(const String& source, HTMLToken&)
 {
-    m_current = addSpanWithClassName("webkit-html-end-of-file");
-    addText(source, "webkit-html-end-of-file");
+    m_current = addSpanWithClassName("html-end-of-file");
+    addText(source, "html-end-of-file");
     m_current = m_td;
 }
 
 void HTMLViewSourceDocument::processTagToken(const String& source, HTMLToken& token, SourceAnnotation annotation)
 {
     maybeAddSpanForAnnotation(annotation);
-    m_current = addSpanWithClassName("webkit-html-tag");
+    m_current = addSpanWithClassName("html-tag");
 
     AtomicString tagName(token.name());
 
     unsigned index = 0;
     HTMLToken::AttributeList::const_iterator iter = token.attributes().begin();
     while (index < source.length()) {
         if (iter == token.attributes().end()) {
             // We want to show the remaining characters in the token.
             index = addRange(source, index, source.length(), emptyAtom);
             ASSERT(index == source.length());
             break;
         }
 
         AtomicString name(iter->name);
         AtomicString value(StringImpl::create8BitIfPossible(iter->value));
 
         index = addRange(source, index, iter->nameRange.start - token.startIndex(), emptyAtom);
-        index = addRange(source, index, iter->nameRange.end - token.startIndex(), "webkit-html-attribute-name");
+        index = addRange(source, index, iter->nameRange.end - token.startIndex(), "html-attribute-name");
 
         if (tagName == baseTag && name == hrefAttr)
             addBase(value);
 
         index = addRange(source, index, iter->valueRange.start - token.startIndex(), emptyAtom);
 
         bool isLink = name == srcAttr || name == hrefAttr;
-        index = addRange(source, index, iter->valueRange.end - token.startIndex(), "webkit-html-attribute-value", isLink, tagName == aTag, value);
+        index = addRange(source, index, iter->valueRange.end - token.startIndex(), "html-attribute-value", isLink, tagName == aTag, value);
 
         ++iter;
     }
     m_current = m_td;
 }
 
 void HTMLViewSourceDocument::processCommentToken(const String& source, HTMLToken&)
 {
-    m_current = addSpanWithClassName("webkit-html-comment");
-    addText(source, "webkit-html-comment");
+    m_current = addSpanWithClassName("html-comment");
+    addText(source, "html-comment");
     m_current = m_td;
 }
 
 void HTMLViewSourceDocument::processCharacterToken(const String& source, HTMLToken&, SourceAnnotation annotation)
 {
     addText(source, "", annotation);
 }
 
 PassRefPtrWillBeRawPtr<Element> HTMLViewSourceDocument::addSpanWithClassName(const AtomicString& className)
 {
     if (m_current == m_tbody) {
         addLine(className);
         return m_current;
     }
 
     RefPtrWillBeRawPtr<HTMLSpanElement> span = HTMLSpanElement::create(*this);
     span->setAttribute(classAttr, className);
     m_current->parserAppendChild(span);
     return span.release();
 }
 
 void HTMLViewSourceDocument::addLine(const AtomicString& className)
 {
     // Create a table row.
     RefPtrWillBeRawPtr<HTMLTableRowElement> trow = HTMLTableRowElement::create(*this);
     m_tbody->parserAppendChild(trow);
 
     // Create a cell that will hold the line number (it is generated in the stylesheet using counters).
     RefPtrWillBeRawPtr<HTMLTableCellElement> td = HTMLTableCellElement::create(tdTag, *this);
-    td->setAttribute(classAttr, "webkit-line-number");
+    td->setAttribute(classAttr, "line-number");
     td->setIntegralAttribute(valueAttr, ++m_lineNumber);
     trow->parserAppendChild(td);
 
     // Create a second cell for the line contents
     td = HTMLTableCellElement::create(tdTag, *this);
-    td->setAttribute(classAttr, "webkit-line-content");
+    td->setAttribute(classAttr, "line-content");
     trow->parserAppendChild(td);
     m_current = m_td = td;
 
     // Open up the needed spans.
     if (!className.isEmpty()) {
-        if (className == "webkit-html-attribute-name" || className == "webkit-html-attribute-value")
-            m_current = addSpanWithClassName("webkit-html-tag");
+        if (className == "html-attribute-name" || className == "html-attribute-value")
+            m_current = addSpanWithClassName("html-tag");
         m_current = addSpanWithClassName(className);
     }
 }
 
 void HTMLViewSourceDocument::finishLine()
 {
     if (!m_current->hasChildren()) {
         RefPtrWillBeRawPtr<HTMLBRElement> br = HTMLBRElement::create(*this);
         m_current->parserAppendChild(br);
     }
@@ skipping 51 matching lines @@
 {
     RefPtrWillBeRawPtr<HTMLBaseElement> base = HTMLBaseElement::create(*this);
     base->setAttribute(hrefAttr, href);
     m_current->parserAppendChild(base);
     return base.release();
 }
 
 PassRefPtrWillBeRawPtr<Element> HTMLViewSourceDocument::addLink(const AtomicString& url, bool isAnchor)
 {
     if (m_current == m_tbody)
-        addLine("webkit-html-tag");
+        addLine("html-tag");
 
     // Now create a link for the attribute value instead of a span.
     RefPtrWillBeRawPtr<HTMLAnchorElement> anchor = HTMLAnchorElement::create(*this);
     const char* classValue;
     if (isAnchor)
-        classValue = "webkit-html-attribute-value webkit-html-external-link";
+        classValue = "html-attribute-value html-external-link";
     else
-        classValue = "webkit-html-attribute-value webkit-html-resource-link";
+        classValue = "html-attribute-value html-resource-link";
     anchor->setAttribute(classAttr, classValue);
     anchor->setAttribute(targetAttr, "_blank");
     anchor->setAttribute(hrefAttr, url);
     m_current->parserAppendChild(anchor);
     return anchor.release();
 }
 
 void HTMLViewSourceDocument::maybeAddSpanForAnnotation(SourceAnnotation annotation)
 {
     if (annotation == AnnotateSourceAsXSS) {
-        m_current = addSpanWithClassName("webkit-highlight");
+        m_current = addSpanWithClassName("highlight");
         m_current->setAttribute(titleAttr, kXSSDetected);
     }
 }
 
 void HTMLViewSourceDocument::trace(Visitor* visitor)
 {
     visitor->trace(m_current);
     visitor->trace(m_tbody);
     visitor->trace(m_td);
     HTMLDocument::trace(visitor);
 }
 
 }