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

content/child/shared_memory_data_consumer_handle_unittest.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 <stddef.h>
 #include <string.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/public/child/fixed_received_data.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebTaskRunner.h"
 
 namespace content {
 
 namespace {
 using blink::WebDataConsumerHandle;
 using Result = WebDataConsumerHandle::Result;
 using Writer = SharedMemoryDataConsumerHandle::Writer;
 using BackpressureMode = SharedMemoryDataConsumerHandle::BackpressureMode;
 const BackpressureMode kApplyBackpressure =
     SharedMemoryDataConsumerHandle::kApplyBackpressure;
@@ skipping 66 matching lines @@
   MOCK_METHOD0(Call, void(void));
 
  protected:
   friend class base::RefCountedThreadSafe<DestructionTrackingFunction>;
   virtual ~DestructionTrackingFunction() { Destruct(); }
 };
 
 class MockClient : public WebDataConsumerHandle::Client {
  public:
   MOCK_METHOD0(didGetReadable, void());
+  MOCK_METHOD0(getTaskRunner, blink::WebTaskRunner*());
 };
 
 std::string ToString(const void* p, size_t size) {
   const char* q = static_cast<const char*>(p);
   return std::string(q, q + size);
 }
 
 class ThreadedSharedMemoryDataConsumerHandleTest : public ::testing::Test {
  protected:
   class ReadDataOperation;
   class ClientImpl final : public WebDataConsumerHandle::Client {
    public:
     explicit ClientImpl(ReadDataOperation* operation) : operation_(operation) {}
 
     void didGetReadable() override { operation_->ReadData(); }
+    blink::WebTaskRunner* getTaskRunner() override {
+      return nullptr;
+    }
 
    private:
     ReadDataOperation* operation_;
   };
 
   class ReadDataOperation final {
    public:
     typedef WebDataConsumerHandle::Result Result;
     ReadDataOperation(std::unique_ptr<SharedMemoryDataConsumerHandle> handle,
                       base::MessageLoop* main_message_loop,
@@ skipping 41 matching lines @@
     std::unique_ptr<WebDataConsumerHandle::Reader> reader_;
     std::unique_ptr<WebDataConsumerHandle::Client> client_;
     base::MessageLoop* main_message_loop_;
     base::Closure on_done_;
     std::string result_;
   };
 
   void SetUp() override {
     handle_.reset(
         new SharedMemoryDataConsumerHandle(kApplyBackpressure, &writer_));
+    EXPECT_CALL(client_, getTaskRunner()).WillRepeatedly(Return(nullptr));
   }
 
   StrictMock<MockClient> client_;
   std::unique_ptr<SharedMemoryDataConsumerHandle> handle_;
   std::unique_ptr<Writer> writer_;
   base::MessageLoop loop_;
 };
 
 class SharedMemoryDataConsumerHandleTest
     : public ::testing::TestWithParam<BackpressureMode> {
  protected:
   void SetUp() override {
     handle_.reset(new SharedMemoryDataConsumerHandle(GetParam(), &writer_));
+    EXPECT_CALL(client_, getTaskRunner()).WillRepeatedly(Return(nullptr));
   }
   std::unique_ptr<FixedReceivedData> NewFixedData(const char* s) {
     auto size = strlen(s);
     return base::WrapUnique(new FixedReceivedData(s, size, size, size));
   }
 
   StrictMock<MockClient> client_;
   std::unique_ptr<SharedMemoryDataConsumerHandle> handle_;
   std::unique_ptr<Writer> writer_;
   base::MessageLoop loop_;
@@ skipping 838 matching lines @@
       logger->log());
 }
 
 INSTANTIATE_TEST_CASE_P(SharedMemoryDataConsumerHandleTest,
                         SharedMemoryDataConsumerHandleTest,
                         ::testing::Values(kApplyBackpressure,
                                           kDoNotApplyBackpressure));
 }  // namespace
 
 }  // namespace content