Rename ParsedChunk to TokenizedChunk in core/html/parser

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 92 matching lines @@
     , m_treeBuilderSimulator(config->options)
     , m_options(config->options)
     , m_outstandingTokenLimit(config->outstandingTokenLimit)
     , m_parser(config->parser)
     , m_pendingTokens(wrapUnique(new CompactHTMLTokenStream))
     , m_pendingTokenLimit(config->pendingTokenLimit)
     , m_xssAuditor(std::move(config->xssAuditor))
     , m_preloadScanner(wrapUnique(new TokenPreloadScanner(documentURL, std::move(cachedDocumentParameters), mediaValuesCachedData)))
     , m_decoder(std::move(config->decoder))
     , m_loadingTaskRunner(std::move(loadingTaskRunner))
-    , m_parsedChunkQueue(config->parsedChunkQueue.release())
+    , m_tokenizedChunkQueue(config->tokenizedChunkQueue.release())
     , m_startingScript(false)
     , m_lastBytesReceivedTime(0.0)
 {
     ASSERT(m_outstandingTokenLimit > 0);
     ASSERT(m_pendingTokenLimit > 0);
     ASSERT(m_outstandingTokenLimit >= m_pendingTokenLimit);
 }
 
 BackgroundHTMLParser::~BackgroundHTMLParser()
 {
@@ skipping 46 matching lines @@
 
 void BackgroundHTMLParser::resumeFrom(std::unique_ptr<Checkpoint> checkpoint)
 {
     m_parser = checkpoint->parser;
     m_token = std::move(checkpoint->token);
     m_tokenizer = std::move(checkpoint->tokenizer);
     m_treeBuilderSimulator.setState(checkpoint->treeBuilderState);
     m_input.rewindTo(checkpoint->inputCheckpoint, checkpoint->unparsedInput);
     m_preloadScanner->rewindTo(checkpoint->preloadScannerCheckpoint);
     m_startingScript = false;
-    m_parsedChunkQueue->clear();
+    m_tokenizedChunkQueue->clear();
     m_lastBytesReceivedTime = monotonicallyIncreasingTimeMS();
     pumpTokenizer();
 }
 
 void BackgroundHTMLParser::startedChunkWithCheckpoint(HTMLInputCheckpoint inputCheckpoint)
 {
     // Note, we should not have to worry about the index being invalid
     // as messages from the main thread will be processed in FIFO order.
     m_input.invalidateCheckpointsBefore(inputCheckpoint);
     pumpTokenizer();
@@ skipping 91 matching lines @@
     if (m_pendingTokens->isEmpty())
         return;
 
 #if ENABLE(ASSERT)
     checkThatTokensAreSafeToSendToAnotherThread(m_pendingTokens.get());
     checkThatPreloadsAreSafeToSendToAnotherThread(m_pendingPreloads);
     checkThatXSSInfosAreSafeToSendToAnotherThread(m_pendingXSSInfos);
 #endif
 
     double chunkStartTime = monotonicallyIncreasingTimeMS();
-    std::unique_ptr<HTMLDocumentParser::ParsedChunk> chunk = wrapUnique(new HTMLDocumentParser::ParsedChunk);
+    std::unique_ptr<HTMLDocumentParser::TokenizedChunk> chunk = 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);
     }
 
     chunk->preloads.swap(m_pendingPreloads);
     if (m_viewportDescription.set)
         chunk->viewport = m_viewportDescription;
     chunk->xssInfos.swap(m_pendingXSSInfos);
     chunk->tokenizerState = m_tokenizer->getState();
     chunk->treeBuilderState = m_treeBuilderSimulator.state();
     chunk->inputCheckpoint = m_input.createCheckpoint(m_pendingTokens->size());
     chunk->preloadScannerCheckpoint = m_preloadScanner->createCheckpoint();
     chunk->tokens = std::move(m_pendingTokens);
     chunk->startingScript = m_startingScript;
     chunk->likelyDocumentWriteScriptIndices.swap(m_likelyDocumentWriteScriptIndices);
     m_startingScript = false;
 
-    bool isEmpty = m_parsedChunkQueue->enqueue(std::move(chunk));
+    bool isEmpty = m_tokenizedChunkQueue->enqueue(std::move(chunk));
 
     DEFINE_STATIC_LOCAL(CustomCountHistogram, chunkEnqueueTime, ("Parser.ChunkEnqueueTime", 1, 10000, 50));
     chunkEnqueueTime.count(monotonicallyIncreasingTimeMS() - chunkStartTime);
 
     if (isEmpty) {
-        runOnMainThread(&HTMLDocumentParser::notifyPendingParsedChunks, m_parser);
+        runOnMainThread(&HTMLDocumentParser::notifyPendingTokenizedChunks, m_parser);
     }
 
     m_pendingTokens = wrapUnique(new CompactHTMLTokenStream);
 }
 
 // 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