Rename duplicate symbols inside core/dom

third_party/WebKit/Source/core/dom/Document.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
@@ skipping 243 matching lines @@
 #include "wtf/Functional.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/StringBuffer.h"
 #include "wtf/text/TextEncodingRegistry.h"
 
 #include <memory>
 
-using namespace WTF;
-using namespace Unicode;
-
 #ifndef NDEBUG
 using WeakDocumentSet =
     blink::PersistentHeapHashSet<blink::WeakMember<blink::Document>>;
 static WeakDocumentSet& liveDocumentSet();
 #endif
 
 namespace blink {
 
 using namespace HTMLNames;
 
@@ skipping 33 matching lines @@
 static inline bool isValidNameStart(UChar32 c) {
   // rule (e) above
   if ((c >= 0x02BB && c <= 0x02C1) || c == 0x559 || c == 0x6E5 || c == 0x6E6)
     return true;
 
   // rule (i) above
   if (c == ':' || c == '_')
     return true;
 
   // rules (a) and (f) above
-  const uint32_t nameStartMask = Letter_Lowercase | Letter_Uppercase |
-                                 Letter_Other | Letter_Titlecase |
-                                 Number_Letter;
-  if (!(Unicode::category(c) & nameStartMask))
+  const uint32_t nameStartMask =
+      WTF::Unicode::Letter_Lowercase | WTF::Unicode::Letter_Uppercase |
+      WTF::Unicode::Letter_Other | WTF::Unicode::Letter_Titlecase |
+      WTF::Unicode::Number_Letter;
+  if (!(WTF::Unicode::category(c) & nameStartMask))
     return false;
 
   // rule (c) above
   if (c >= 0xF900 && c < 0xFFFE)
     return false;
 
   // rule (d) above
-  CharDecompositionType decompType = decompositionType(c);
-  if (decompType == DecompositionFont || decompType == DecompositionCompat)
+  WTF::Unicode::CharDecompositionType decompType =
+      WTF::Unicode::decompositionType(c);
+  if (decompType == WTF::Unicode::DecompositionFont ||
+      decompType == WTF::Unicode::DecompositionCompat)
     return false;
 
   return true;
 }
 
 static inline bool isValidNamePart(UChar32 c) {
   // rules (a), (e), and (i) above
   if (isValidNameStart(c))
     return true;
 
   // rules (g) and (h) above
   if (c == 0x00B7 || c == 0x0387)
     return true;
 
   // rule (j) above
   if (c == '-' || c == '.')
     return true;
 
   // rules (b) and (f) above
-  const uint32_t otherNamePartMask = Mark_NonSpacing | Mark_Enclosing |
-                                     Mark_SpacingCombining | Letter_Modifier |
-                                     Number_DecimalDigit;
-  if (!(Unicode::category(c) & otherNamePartMask))
+  const uint32_t otherNamePartMask =
+      WTF::Unicode::Mark_NonSpacing | WTF::Unicode::Mark_Enclosing |
+      WTF::Unicode::Mark_SpacingCombining | WTF::Unicode::Letter_Modifier |
+      WTF::Unicode::Number_DecimalDigit;
+  if (!(WTF::Unicode::category(c) & otherNamePartMask))
     return false;
 
   // rule (c) above
   if (c >= 0xF900 && c < 0xFFFE)
     return false;
 
   // rule (d) above
-  CharDecompositionType decompType = decompositionType(c);
-  if (decompType == DecompositionFont || decompType == DecompositionCompat)
+  WTF::Unicode::CharDecompositionType decompType =
+      WTF::Unicode::decompositionType(c);
+  if (decompType == WTF::Unicode::DecompositionFont ||
+      decompType == WTF::Unicode::DecompositionCompat)
     return false;
 
   return true;
 }
 
 static FrameViewBase* frameViewBaseForElement(const Element& focusedElement) {
   LayoutObject* layoutObject = focusedElement.layoutObject();
   if (!layoutObject || !layoutObject->isLayoutPart())
     return 0;
   return toLayoutPart(layoutObject)->frameViewBase();
@@ skipping 1071 matching lines @@
   unsigned length = title.length();
   unsigned builderIndex = 0;
   const CharacterType* characters = title.getCharacters<CharacterType>();
 
   StringBuffer<CharacterType> buffer(length);
 
   // Replace control characters with spaces and collapse whitespace.
   bool pendingWhitespace = false;
   for (unsigned i = 0; i < length; ++i) {
     UChar32 c = characters[i];
-    if ((c <= spaceCharacter && c != lineTabulationCharacter) ||
-        c == deleteCharacter) {
+    if ((c <= WTF::Unicode::spaceCharacter &&
+         c != WTF::Unicode::lineTabulationCharacter) ||
+        c == WTF::Unicode::deleteCharacter) {
       if (builderIndex != 0)
         pendingWhitespace = true;
     } else {
       if (pendingWhitespace) {
         buffer[builderIndex++] = ' ';
         pendingWhitespace = false;
       }
       buffer[builderIndex++] = c;
     }
   }
@@ skipping 3547 matching lines @@
   // portion of the document. There isn't much user-visible content in the
   // <head>, but there is the <title> element. This function detects that
   // situation and re-decodes the document's title so that the user doesn't see
   // an incorrectly decoded title in the title bar.
   if (m_titleElement && encoding() != newData.encoding() &&
       !ElementTraversal::firstWithin(*m_titleElement) &&
       encoding() == Latin1Encoding() &&
       m_titleElement->textContent().containsOnlyLatin1()) {
     CString originalBytes = m_titleElement->textContent().latin1();
     std::unique_ptr<TextCodec> codec = newTextCodec(newData.encoding());
-    String correctlyDecodedTitle =
-        codec->decode(originalBytes.data(), originalBytes.length(), DataEOF);
+    String correctlyDecodedTitle = codec->decode(
+        originalBytes.data(), originalBytes.length(), WTF::DataEOF);
     m_titleElement->setTextContent(correctlyDecodedTitle);
   }
 
   DCHECK(newData.encoding().isValid());
   m_encodingData = newData;
 
   // FIXME: Should be removed as part of
   // https://code.google.com/p/chromium/issues/detail?id=319643
   bool shouldUseVisualOrdering = m_encodingData.encoding().usesVisualOrdering();
   if (shouldUseVisualOrdering != m_visuallyOrdered) {
@@ skipping 1592 matching lines @@
 }
 
 void showLiveDocumentInstances() {
   WeakDocumentSet& set = liveDocumentSet();
   fprintf(stderr, "There are %u documents currently alive:\n", set.size());
   for (blink::Document* document : set)
     fprintf(stderr, "- Document %p URL: %s\n", document,
             document->url().getString().utf8().data());
 }
 #endif