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

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

 /*
  * Copyright (C) 2013 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 93 matching lines @@
 
 BackgroundHTMLParser::Configuration::Configuration()
     : outstandingTokenLimit(defaultOutstandingTokenLimit),
       pendingTokenLimit(defaultPendingTokenLimit),
       shouldCoalesceChunks(false) {}
 
 BackgroundHTMLParser::BackgroundHTMLParser(
     std::unique_ptr<Configuration> config,
     std::unique_ptr<WebTaskRunner> loadingTaskRunner)
     : m_weakFactory(this),
-      m_token(wrapUnique(new HTMLToken)),
+      m_token(WTF::wrapUnique(new HTMLToken)),
       m_tokenizer(HTMLTokenizer::create(config->options)),
       m_treeBuilderSimulator(config->options),
       m_options(config->options),
       m_outstandingTokenLimit(config->outstandingTokenLimit),
       m_parser(config->parser),
-      m_pendingTokens(wrapUnique(new CompactHTMLTokenStream)),
+      m_pendingTokens(WTF::wrapUnique(new CompactHTMLTokenStream)),
       m_pendingTokenLimit(config->pendingTokenLimit),
       m_xssAuditor(std::move(config->xssAuditor)),
       m_decoder(std::move(config->decoder)),
       m_loadingTaskRunner(std::move(loadingTaskRunner)),
       m_tokenizedChunkQueue(config->tokenizedChunkQueue.release()),
       m_pendingCSPMetaTokenIndex(
           HTMLDocumentParser::TokenizedChunk::noPendingToken),
       m_startingScript(false),
       m_lastBytesReceivedTime(0.0),
       m_shouldCoalesceChunks(config->shouldCoalesceChunks) {
@@ skipping 188 matching lines @@
     return false;
 
 #if ENABLE(ASSERT)
   checkThatTokensAreSafeToSendToAnotherThread(m_pendingTokens.get());
   checkThatPreloadsAreSafeToSendToAnotherThread(m_pendingPreloads);
   checkThatXSSInfosAreSafeToSendToAnotherThread(m_pendingXSSInfos);
 #endif
 
   double chunkStartTime = monotonicallyIncreasingTimeMS();
   std::unique_ptr<HTMLDocumentParser::TokenizedChunk> chunk =
-      wrapUnique(new HTMLDocumentParser::TokenizedChunk);
+      WTF::wrapUnique(new HTMLDocumentParser::TokenizedChunk);
   TRACE_EVENT_WITH_FLOW0("blink,loading",
                          "BackgroundHTMLParser::sendTokensToMainThread",
                          chunk.get(), TRACE_EVENT_FLAG_FLOW_OUT);
 
   if (!m_pendingPreloads.isEmpty()) {
     double delay = monotonicallyIncreasingTimeMS() - m_lastBytesReceivedTime;
     DEFINE_STATIC_LOCAL(CustomCountHistogram, preloadTokenizeDelay,
                         ("Parser.PreloadTokenizeDelay", 1, 10000, 50));
     preloadTokenizeDelay.count(delay);
   }
@@ skipping 14 matching lines @@
   m_startingScript = false;
   m_pendingCSPMetaTokenIndex =
       HTMLDocumentParser::TokenizedChunk::noPendingToken;
 
   bool isEmpty = m_tokenizedChunkQueue->enqueue(std::move(chunk));
 
   DEFINE_STATIC_LOCAL(CustomCountHistogram, chunkEnqueueTime,
                       ("Parser.ChunkEnqueueTime", 1, 10000, 50));
   chunkEnqueueTime.count(monotonicallyIncreasingTimeMS() - chunkStartTime);
 
-  m_pendingTokens = wrapUnique(new CompactHTMLTokenStream);
+  m_pendingTokens = WTF::wrapUnique(new CompactHTMLTokenStream);
   return isEmpty;
 }
 
 // If the background parser is already running on the main thread, then it is
 // not necessary to post a task to the main thread to run asynchronously. The
 // main parser deals with chunking up its own work.
 // TODO(csharrison): This is a pretty big hack because we don't actually need a
 // CrossThreadClosure in these cases. This is just experimental.
 template <typename FunctionType, typename... Ps>
 void BackgroundHTMLParser::runOnMainThread(FunctionType function,
                                            Ps&&... parameters) {
   if (isMainThread()) {
     (*WTF::bind(function, std::forward<Ps>(parameters)...))();
   } else {
     m_loadingTaskRunner->postTask(
         BLINK_FROM_HERE,
         crossThreadBind(function, std::forward<Ps>(parameters)...));
   }
 }
 
 }  // namespace blink