Redirect HTML resource bytes directly to parser thread (Blink side CL)

Source/core/html/parser/HTMLDocumentParser.h

 /*
  * 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 31 matching lines @@
 #include "core/html/parser/HTMLTreeBuilderSimulator.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "core/html/parser/XSSAuditor.h"
 #include "core/html/parser/XSSAuditorDelegate.h"
 #include "platform/text/SegmentedString.h"
 #include "wtf/Deque.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/WeakPtr.h"
 #include "wtf/text/TextPosition.h"
 
+namespace blink {
+class WebThreadedResourceProvider;
+class WebThread;
+}
+
 namespace WebCore {
 
 class BackgroundHTMLParser;
 class CompactHTMLToken;
 class Document;
 class DocumentFragment;
 class HTMLDocument;
 class HTMLParserScheduler;
 class HTMLScriptRunner;
 class HTMLTreeBuilder;
@@ skipping 29 matching lines @@
         OwnPtr<CompactHTMLTokenStream> tokens;
         PreloadRequestStream preloads;
         XSSInfoStream xssInfos;
         HTMLTokenizer::State tokenizerState;
         HTMLTreeBuilderSimulator::State treeBuilderState;
         HTMLInputCheckpoint inputCheckpoint;
         TokenPreloadScannerCheckpoint preloadScannerCheckpoint;
     };
     void didReceiveParsedChunkFromBackgroundParser(PassOwnPtr<ParsedChunk>);
     void didReceiveEncodingDataFromBackgroundParser(const DocumentEncodingData&);
+    static void destroyResourceProvider(PassOwnPtr<blink::WebThreadedResourceProvider>);
 
     virtual void appendBytes(const char* bytes, size_t length) OVERRIDE;
     virtual void flush() OVERRIDE FINAL;
     virtual void setDecoder(PassOwnPtr<TextResourceDecoder>) OVERRIDE FINAL;
 
+    void didSwitchedToBackgroundClient();
+
     UseCounter* useCounter() { return UseCounter::getFrom(contextForParsingSession()); }
 
 protected:
     virtual void insert(const SegmentedString&) OVERRIDE FINAL;
     virtual void append(PassRefPtr<StringImpl>) OVERRIDE;
     virtual void finish() OVERRIDE FINAL;
 
     HTMLDocumentParser(HTMLDocument*, bool reportErrors);
     HTMLDocumentParser(DocumentFragment*, Element* contextElement, ParserContentPolicy);
 
@@ skipping 83 matching lines @@
     // so they can be set and cleared together and passed between threads together.
     OwnPtr<ParsedChunk> m_lastChunkBeforeScript;
     Deque<OwnPtr<ParsedChunk> > m_speculations;
     WeakPtrFactory<HTMLDocumentParser> m_weakFactory;
     WeakPtr<BackgroundHTMLParser> m_backgroundParser;
     OwnPtr<HTMLResourcePreloader> m_preloader;
 
     bool m_isPinnedToMainThread;
     bool m_endWasDelayed;
     bool m_haveBackgroundParser;
+    static blink::WebThread* s_parserThread;

[abarth-chromium, 2014/02/03 21:17:36]

Why did you move this static out of its dedicated class?

[oystein (OOO til 10th of July), 2014/02/05 00:05:00]

The parser thread itself now has to be managed by Chrome and not Blink (to be
able to schedule Chrome jobs on the thread, like installing the resource filter
etc), so keeping it in a singleton on the Blink side doesn't make sense anymore.
The static in HTMLDocumentParser is now essentially just a cached pointer. The
use of the thread itself is also an implementation detail of HTMLDocumentParser
and shouldn't be visible outside of it IMO.

I've moved the explicit shutdown eseidel added to the Chrome side in the
companion CL to this.

     unsigned m_pumpSessionNestingLevel;
+    bool m_parserThreadIsStandalone;
 };
 
 }
 
 #endif