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

third_party/WebKit/public/platform/WebDataConsumerHandle.h

 // 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.
 
 #ifndef WebDataConsumerHandle_h
 #define WebDataConsumerHandle_h
 
 #include <stddef.h>
 #include <memory>
 
 #include "public/platform/WebCommon.h"
 
 namespace blink {
 
+class WebTaskRunner;
+
 // WebDataConsumerHandle represents the "consumer" side of a data pipe. A user
 // can read data from it.
 //
 // A WebDataConsumerHandle is a thread-safe object. A user can call
 // |obtainReader| or destruct the object on any thread.
 // A WebDataConsumerHandle having a reader is called "locked". A
 // WebDataConsumerHandle or its reader are called "waiting" when reading from
 // the handle or reader returns ShouldWait.
 //
 // WebDataConsumerHandle can be created / used / destructed only on
@@ skipping 20 matching lines @@
         // The associated handle gets readable. This function will be called
         // when the associated reader was waiting but is not waiting any more.
         // This means this function can be called when handle gets errored or
         // closed. This also means that this function will not be called even
         // when some data arrives if the handle already has non-empty readable
         // data.
         // It is not guaranteed that the handle is not waiting when this
         // function is called, i.e. it can be called more than needed.
         // One can use / destruct the associated reader in this function.
         virtual void didGetReadable() = 0;
+
+        virtual WebTaskRunner* getTaskRunner() = 0;

[yhirano, 2016/07/28 16:25:05]

Please write comments. What is this? Is it allowed to return null?

     };
 
     // This class provides a means to read data from the associated handle. A
     // Reader object is bound to the thread on which |obtainReader| is called.
     // Any functions including the destructor should be called on the thread.
     // A reader can outlive the associated handle. In such a case, the handle
     // destruction will not affect the reader functionality.
     // Reading functions may success (i.e. return Ok) or fail (otherwise), and
     // the behavior which is not specified is unspecified.
     class BLINK_PLATFORM_EXPORT Reader {
@@ skipping 37 matching lines @@
     // notification is called asynchronously.
     virtual std::unique_ptr<Reader> obtainReader(Client*) = 0;
 
     // Returns a string literal (e.g. class name) for debugging only.
     virtual const char* debugName() const = 0;
 };
 
 } // namespace blink
 
 #endif // WebDataConsumerHandle_h