Use per-frame TaskRunner instead of thread's default in DataConsumerHandle

third_party/WebKit/Source/modules/fetch/FetchDataLoader.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/fetch/FetchDataLoader.h"
 
 #include "core/html/parser/TextResourceDecoder.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
@@ skipping 14 matching lines @@
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         FetchDataLoader::trace(visitor);
         visitor->trace(m_client);
     }
 
 private:
     void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
     {
-        ASSERT(!m_client);
-        ASSERT(!m_reader);
+        DCHECK(client);
+        DCHECK(!m_client);
+        DCHECK(!m_reader);
 
         m_client = client;
         // Passing |this| here is safe because |this| owns |m_reader|.
         m_reader = handle->obtainFetchDataReader(this);
         RefPtr<BlobDataHandle> blobHandle = m_reader->drainAsBlobDataHandle();
         if (blobHandle) {
-            ASSERT(blobHandle->size() != UINT64_MAX);
+            DCHECK(blobHandle->size() != UINT64_MAX);
             m_reader.reset();
             if (blobHandle->type() != m_mimeType) {
                 // A new BlobDataHandle is created to override the Blob's type.
                 m_client->didFetchDataLoadedBlobHandle(BlobDataHandle::create(blobHandle->uuid(), m_mimeType, blobHandle->size()));
             } else {
                 m_client->didFetchDataLoadedBlobHandle(blobHandle);
             }
             m_client.clear();
             return;
         }
 
         // We read data from |m_reader| and create a new blob.
         m_blobData = BlobData::create();
         m_blobData->setContentType(m_mimeType);
     }
 
     void didGetReadable() override
     {
-        ASSERT(m_client);
-        ASSERT(m_reader);
+        DCHECK(m_client);
+        DCHECK(m_reader);
 
         while (true) {
             const void* buffer;
             size_t available;
             WebDataConsumerHandle::Result result = m_reader->beginRead(&buffer, WebDataConsumerHandle::FlagNone, &available);
 
             switch (result) {
             case WebDataConsumerHandle::Ok:
                 m_blobData->appendBytes(buffer, available);
                 m_reader->endRead(available);
@@ skipping 15 matching lines @@
             case WebDataConsumerHandle::UnexpectedError:
                 m_reader.reset();
                 m_blobData.reset();
                 m_client->didFetchDataLoadFailed();
                 m_client.clear();
                 return;
             }
         }
     }
 
+    WebTaskRunner* getTaskRunner() override
+    {
+        return m_client->getTaskRunner();
+    }
+
     void cancel() override
     {
         m_reader.reset();
         m_blobData.reset();
         m_client.clear();
     }
 
     std::unique_ptr<FetchDataConsumerHandle::Reader> m_reader;
     Member<FetchDataLoader::Client> m_client;
 
@@ skipping 10 matching lines @@
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         FetchDataLoader::trace(visitor);
         visitor->trace(m_client);
     }
 
 protected:
     void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
     {
-        ASSERT(!m_client);
-        ASSERT(!m_rawData);
-        ASSERT(!m_reader);
+        DCHECK(!m_client);
+        DCHECK(!m_rawData);
+        DCHECK(!m_reader);
         m_client = client;
         m_rawData = wrapUnique(new ArrayBufferBuilder());
         m_reader = handle->obtainFetchDataReader(this);
     }
 
     void didGetReadable() override
     {
-        ASSERT(m_client);
-        ASSERT(m_rawData);
-        ASSERT(m_reader);
+        DCHECK(m_client);
+        DCHECK(m_rawData);
+        DCHECK(m_reader);
 
         while (true) {
             const void* buffer;
             size_t available;
             WebDataConsumerHandle::Result result = m_reader->beginRead(&buffer, WebDataConsumerHandle::FlagNone, &available);
 
             switch (result) {
             case WebDataConsumerHandle::Ok:
                 if (available > 0) {
                     unsigned bytesAppended = m_rawData->append(static_cast<const char*>(buffer), available);
                     if (!bytesAppended) {
                         m_reader->endRead(0);
                         error();
                         return;
                     }
-                    ASSERT(bytesAppended == available);
+                    DCHECK(bytesAppended == available);
                 }
                 m_reader->endRead(available);
                 break;
 
             case WebDataConsumerHandle::Done:
                 m_reader.reset();
                 m_client->didFetchDataLoadedArrayBuffer(DOMArrayBuffer::create(m_rawData->toArrayBuffer()));
                 m_rawData.reset();
                 m_client.clear();
                 return;
 
             case WebDataConsumerHandle::ShouldWait:
                 return;
 
             case WebDataConsumerHandle::Busy:
             case WebDataConsumerHandle::ResourceExhausted:
             case WebDataConsumerHandle::UnexpectedError:
                 error();
                 return;
             }
         }
     }
 
