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

content/child/shared_memory_data_consumer_handle.cc

 // 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 "content/child/shared_memory_data_consumer_handle.h"
 
 #include <algorithm>
 #include <deque>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "components/scheduler/child/web_task_runner_impl.h"
 #include "content/public/child/fixed_received_data.h"
 
 namespace content {
 
 namespace {
 
 class DelegateThreadSafeReceivedData final
     : public RequestPeer::ThreadSafeReceivedData {
  public:
   explicit DelegateThreadSafeReceivedData(
@@ skipping 80 matching lines @@
     return first_offset_;
   }
   Result result() const {
     lock_.AssertAcquired();
     return result_;
   }
   void set_result(Result r) {
     lock_.AssertAcquired();
     result_ = r;
   }
-  void AcquireReaderLock(Client* client) {
+  void AcquireReaderLock(
+      Client* client,
+      scoped_refptr<base::SingleThreadTaskRunner> notification_task_runner) {
     lock_.AssertAcquired();
     DCHECK(!notification_task_runner_);
     DCHECK(!client_);
-    notification_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+    notification_task_runner_ = std::move(notification_task_runner);
     client_ = client;
     if (client && !(IsEmpty() && result() == Ok)) {
       // We cannot notify synchronously because the user doesn't have the reader
       // yet.
       notification_task_runner_->PostTask(
           FROM_HERE, base::Bind(&Context::NotifyInternal, this, false));
     }
   }
   void ReleaseReaderLock() {
     lock_.AssertAcquired();
@@ skipping 222 matching lines @@
 
     context_->ResetOnReaderDetached();
     // We cannot issue the notification synchronously because this function can
     // be called in the client's callback.
     context_->PostNotify();
   }
 }
 
 SharedMemoryDataConsumerHandle::ReaderImpl::ReaderImpl(
     scoped_refptr<Context> context,
-    Client* client)
+    Client* client,
+    scoped_refptr<base::SingleThreadTaskRunner> reader_task_runner)
     : context_(context) {
   base::AutoLock lock(context_->lock());
   DCHECK(!context_->is_handle_locked());
-  context_->AcquireReaderLock(client);
+  context_->AcquireReaderLock(client, std::move(reader_task_runner));
 }
 
 SharedMemoryDataConsumerHandle::ReaderImpl::~ReaderImpl() {
   base::AutoLock lock(context_->lock());
   context_->ReleaseReaderLock();
   context_->ClearIfNecessary();
 }
 
 Result SharedMemoryDataConsumerHandle::ReaderImpl::read(
     void* data,
@@ skipping 86 matching lines @@
   writer->reset(new Writer(context_, mode));
 }
 
 SharedMemoryDataConsumerHandle::~SharedMemoryDataConsumerHandle() {
   base::AutoLock lock(context_->lock());
   context_->set_is_handle_active(false);
   context_->ClearIfNecessary();
 }
 
 std::unique_ptr<blink::WebDataConsumerHandle::Reader>
-SharedMemoryDataConsumerHandle::obtainReader(Client* client) {
-  return base::WrapUnique(new ReaderImpl(context_, client));
+SharedMemoryDataConsumerHandle::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* SharedMemoryDataConsumerHandle::debugName() const {
   return "SharedMemoryDataConsumerHandle";
 }
 
 }  // namespace content