Remove using directives ("using namespace x") from renderer/core/html/parser/.

Bug: 82078
Change-Id: I0b56a851bafdd9894bf8ccd44bf9a765f7170498
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1869828
Commit-Queue: Peter Kasting <pkasting@chromium.org>
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Yoav Weiss <yoavweiss@chromium.org>
Cr-Commit-Position: refs/heads/master@{#709075}

third_party/blink/renderer/core/html/parser/html_construction_site.cc

@@ -69,8 +69,6 @@
 
 namespace blink {
 
-using namespace html_names;
-
 static const unsigned kMaximumHTMLParserDOMTreeDepth = 512;
 
 static inline void SetAttributes(Element* element,
@@ -86,11 +84,16 @@ static inline void SetAttributes(Element* element,
 }
 
 static bool HasImpliedEndTag(const HTMLStackItem* item) {
-  return item->HasTagName(kDdTag) || item->HasTagName(kDtTag) ||
-         item->HasTagName(kLiTag) || item->HasTagName(kOptionTag) ||
-         item->HasTagName(kOptgroupTag) || item->HasTagName(kPTag) ||
-         item->HasTagName(kRbTag) || item->HasTagName(kRpTag) ||
-         item->HasTagName(kRtTag) || item->HasTagName(kRTCTag);
+  return item->HasTagName(html_names::kDdTag) ||
+         item->HasTagName(html_names::kDtTag) ||
+         item->HasTagName(html_names::kLiTag) ||
+         item->HasTagName(html_names::kOptionTag) ||
+         item->HasTagName(html_names::kOptgroupTag) ||
+         item->HasTagName(html_names::kPTag) ||
+         item->HasTagName(html_names::kRbTag) ||
+         item->HasTagName(html_names::kRpTag) ||
+         item->HasTagName(html_names::kRtTag) ||
+         item->HasTagName(html_names::kRTCTag);
 }
 
 static bool ShouldUseLengthLimit(const ContainerNode& node) {
@@ -671,14 +674,14 @@ void HTMLConstructionSite::InsertCommentOnHTMLHtmlElement(
 void HTMLConstructionSite::InsertHTMLHeadElement(AtomicHTMLToken* token) {
   DCHECK(!ShouldFosterParent());
   head_ = MakeGarbageCollected<HTMLStackItem>(
-      CreateElement(token, xhtmlNamespaceURI), token);
+      CreateElement(token, html_names::xhtmlNamespaceURI), token);
   AttachLater(CurrentNode(), head_->GetElement());
   open_elements_.PushHTMLHeadElement(head_);
 }
 
 void HTMLConstructionSite::InsertHTMLBodyElement(AtomicHTMLToken* token) {
   DCHECK(!ShouldFosterParent());
-  Element* body = CreateElement(token, xhtmlNamespaceURI);
+  Element* body = CreateElement(token, html_names::xhtmlNamespaceURI);
   AttachLater(CurrentNode(), body);
   open_elements_.PushHTMLBodyElement(
       MakeGarbageCollected<HTMLStackItem>(body, token));
@@ -689,7 +692,7 @@ void HTMLConstructionSite::InsertHTMLBodyElement(AtomicHTMLToken* token) {
 void HTMLConstructionSite::InsertHTMLFormElement(AtomicHTMLToken* token,
                                                  bool is_demoted) {
   auto* form_element =
-      To<HTMLFormElement>(CreateElement(token, xhtmlNamespaceURI));
+      To<HTMLFormElement>(CreateElement(token, html_names::xhtmlNamespaceURI));
   if (!OpenElements()->HasTemplateInHTMLScope())
     form_ = form_element;
   if (is_demoted) {
@@ -701,7 +704,7 @@ void HTMLConstructionSite::InsertHTMLFormElement(AtomicHTMLToken* token,
 }
 
 void HTMLConstructionSite::InsertHTMLElement(AtomicHTMLToken* token) {
-  Element* element = CreateElement(token, xhtmlNamespaceURI);
+  Element* element = CreateElement(token, html_names::xhtmlNamespaceURI);
   AttachLater(CurrentNode(), element);
   open_elements_.Push(MakeGarbageCollected<HTMLStackItem>(element, token));
 }
@@ -712,7 +715,8 @@ void HTMLConstructionSite::InsertSelfClosingHTMLElementDestroyingToken(
   // Normally HTMLElementStack is responsible for calling finishParsingChildren,
   // but self-closing elements are never in the element stack so the stack
   // doesn't get a chance to tell them that we're done parsing their children.
-  AttachLater(CurrentNode(), CreateElement(token, xhtmlNamespaceURI), true);
+  AttachLater(CurrentNode(),
+              CreateElement(token, html_names::xhtmlNamespaceURI), true);
   // FIXME: Do we want to acknowledge the token's self-closing flag?
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#acknowledge-self-closing-flag
 }
@@ -1066,11 +1070,11 @@ bool HTMLConstructionSite::InQuirksMode() {
 void HTMLConstructionSite::FindFosterSite(HTMLConstructionSiteTask& task) {
   // 2.1
   HTMLElementStack::ElementRecord* last_template =
-      open_elements_.Topmost(kTemplateTag.LocalName());
+      open_elements_.Topmost(html_names::kTemplateTag.LocalName());
 
   // 2.2
   HTMLElementStack::ElementRecord* last_table =
-      open_elements_.Topmost(kTableTag.LocalName());
+      open_elements_.Topmost(html_names::kTableTag.LocalName());
 
   // 2.3
   if (last_template && (!last_table || last_template->IsAbove(last_table))) {

third_party/blink/renderer/core/html/parser/html_document_parser.cc

@@ -70,8 +70,6 @@
 
 namespace blink {
 
-using namespace html_names;
-
 // This is a direct transcription of step 4 from:
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#fragment-case
 static HTMLTokenizer::State TokenizerStateForContextElement(
@@ -83,18 +81,22 @@ static HTMLTokenizer::State TokenizerStateForContextElement(
 
   const QualifiedName& context_tag = context_element->TagQName();
 
-  if (context_tag.Matches(kTitleTag) || context_tag.Matches(kTextareaTag))
+  if (context_tag.Matches(html_names::kTitleTag) ||
+      context_tag.Matches(html_names::kTextareaTag))
     return HTMLTokenizer::kRCDATAState;
-  if (context_tag.Matches(kStyleTag) || context_tag.Matches(kXmpTag) ||
-      context_tag.Matches(kIFrameTag) || context_tag.Matches(kNoembedTag) ||
-      (context_tag.Matches(kNoscriptTag) && options.script_enabled) ||
-      context_tag.Matches(kNoframesTag))
+  if (context_tag.Matches(html_names::kStyleTag) ||
+      context_tag.Matches(html_names::kXmpTag) ||
+      context_tag.Matches(html_names::kIFrameTag) ||
+      context_tag.Matches(html_names::kNoembedTag) ||
+      (context_tag.Matches(html_names::kNoscriptTag) &&
+       options.script_enabled) ||
+      context_tag.Matches(html_names::kNoframesTag))
     return report_errors ? HTMLTokenizer::kRAWTEXTState
                          : HTMLTokenizer::kPLAINTEXTState;
-  if (context_tag.Matches(kScriptTag))
+  if (context_tag.Matches(html_names::kScriptTag))
     return report_errors ? HTMLTokenizer::kScriptDataState
                          : HTMLTokenizer::kPLAINTEXTState;
-  if (context_tag.Matches(kPlaintextTag))
+  if (context_tag.Matches(html_names::kPlaintextTag))
     return HTMLTokenizer::kPLAINTEXTState;
   return HTMLTokenizer::kDataState;
 }

third_party/blink/renderer/core/html/parser/html_element_stack.cc

@@ -36,19 +36,22 @@
 
 namespace blink {
 
-using namespace html_names;
-
 namespace {
 
 inline bool IsRootNode(HTMLStackItem* item) {
-  return item->IsDocumentFragmentNode() || item->HasTagName(kHTMLTag);
+  return item->IsDocumentFragmentNode() ||
+         item->HasTagName(html_names::kHTMLTag);
 }
 
 inline bool IsScopeMarker(HTMLStackItem* item) {
-  return item->HasTagName(kAppletTag) || item->HasTagName(kCaptionTag) ||
-         item->HasTagName(kMarqueeTag) || item->HasTagName(kObjectTag) ||
-         item->HasTagName(kTableTag) || item->HasTagName(kTdTag) ||
-         item->HasTagName(kThTag) || item->HasTagName(mathml_names::kMiTag) ||
+  return item->HasTagName(html_names::kAppletTag) ||
+         item->HasTagName(html_names::kCaptionTag) ||
+         item->HasTagName(html_names::kMarqueeTag) ||
+         item->HasTagName(html_names::kObjectTag) ||
+         item->HasTagName(html_names::kTableTag) ||
+         item->HasTagName(html_names::kTdTag) ||
+         item->HasTagName(html_names::kThTag) ||
+         item->HasTagName(mathml_names::kMiTag) ||
          item->HasTagName(mathml_names::kMoTag) ||
          item->HasTagName(mathml_names::kMnTag) ||
          item->HasTagName(mathml_names::kMsTag) ||
@@ -57,28 +60,29 @@ inline bool IsScopeMarker(HTMLStackItem* item) {
          item->HasTagName(svg_names::kForeignObjectTag) ||
          item->HasTagName(svg_names::kDescTag) ||
          item->HasTagName(svg_names::kTitleTag) ||
-         item->HasTagName(kTemplateTag) || IsRootNode(item);
+         item->HasTagName(html_names::kTemplateTag) || IsRootNode(item);
 }
 
 inline bool IsListItemScopeMarker(HTMLStackItem* item) {
-  return IsScopeMarker(item) || item->HasTagName(kOlTag) ||
-         item->HasTagName(kUlTag);
+  return IsScopeMarker(item) || item->HasTagName(html_names::kOlTag) ||
+         item->HasTagName(html_names::kUlTag);
 }
 
 inline bool IsTableScopeMarker(HTMLStackItem* item) {
-  return item->HasTagName(kTableTag) || item->HasTagName(kTemplateTag) ||
-         IsRootNode(item);
+  return item->HasTagName(html_names::kTableTag) ||
+         item->HasTagName(html_names::kTemplateTag) || IsRootNode(item);
 }
 
 inline bool IsTableBodyScopeMarker(HTMLStackItem* item) {
-  return item->HasTagName(kTbodyTag) || item->HasTagName(kTfootTag) ||
-         item->HasTagName(kTheadTag) || item->HasTagName(kTemplateTag) ||
-         IsRootNode(item);
+  return item->HasTagName(html_names::kTbodyTag) ||
+         item->HasTagName(html_names::kTfootTag) ||
+         item->HasTagName(html_names::kTheadTag) ||
+         item->HasTagName(html_names::kTemplateTag) || IsRootNode(item);
 }
 
 inline bool IsTableRowScopeMarker(HTMLStackItem* item) {
-  return item->HasTagName(kTrTag) || item->HasTagName(kTemplateTag) ||
-         IsRootNode(item);
+  return item->HasTagName(html_names::kTrTag) ||
+         item->HasTagName(html_names::kTemplateTag) || IsRootNode(item);
 }
 
 inline bool IsForeignContentScopeMarker(HTMLStackItem* item) {
@@ -88,11 +92,12 @@ inline bool IsForeignContentScopeMarker(HTMLStackItem* item) {
 }
 
 inline bool IsButtonScopeMarker(HTMLStackItem* item) {
-  return IsScopeMarker(item) || item->HasTagName(kButtonTag);
+  return IsScopeMarker(item) || item->HasTagName(html_names::kButtonTag);
 }
 
 inline bool IsSelectScopeMarker(HTMLStackItem* item) {
-  return !item->HasTagName(kOptgroupTag) && !item->HasTagName(kOptionTag);
+  return !item->HasTagName(html_names::kOptgroupTag) &&
+         !item->HasTagName(html_names::kOptionTag);
 }
 
 }  // namespace
@@ -267,7 +272,7 @@ void HTMLElementStack::PushRootNode(HTMLStackItem* root_item) {
 }
 
 void HTMLElementStack::PushHTMLHtmlElement(HTMLStackItem* item) {
-  DCHECK(item->HasTagName(kHTMLTag));
+  DCHECK(item->HasTagName(html_names::kHTMLTag));
   PushRootNodeCommon(item);
 }
 
@@ -293,9 +298,9 @@ void HTMLElementStack::PushHTMLBodyElement(HTMLStackItem* item) {
 }
 
 void HTMLElementStack::Push(HTMLStackItem* item) {
-  DCHECK(!item->HasTagName(kHTMLTag));
-  DCHECK(!item->HasTagName(kHeadTag));
-  DCHECK(!item->HasTagName(kBodyTag));
+  DCHECK(!item->HasTagName(html_names::kHTMLTag));
+  DCHECK(!item->HasTagName(html_names::kHeadTag));
+  DCHECK(!item->HasTagName(html_names::kBodyTag));
   DCHECK(root_node_);
   PushCommon(item);
 }
@@ -305,9 +310,9 @@ void HTMLElementStack::InsertAbove(HTMLStackItem* item,
   DCHECK(item);
   DCHECK(record_below);
   DCHECK(top_);
-  DCHECK(!item->HasTagName(kHTMLTag));
-  DCHECK(!item->HasTagName(kHeadTag));
-  DCHECK(!item->HasTagName(kBodyTag));
+  DCHECK(!item->HasTagName(html_names::kHTMLTag));
+  DCHECK(!item->HasTagName(html_names::kHeadTag));
+  DCHECK(!item->HasTagName(html_names::kBodyTag));
   DCHECK(root_node_);
   if (record_below == top_) {
     Push(item);
@@ -466,7 +471,8 @@ bool HTMLElementStack::InSelectScope(const QualifiedName& tag_name) const {
 }
 
 bool HTMLElementStack::HasTemplateInHTMLScope() const {
-  return InScopeCommon<IsRootNode>(top_.Get(), kTemplateTag.LocalName());
+  return InScopeCommon<IsRootNode>(top_.Get(),
+                                   html_names::kTemplateTag.LocalName());
 }
 
 Element* HTMLElementStack::HtmlElement() const {
@@ -497,9 +503,9 @@ void HTMLElementStack::PushCommon(HTMLStackItem* item) {
 }
 
 void HTMLElementStack::PopCommon() {
-  DCHECK(!TopStackItem()->HasTagName(kHTMLTag));
-  DCHECK(!TopStackItem()->HasTagName(kHeadTag) || !head_element_);
-  DCHECK(!TopStackItem()->HasTagName(kBodyTag) || !body_element_);
+  DCHECK(!TopStackItem()->HasTagName(html_names::kHTMLTag));
+  DCHECK(!TopStackItem()->HasTagName(html_names::kHeadTag) || !head_element_);
+  DCHECK(!TopStackItem()->HasTagName(html_names::kBodyTag) || !body_element_);
   Top()->FinishParsingChildren();
   top_ = top_->ReleaseNext();
 

third_party/blink/renderer/core/html/parser/html_meta_charset_parser.cc

@@ -34,8 +34,6 @@
 
 namespace blink {
 
-using namespace html_names;
-
 HTMLMetaCharsetParser::HTMLMetaCharsetParser()
     : tokenizer_(std::make_unique<HTMLTokenizer>(HTMLParserOptions(nullptr))),
       assumed_codec_(NewTextCodec(Latin1Encoding())),
@@ -94,22 +92,22 @@ bool HTMLMetaCharsetParser::CheckForMetaCharset(const char* data,
           AttemptStaticStringCreation(token_.GetName(), kLikely8Bit);
       if (!end) {
         tokenizer_->UpdateStateFor(tag_name);
-        if (ThreadSafeMatch(tag_name, kMetaTag) && ProcessMeta()) {
+        if (ThreadSafeMatch(tag_name, html_names::kMetaTag) && ProcessMeta()) {
           done_checking_ = true;
           return true;
         }
       }
 
-      if (!ThreadSafeMatch(tag_name, kScriptTag) &&
-          !ThreadSafeMatch(tag_name, kNoscriptTag) &&
-          !ThreadSafeMatch(tag_name, kStyleTag) &&
-          !ThreadSafeMatch(tag_name, kLinkTag) &&
-          !ThreadSafeMatch(tag_name, kMetaTag) &&
-          !ThreadSafeMatch(tag_name, kObjectTag) &&
-          !ThreadSafeMatch(tag_name, kTitleTag) &&
-          !ThreadSafeMatch(tag_name, kBaseTag) &&
-          (end || !ThreadSafeMatch(tag_name, kHTMLTag)) &&
-          (end || !ThreadSafeMatch(tag_name, kHeadTag))) {
+      if (!ThreadSafeMatch(tag_name, html_names::kScriptTag) &&
+          !ThreadSafeMatch(tag_name, html_names::kNoscriptTag) &&
+          !ThreadSafeMatch(tag_name, html_names::kStyleTag) &&
+          !ThreadSafeMatch(tag_name, html_names::kLinkTag) &&
+          !ThreadSafeMatch(tag_name, html_names::kMetaTag) &&
+          !ThreadSafeMatch(tag_name, html_names::kObjectTag) &&
+          !ThreadSafeMatch(tag_name, html_names::kTitleTag) &&
+          !ThreadSafeMatch(tag_name, html_names::kBaseTag) &&
+          (end || !ThreadSafeMatch(tag_name, html_names::kHTMLTag)) &&
+          (end || !ThreadSafeMatch(tag_name, html_names::kHeadTag))) {
         in_head_section_ = false;
       }
     }

third_party/blink/renderer/core/html/parser/html_parser_idioms.cc

@@ -36,8 +36,6 @@
 
 namespace blink {
 
-using namespace html_names;
-
 template <typename CharType>
 static String StripLeadingAndTrailingHTMLSpaces(String string,
                                                 const CharType* characters,
@@ -380,14 +378,15 @@ WTF::TextEncoding EncodingFromMetaAttributes(
     const String& attribute_name = html_attribute.first;
     const AtomicString& attribute_value = AtomicString(html_attribute.second);
 
-    if (ThreadSafeMatch(attribute_name, kHttpEquivAttr)) {
+    if (ThreadSafeMatch(attribute_name, html_names::kHttpEquivAttr)) {
       if (DeprecatedEqualIgnoringCase(attribute_value, "content-type"))
         got_pragma = true;
-    } else if (ThreadSafeMatch(attribute_name, kCharsetAttr)) {
+    } else if (ThreadSafeMatch(attribute_name, html_names::kCharsetAttr)) {
       has_charset = true;
       charset = attribute_value;
       mode = MetaAttribute::kCharset;
-    } else if (!has_charset && ThreadSafeMatch(attribute_name, kContentAttr)) {
+    } else if (!has_charset &&
+               ThreadSafeMatch(attribute_name, html_names::kContentAttr)) {
       charset = ExtractCharset(attribute_value);
       if (charset.length())
         mode = MetaAttribute::kPragma;

third_party/blink/renderer/core/html/parser/html_tokenizer.cc

@@ -38,8 +38,6 @@
 
 namespace blink {
 
-using namespace html_names;
-
 static inline UChar ToLowerCase(UChar cc) {
   DCHECK(IsASCIIAlpha(cc));
   return cc | 0x20;
@@ -603,7 +601,7 @@ bool HTMLTokenizer::NextToken(SegmentedString& source, HTMLToken& token) {
     HTML_BEGIN_STATE(kScriptDataDoubleEscapeStartState) {
       if (IsTokenizerWhitespace(cc) || cc == '/' || cc == '>') {
         BufferCharacter(cc);
-        if (TemporaryBufferIs(kScriptTag.LocalName()))
+        if (TemporaryBufferIs(html_names::kScriptTag.LocalName()))
           HTML_ADVANCE_TO(kScriptDataDoubleEscapedState);
         else
           HTML_ADVANCE_TO(kScriptDataEscapedState);
@@ -683,7 +681,7 @@ bool HTMLTokenizer::NextToken(SegmentedString& source, HTMLToken& token) {
     HTML_BEGIN_STATE(kScriptDataDoubleEscapeEndState) {
       if (IsTokenizerWhitespace(cc) || cc == '/' || cc == '>') {
         BufferCharacter(cc);
-        if (TemporaryBufferIs(kScriptTag.LocalName()))
+        if (TemporaryBufferIs(html_names::kScriptTag.LocalName()))
           HTML_ADVANCE_TO(kScriptDataEscapedState);
         else
           HTML_ADVANCE_TO(kScriptDataDoubleEscapedState);
@@ -1454,19 +1452,20 @@ String HTMLTokenizer::BufferedCharacters() const {
 }
 
 void HTMLTokenizer::UpdateStateFor(const String& tag_name) {
-  if (ThreadSafeMatch(tag_name, kTextareaTag) ||
-      ThreadSafeMatch(tag_name, kTitleTag))
+  if (ThreadSafeMatch(tag_name, html_names::kTextareaTag) ||
+      ThreadSafeMatch(tag_name, html_names::kTitleTag))
     SetState(HTMLTokenizer::kRCDATAState);
-  else if (ThreadSafeMatch(tag_name, kPlaintextTag))
+  else if (ThreadSafeMatch(tag_name, html_names::kPlaintextTag))
     SetState(HTMLTokenizer::kPLAINTEXTState);
-  else if (ThreadSafeMatch(tag_name, kScriptTag))
+  else if (ThreadSafeMatch(tag_name, html_names::kScriptTag))
     SetState(HTMLTokenizer::kScriptDataState);
-  else if (ThreadSafeMatch(tag_name, kStyleTag) ||
-           ThreadSafeMatch(tag_name, kIFrameTag) ||
-           ThreadSafeMatch(tag_name, kXmpTag) ||
-           ThreadSafeMatch(tag_name, kNoembedTag) ||
-           ThreadSafeMatch(tag_name, kNoframesTag) ||
-           (ThreadSafeMatch(tag_name, kNoscriptTag) && options_.script_enabled))
+  else if (ThreadSafeMatch(tag_name, html_names::kStyleTag) ||
+           ThreadSafeMatch(tag_name, html_names::kIFrameTag) ||
+           ThreadSafeMatch(tag_name, html_names::kXmpTag) ||
+           ThreadSafeMatch(tag_name, html_names::kNoembedTag) ||
+           ThreadSafeMatch(tag_name, html_names::kNoframesTag) ||
+           (ThreadSafeMatch(tag_name, html_names::kNoscriptTag) &&
+            options_.script_enabled))
     SetState(HTMLTokenizer::kRAWTEXTState);
 }
 

third_party/blink/renderer/core/html/parser/text_document_parser.cc

@@ -30,8 +30,6 @@
 
 namespace blink {
 
-using namespace html_names;
-
 TextDocumentParser::TextDocumentParser(HTMLDocument& document,
                                        ParserSynchronizationPolicy sync_policy)
     : HTMLDocumentParser(document, sync_policy),
@@ -55,10 +53,10 @@ void TextDocumentParser::InsertFakePreElement() {
   // fake bytes through the front-end of the parser to avoid distrubing the
   // line/column number calculations.
   Vector<Attribute> attributes;
-  attributes.push_back(
-      Attribute(kStyleAttr, "word-wrap: break-word; white-space: pre-wrap;"));
-  AtomicHTMLToken fake_pre(HTMLToken::kStartTag, kPreTag.LocalName(),
-                           attributes);
+  attributes.push_back(Attribute(
+      html_names::kStyleAttr, "word-wrap: break-word; white-space: pre-wrap;"));
+  AtomicHTMLToken fake_pre(HTMLToken::kStartTag,
+                           html_names::kPreTag.LocalName(), attributes);
   TreeBuilder()->ConstructTree(&fake_pre);
 
   // The document could have been detached by an extension while the