Make WebTaskRunner ThreadSafeRefCounted

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

 /*
  * 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 53 matching lines @@
     // pendingTokenLimit
     size_t outstandingTokenLimit;
     size_t pendingTokenLimit;
     bool shouldCoalesceChunks;
   };
 
   // The returned BackgroundHTMLParser should only be used on the parser
   // thread: it must first be initialized by calling init(), and free by
   // calling stop().
   static WeakPtr<BackgroundHTMLParser> create(std::unique_ptr<Configuration>,
-                                              std::unique_ptr<WebTaskRunner>);
+                                              RefPtr<WebTaskRunner>);
   void init(const KURL& documentURL,
             std::unique_ptr<CachedDocumentParameters>,
             const MediaValuesCached::MediaValuesCachedData&);
 
   struct Checkpoint {
     USING_FAST_MALLOC(Checkpoint);
 
    public:
     WeakPtr<HTMLDocumentParser> parser;
     std::unique_ptr<HTMLToken> token;
     std::unique_ptr<HTMLTokenizer> tokenizer;
     HTMLTreeBuilderSimulator::State treeBuilderState;
     HTMLInputCheckpoint inputCheckpoint;
     TokenPreloadScannerCheckpoint preloadScannerCheckpoint;
     String unparsedInput;
   };
 
   void appendRawBytesFromMainThread(std::unique_ptr<Vector<char>>,
                                     double bytesReceivedTime);
   void setDecoder(std::unique_ptr<TextResourceDecoder>);
   void flush();
   void resumeFrom(std::unique_ptr<Checkpoint>);
   void startedChunkWithCheckpoint(HTMLInputCheckpoint);
   void finish();
   void stop();
 
   void forcePlaintextForTextDocument();
 
  private:
-  BackgroundHTMLParser(std::unique_ptr<Configuration>,
-                       std::unique_ptr<WebTaskRunner>);
+  BackgroundHTMLParser(std::unique_ptr<Configuration>, RefPtr<WebTaskRunner>);
   ~BackgroundHTMLParser();
 
   void appendDecodedBytes(const String&);
   void markEndOfFile();
   void pumpTokenizer();
 
   // Returns whether or not the HTMLDocumentParser should be notified of
   // pending chunks.
   bool queueChunkForMainThread();
   void notifyMainThreadOfNewChunks();
@@ skipping 17 matching lines @@
   PreloadRequestStream m_pendingPreloads;
   // Indices into |m_pendingTokens|.
   Vector<int> m_likelyDocumentWriteScriptIndices;
   ViewportDescriptionWrapper m_viewportDescription;
   XSSInfoStream m_pendingXSSInfos;
 
   std::unique_ptr<XSSAuditor> m_xssAuditor;
   std::unique_ptr<TokenPreloadScanner> m_preloadScanner;
   std::unique_ptr<TextResourceDecoder> m_decoder;
   DocumentEncodingData m_lastSeenEncodingData;
-  std::unique_ptr<WebTaskRunner> m_loadingTaskRunner;
+  RefPtr<WebTaskRunner> m_loadingTaskRunner;
   RefPtr<TokenizedChunkQueue> m_tokenizedChunkQueue;
 
   // Index into |m_pendingTokens| of the last <meta> csp token found. Will be
   // |TokenizedChunk::noPendingToken| if none have been found.
   int m_pendingCSPMetaTokenIndex;
 
   bool m_startingScript;
   double m_lastBytesReceivedTime;
   bool m_shouldCoalesceChunks;
 };
 
 }  // namespace blink
 
 #endif