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

content/child/web_data_consumer_handle_impl.cc

 // Copyright 2014 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 "content/child/web_data_consumer_handle_impl.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "components/scheduler/child/web_task_runner_impl.h"
 #include "mojo/public/c/system/types.h"
 
 namespace content {
 
 using Result = blink::WebDataConsumerHandle::Result;
 
 class WebDataConsumerHandleImpl::Context
     : public base::RefCountedThreadSafe<Context> {
  public:
   explicit Context(Handle handle) : handle_(std::move(handle)) {}
 
   const Handle& handle() { return handle_; }
 
  private:
   friend class base::RefCountedThreadSafe<Context>;
   ~Context() {}
   Handle handle_;
 
   DISALLOW_COPY_AND_ASSIGN(Context);
 };
 
 WebDataConsumerHandleImpl::ReaderImpl::ReaderImpl(
     scoped_refptr<Context> context,
-    Client* client)
-    : context_(context), client_(client) {
+    Client* client,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : context_(context),
+      handle_watcher_(std::move(task_runner)),
+      client_(client) {
   if (client_)
     StartWatching();
 }
 
 WebDataConsumerHandleImpl::ReaderImpl::~ReaderImpl() {
 }
 
 Result WebDataConsumerHandleImpl::ReaderImpl::read(void* data,
                                                    size_t size,
                                                    Flags flags,
@@ skipping 69 matching lines @@
   client_->didGetReadable();
 }
 
 WebDataConsumerHandleImpl::WebDataConsumerHandleImpl(Handle handle)
     : context_(new Context(std::move(handle))) {}
 
 WebDataConsumerHandleImpl::~WebDataConsumerHandleImpl() {
 }
 
 std::unique_ptr<blink::WebDataConsumerHandle::Reader>
-WebDataConsumerHandleImpl::obtainReader(Client* client) {
-  return base::WrapUnique(new ReaderImpl(context_, client));
+WebDataConsumerHandleImpl::obtainReader(
+    Client* client,
+    std::unique_ptr<blink::WebTaskRunner> reader_task_runner) {
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner;
+  if (reader_task_runner) {
+    task_runner =
+        scheduler::WebTaskRunnerImpl::GetBaseTaskRunner(*reader_task_runner);
+  } else {
+    task_runner = base::ThreadTaskRunnerHandle::Get();
+  }
+
+  return base::WrapUnique(new ReaderImpl(context_, client,
+                                         std::move(task_runner)));
 }
 
 const char* WebDataConsumerHandleImpl::debugName() const {
   return "WebDataConsumerHandleImpl";
 }
 
 }  // namespace content