Better handle reentrancy into DocumentLoader::dataReceived().

Source/core/loader/DocumentLoader.h

 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 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.
@@ skipping 27 matching lines @@
 #include "core/fetch/ResourcePtr.h"
 #include "core/fetch/SubstituteData.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/loader/DocumentLoadTiming.h"
 #include "core/loader/DocumentWriter.h"
 #include "core/loader/FrameLoaderTypes.h"
 #include "core/loader/NavigationPolicy.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
+#include "wtf/Deque.h"
 #include "wtf/HashSet.h"
+#include "wtf/OwnPtr.h"
 #include "wtf/RefPtr.h"
+#include "wtf/Vector.h"
 
 namespace blink {
 
 class ApplicationCacheHost;
 class ResourceFetcher;
 class DocumentInit;
 class LocalFrame;
 class FrameLoader;
 class MHTMLArchive;
 class ResourceLoader;
@@ skipping 109 matching lines @@
     void prepareSubframeArchiveLoadIfNeeded();
 
     void willSendRequest(ResourceRequest&, const ResourceResponse&);
     void finishedLoading(double finishTime);
     void mainReceivedError(const ResourceError&);
     void cancelLoadAfterXFrameOptionsOrCSPDenied(const ResourceResponse&);
     void redirectReceived(Resource*, ResourceRequest&, const ResourceResponse&) final;
     void updateRequest(Resource*, const ResourceRequest&) final;
     void responseReceived(Resource*, const ResourceResponse&, PassOwnPtr<WebDataConsumerHandle>) final;
     void dataReceived(Resource*, const char* data, unsigned length) final;
+    void processData(const char* data, unsigned length);
     void notifyFinished(Resource*) final;
 
     bool maybeLoadEmpty();
 
     bool isRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
 
     bool shouldContinueForResponse() const;
 
     RawPtrWillBeMember<LocalFrame> m_frame;
     PersistentWillBeMember<ResourceFetcher> m_fetcher;
@@ skipping 36 matching lines @@
     InitialScrollState m_initialScrollState;
 
     enum State {
         NotStarted,
         Provisional,
         Committed,
         DataReceived,
         MainResourceDone
     };
     State m_state;
+
+    // Used to protect against reentrancy into dataReceived().
+    bool m_inDataReceived;
+    Deque<OwnPtr<Vector<char>>> m_dataQueue;

[Nate Chapin, 2015/08/05 18:27:06]

I assume the OwnPtr here is actually necessary (or at least saves a copy)?

Can/should we use SharedBuffer here for readability?

[dcheng, 2015/08/05 21:57:12]

It's to save a copy. If we could use std::move() and Deque::append() had a
move-only equivalent like std::vector::emplace_back, we wouldn't need this.

One alternative is to do:
  m_dataQueue.append(Vector());
  m_dataQueue.last().swap(buffer);
which would also avoid the copy, and allow us to simplify the type to
Deque<Vector<char>>.

Using Dequeue<RefPtr<SharedBuffer>> doesn't really seem better: the refcounting
is unnecessary.

As a final option, if it's not important to preserve the exact chunking, I can
just dump everything into a Deque<char>. This means multiple calls to
dataReceived() might get batched, but maybe it doesn't matter?

 };
 
 DECLARE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 } // namespace blink
 
 #endif // DocumentLoader_h