+    WebTaskRunner* getTaskRunner() override
+    {
+        return m_client->getTaskRunner();
+    }
+
     void error()
     {
         m_reader.reset();
         m_rawData.reset();
         m_client->didFetchDataLoadFailed();
         m_client.clear();
     }
 
     void cancel() override
     {
@@ skipping 17 matching lines @@
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         FetchDataLoader::trace(visitor);
         visitor->trace(m_client);
     }
 
 protected:
     void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
     {
-        ASSERT(!m_client);
-        ASSERT(!m_decoder);
-        ASSERT(!m_reader);
+        DCHECK(client);
+        DCHECK(!m_client);
+        DCHECK(!m_decoder);
+        DCHECK(!m_reader);
         m_client = client;
         m_decoder = TextResourceDecoder::createAlwaysUseUTF8ForText();
         m_reader = handle->obtainFetchDataReader(this);
     }
 
     void didGetReadable() override
     {
-        ASSERT(m_client);
-        ASSERT(m_decoder);
-        ASSERT(m_reader);
+        DCHECK(m_client);
+        DCHECK(m_decoder);
+        DCHECK(m_reader);
 
         while (true) {
             const void* buffer;
             size_t available;
             WebDataConsumerHandle::Result result = m_reader->beginRead(&buffer, WebDataConsumerHandle::FlagNone, &available);
 
             switch (result) {
             case WebDataConsumerHandle::Ok:
                 if (available > 0)
                     m_builder.append(m_decoder->decode(static_cast<const char*>(buffer), available));
@@ skipping 14 matching lines @@
 
             case WebDataConsumerHandle::Busy:
             case WebDataConsumerHandle::ResourceExhausted:
             case WebDataConsumerHandle::UnexpectedError:
                 error();
                 return;
             }
         }
     }
 
+    WebTaskRunner* getTaskRunner() override
+    {
+        DCHECK(m_client);
+        return m_client->getTaskRunner();
+    }
+
     void error()
     {
         m_reader.reset();
         m_builder.clear();
         m_decoder.reset();
         m_client->didFetchDataLoadFailed();
         m_client.clear();
     }
 
     void cancel() override
@@ skipping 22 matching lines @@
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         FetchDataLoader::trace(visitor);
         visitor->trace(m_client);
         visitor->trace(m_outStream);
     }
 
 protected:
     void start(FetchDataConsumerHandle* handle, FetchDataLoader::Client* client) override
     {
-        ASSERT(!m_client);
-        ASSERT(!m_reader);
+        DCHECK(!m_client);
+        DCHECK(!m_reader);
         m_client = client;
         m_reader = handle->obtainFetchDataReader(this);
     }
 
     void didGetReadable() override
     {
-        ASSERT(m_client);
-        ASSERT(m_reader);
+        DCHECK(m_client);
+        DCHECK(m_reader);
 
         bool needToFlush = false;
         while (true) {
             const void* buffer;
             size_t available;
             WebDataConsumerHandle::Result result = m_reader->beginRead(&buffer, WebDataConsumerHandle::FlagNone, &available);
 
             switch (result) {
             case WebDataConsumerHandle::Ok:
                 m_outStream->addData(static_cast<const char*>(buffer), available);
@@ skipping 25 matching lines @@
                 // process.
                 m_reader.reset();
                 m_outStream->abort();
                 m_client->didFetchDataLoadFailed();
                 cleanup();
                 return;
             }
         }
     }
 
+    WebTaskRunner* getTaskRunner() override
+    {
+        return m_client->getTaskRunner();
+    }
+
     void cancel() override
     {
         cleanup();
     }
 
     void cleanup()
     {
         m_reader.reset();
         m_client.clear();
         m_outStream.clear();
@@ skipping 22 matching lines @@
 {
     return new FetchDataLoaderAsString();
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsStream(Stream* outStream)
 {
     return new FetchDataLoaderAsStream(outStream);
 }
 
 } // namespace blink