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 84 matching lines @@
     return result_;
   }
   void set_result(Result r) {
     lock_.AssertAcquired();
     result_ = r;
   }
   void AcquireReaderLock(Client* client) {
     lock_.AssertAcquired();
     DCHECK(!notification_task_runner_);
     DCHECK(!client_);
-    notification_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+
+    blink::WebTaskRunner* task_runner =
+        client ? client->getTaskRunner() : nullptr;
+    if (task_runner) {
+      notification_task_runner_ =
+          scheduler::WebTaskRunnerImpl::GetBaseTaskRunner(*task_runner);

[kinuko, 2016/07/28 15:41:31]

Per Sami's comment this would be a tentative solution but this code makes me
feel uneasy :(  There doesn't seem enough guarantee that this is going to be
always safe.

Does it make sense to instead use WebTaskRunner for notification_task_runner_
for now?  (For null-client case could we use
Platform::current()->currentThread()->getWebTaskRunner()?)

Or I think we need some comment at least to explicitly note that this should be
safe and will be gone soon.

(Or if we're landing the scheduler migration patch first we won't need this
hack, I assume)

+    } else {
+      notification_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+    }
     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 342 matching lines @@
 std::unique_ptr<blink::WebDataConsumerHandle::Reader>
 SharedMemoryDataConsumerHandle::obtainReader(Client* client) {
   return base::WrapUnique(new ReaderImpl(context_, client));
 }
 
 const char* SharedMemoryDataConsumerHandle::debugName() const {
   return "SharedMemoryDataConsumerHandle";
 }
 
 }  // namespace content