s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

third_party/WebKit/Source/core/html/parser/HTMLDocumentParser.cpp

 /*
  * Copyright (C) 2010 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 107 matching lines @@
       tokenizerStateForContextElement(contextElement, reportErrors, m_options));
   m_xssAuditor.initForFragment();
 }
 
 HTMLDocumentParser::HTMLDocumentParser(Document& document,
                                        ParserContentPolicy contentPolicy,
                                        ParserSynchronizationPolicy syncPolicy)
     : ScriptableDocumentParser(document, contentPolicy),
       m_options(&document),
       m_reentryPermit(HTMLParserReentryPermit::create()),
-      m_token(syncPolicy == ForceSynchronousParsing ? wrapUnique(new HTMLToken)
-                                                    : nullptr),
+      m_token(syncPolicy == ForceSynchronousParsing
+                  ? WTF::wrapUnique(new HTMLToken)
+                  : nullptr),
       m_tokenizer(syncPolicy == ForceSynchronousParsing
                       ? HTMLTokenizer::create(m_options)
                       : nullptr),
       m_loadingTaskRunner(
           TaskRunnerHelper::get(TaskType::Networking, &document)->clone()),
       m_parserScheduler(
           syncPolicy == AllowAsynchronousParsing
               ? HTMLParserScheduler::create(this, m_loadingTaskRunner.get())
               : nullptr),
       m_xssAuditorDelegate(&document),
@@ skipping 311 matching lines @@
   }
   DEFINE_STATIC_LOCAL(CustomCountHistogram, discardedTokenCountHistogram,
                       ("Parser.DiscardedTokenCount", 1, 100000, 50));
   discardedTokenCountHistogram.count(discardedTokenCount);
 
   m_speculations.clear();
   m_pendingCSPMetaToken = nullptr;
   m_queuedPreloads.clear();
 
   std::unique_ptr<BackgroundHTMLParser::Checkpoint> checkpoint =
-      wrapUnique(new BackgroundHTMLParser::Checkpoint);
+      WTF::wrapUnique(new BackgroundHTMLParser::Checkpoint);
   checkpoint->parser = m_weakFactory.createWeakPtr();
   checkpoint->token = std::move(token);
   checkpoint->tokenizer = std::move(tokenizer);
   checkpoint->treeBuilderState =
       HTMLTreeBuilderSimulator::stateFor(m_treeBuilder.get());
   checkpoint->inputCheckpoint = lastChunkBeforeScript->inputCheckpoint;
   checkpoint->preloadScannerCheckpoint =
       lastChunkBeforeScript->preloadScannerCheckpoint;
   checkpoint->unparsedInput = m_input.current().toString().isolatedCopy();
   // FIXME: This should be passed in instead of cleared.
   m_input.current().clear();
 
   ASSERT(checkpoint->unparsedInput.isSafeToSendToAnotherThread());
   postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::resumeFrom,
-                            m_backgroundParser, passed(std::move(checkpoint)));
+                            m_backgroundParser,
+                            WTF::passed(std::move(checkpoint)));
 }
 
 size_t HTMLDocumentParser::processTokenizedChunkFromBackgroundParser(
     std::unique_ptr<TokenizedChunk> popChunk) {
   TRACE_EVENT_WITH_FLOW0(
       "blink,loading",
       "HTMLDocumentParser::processTokenizedChunkFromBackgroundParser",
       popChunk.get(), TRACE_EVENT_FLAG_FLOW_IN);
   AutoReset<bool> hasLineNumber(&m_isParsingAtLineNumber, true);
 
@@ skipping 288 matching lines @@
 void HTMLDocumentParser::insert(const SegmentedString& source) {
   if (isStopped())
     return;
 
   TRACE_EVENT1("blink", "HTMLDocumentParser::insert", "source_length",
                source.length());
 
   if (!m_tokenizer) {
     ASSERT(!inPumpSession());
     ASSERT(m_haveBackgroundParser || wasCreatedByScript());
-    m_token = wrapUnique(new HTMLToken);
+    m_token = WTF::wrapUnique(new HTMLToken);
     m_tokenizer = HTMLTokenizer::create(m_options);
   }
 
   SegmentedString excludedLineNumberSource(source);
   excludedLineNumberSource.setExcludeLineNumbers();
   m_input.insertAtCurrentInsertionPoint(excludedLineNumberSource);
   pumpTokenizerIfPossible();
 
   if (isWaitingForScripts()) {
     // Check the document.write() output with a separate preload scanner as
@@ skipping 18 matching lines @@
   // when background parser goes away.
   if (document()->frame() && document()->frame()->frameScheduler())
     document()->frame()->frameScheduler()->setDocumentParsingInBackground(true);
 
   // Make sure that a resolver is set up, so that the correct viewport
   // dimensions will be fed to the background parser and preload scanner.
   if (document()->loader())
     document()->ensureStyleResolver();
 
   std::unique_ptr<BackgroundHTMLParser::Configuration> config =
-      wrapUnique(new BackgroundHTMLParser::Configuration);
+      WTF::wrapUnique(new BackgroundHTMLParser::Configuration);
   config->options = m_options;
   config->parser = m_weakFactory.createWeakPtr();
-  config->xssAuditor = wrapUnique(new XSSAuditor);
+  config->xssAuditor = WTF::wrapUnique(new XSSAuditor);
   config->xssAuditor->init(document(), &m_xssAuditorDelegate);
 
   config->decoder = takeDecoder();
   config->tokenizedChunkQueue = m_tokenizedChunkQueue.get();
   if (document()->settings()) {
     if (document()->settings()->backgroundHtmlParserOutstandingTokenLimit())
       config->outstandingTokenLimit =
           document()->settings()->backgroundHtmlParserOutstandingTokenLimit();
     if (document()->settings()->backgroundHtmlParserPendingTokenLimit())
       config->pendingTokenLimit =
           document()->settings()->backgroundHtmlParserPendingTokenLimit();
     config->shouldCoalesceChunks =
         document()->settings()->parseHTMLOnMainThreadCoalesceChunks();
   }
 
   ASSERT(config->xssAuditor->isSafeToSendToAnotherThread());
 
   // The background parser is created on the main thread, but may otherwise
   // only be used from the parser thread.
   m_backgroundParser = BackgroundHTMLParser::create(
       std::move(config), m_loadingTaskRunner->clone());
   // TODO(csharrison): This is a hack to initialize MediaValuesCached on the
   // correct thread. We should get rid of it.
   postTaskToLookaheadParser(
       Synchronous, &BackgroundHTMLParser::init, m_backgroundParser,
-      document()->url(), passed(CachedDocumentParameters::create(document())),
+      document()->url(),
+      WTF::passed(CachedDocumentParameters::create(document())),
       MediaValuesCached::MediaValuesCachedData(*document()));
 }
 
 void HTMLDocumentParser::stopBackgroundParser() {
   ASSERT(shouldUseThreading());
   ASSERT(m_haveBackgroundParser);
 
   if (m_haveBackgroundParser && document()->frame() &&
       document()->frame()->frameScheduler())
     document()->frame()->frameScheduler()->setDocumentParsingInBackground(
@@ skipping 123 matching lines @@
       m_input.closeWithoutMarkingEndOfFile();
     postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::finish,
                               m_backgroundParser);
     return;
   }
 
   if (!m_tokenizer) {
     ASSERT(!m_token);
     // We're finishing before receiving any data. Rather than booting up the
     // background parser just to spin it down, we finish parsing synchronously.
-    m_token = wrapUnique(new HTMLToken);
+    m_token = WTF::wrapUnique(new HTMLToken);
     m_tokenizer = HTMLTokenizer::create(m_options);
   }
 
   // We're not going to get any more data off the network, so we tell the input
   // stream we've reached the end of file. finish() can be called more than
   // once, if the first time does not call end().
   if (!m_input.haveSeenEndOfFile())
     m_input.markEndOfFile();
 
   attemptToEnd();
@@ skipping 131 matching lines @@
 
 void HTMLDocumentParser::appendBytes(const char* data, size_t length) {
   if (!length || isStopped())
     return;
 
   if (shouldUseThreading()) {
     double bytesReceivedTime = monotonicallyIncreasingTimeMS();
     if (!m_haveBackgroundParser)
       startBackgroundParser();
 
-    std::unique_ptr<Vector<char>> buffer = makeUnique<Vector<char>>(length);
+    std::unique_ptr<Vector<char>> buffer =
+        WTF::makeUnique<Vector<char>>(length);
     memcpy(buffer->data(), data, length);
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.debug"),
                  "HTMLDocumentParser::appendBytes", "size", (unsigned)length);
 
     LookaheadParserTaskSynchrony policy =
         document()->settings() &&
                 document()->settings()->parseHTMLOnMainThreadSyncTokenize()
             ? Synchronous
             : Asynchronous;
     postTaskToLookaheadParser(
         policy, &BackgroundHTMLParser::appendRawBytesFromMainThread,
-        m_backgroundParser, passed(std::move(buffer)), bytesReceivedTime);
+        m_backgroundParser, WTF::passed(std::move(buffer)), bytesReceivedTime);
     return;
   }
 
   DecodedDataDocumentParser::appendBytes(data, length);
 }
 
 void HTMLDocumentParser::flush() {
   // If we've got no decoder, we never received any data.
   if (isDetached() || needsDecoder())
     return;
 
   if (shouldUseThreading()) {
     // In some cases, flush() is called without any invocation of appendBytes.
     // Fallback to synchronous parsing in that case.
     if (!m_haveBackgroundParser) {
       m_shouldUseThreading = false;
-      m_token = wrapUnique(new HTMLToken);
+      m_token = WTF::wrapUnique(new HTMLToken);
       m_tokenizer = HTMLTokenizer::create(m_options);
       DecodedDataDocumentParser::flush();
       return;
     }
 
     postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::flush,
                               m_backgroundParser);
   } else {
     DecodedDataDocumentParser::flush();
   }
 }
 
 void HTMLDocumentParser::setDecoder(
     std::unique_ptr<TextResourceDecoder> decoder) {
   ASSERT(decoder);
   DecodedDataDocumentParser::setDecoder(std::move(decoder));
 
-  if (m_haveBackgroundParser)
+  if (m_haveBackgroundParser) {
     postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::setDecoder,
-                              m_backgroundParser, passed(takeDecoder()));
+                              m_backgroundParser, WTF::passed(takeDecoder()));
+  }
 }
 
 void HTMLDocumentParser::documentElementAvailable() {
   TRACE_EVENT0("blink,loader", "HTMLDocumentParser::documentElementAvailable");
   DCHECK(document()->documentElement());
   fetchQueuedPreloads();
 }
 
 std::unique_ptr<HTMLPreloadScanner> HTMLDocumentParser::createPreloadScanner() {
   return HTMLPreloadScanner::create(
@@ skipping 97 matching lines @@
     case Asynchronous:
       m_loadingTaskRunner->postTask(
           BLINK_FROM_HERE,
           WTF::bind(function, std::forward<Ps>(parameters)...));
       return;
   }
   NOTREACHED();
 }
 
 }  // namespace blink