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 101 matching lines @@
                       const base::Closure& on_done)
         : handle_(std::move(handle)),
           main_message_loop_(main_message_loop),
           on_done_(on_done) {}
 
     const std::string& result() const { return result_; }
 
     void ReadData() {
       if (!client_) {
         client_.reset(new ClientImpl(this));
-        reader_ = handle_->obtainReader(client_.get());
+        reader_ = handle_->obtainReader(client_.get(), nullptr);
       }
 
       Result rv = kOk;
       size_t read_size = 0;
 
       while (true) {
         char buffer[16];
         rv = reader_->read(&buffer, sizeof(buffer), kNone, &read_size);
         if (rv != kOk)
           break;
@@ skipping 55 matching lines @@
 void RunPostedTasks() {
   base::RunLoop run_loop;
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 run_loop.QuitClosure());
   run_loop.Run();
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, ReadFromEmpty) {
   char buffer[4];
   size_t read = 88;
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   Result result = reader->read(buffer, 4, kNone, &read);
 
   EXPECT_EQ(kShouldWait, result);
   EXPECT_EQ(0u, read);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, AutoClose) {
   char buffer[4];
   size_t read = 88;
 
   writer_.reset();
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   Result result = reader->read(buffer, 4, kNone, &read);
 
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, read);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, ReadSimple) {
   writer_->AddData(NewFixedData("hello"));
 
   char buffer[4] = {};
   size_t read = 88;
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   Result result = reader->read(buffer, 3, kNone, &read);
 
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(3u, read);
   EXPECT_STREQ("hel", buffer);
 
   result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, read);
   EXPECT_STREQ("lol", buffer);
 
   result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kShouldWait, result);
   EXPECT_EQ(0u, read);
 
   writer_->Close();
 
   result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, read);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, ReadAfterHandleIsGone) {
   writer_->AddData(NewFixedData("hello"));
 
   char buffer[8] = {};
   size_t read = 88;
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
 
   handle_.reset();
 
   Result result = reader->read(buffer, sizeof(buffer), kNone, &read);
 
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(5u, read);
   EXPECT_STREQ("hello", buffer);
 
   result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kShouldWait, result);
   EXPECT_EQ(0u, read);
 
   writer_->Close();
 
   result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, read);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, ReObtainReader) {
   writer_->AddData(NewFixedData("hello"));
 
   char buffer[4] = {};
   size_t read = 88;
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   Result result = reader->read(buffer, 3, kNone, &read);
 
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(3u, read);
   EXPECT_STREQ("hel", buffer);
 
   reader.reset();
-  reader = handle_->obtainReader(nullptr);
+  reader = handle_->obtainReader(nullptr, nullptr);
 
   result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, read);
   EXPECT_STREQ("lol", buffer);
 
   result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kShouldWait, result);
   EXPECT_EQ(0u, read);
 
   writer_->Close();
 
   result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, read);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, CloseBeforeReading) {
   writer_->AddData(NewFixedData("hello"));
   writer_->Close();
 
   char buffer[20] = {};
   size_t read = 88;
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   Result result = reader->read(buffer, sizeof(buffer), kNone, &read);
 
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(5u, read);
   EXPECT_STREQ("hello", buffer);
 
   result = reader->read(buffer, sizeof(buffer), kNone, &read);
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, read);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, CloseWithDataBeforeZeroRead) {
   writer_->AddData(NewFixedData("hello"));
   writer_->Close();
 
   size_t read = 88;
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   Result result = reader->read(nullptr, 0, kNone, &read);
 
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(0u, read);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, CloseWithoutDataBeforeZeroRead) {
   writer_->Close();
 
   size_t read = 88;
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   Result result = reader->read(nullptr, 0, kNone, &read);
 
   EXPECT_EQ(kDone, result);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, AddMultipleData) {
   writer_->AddData(NewFixedData("Once "));
   writer_->AddData(NewFixedData("upon "));
   writer_->AddData(NewFixedData("a "));
   writer_->AddData(NewFixedData("time "));
   writer_->AddData(NewFixedData("there "));
   writer_->AddData(NewFixedData("was "));
   writer_->AddData(NewFixedData("a "));
   writer_->Close();
 
   char buffer[20];
   size_t read;
   Result result;
 
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
   result = reader->read(buffer, 6, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(6u, read);
   EXPECT_STREQ("Once u", buffer);
 
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
   result = reader->read(buffer, 2, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, read);
@@ skipping 23 matching lines @@
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, AddMultipleDataInteractively) {
   writer_->AddData(NewFixedData("Once "));
   writer_->AddData(NewFixedData("upon "));
 
   char buffer[20];
   size_t read;
   Result result;
 
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
   result = reader->read(buffer, 6, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(6u, read);
   EXPECT_STREQ("Once u", buffer);
 
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
   result = reader->read(buffer, 2, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, read);
@@ skipping 41 matching lines @@
 
   InSequence s;
   EXPECT_CALL(checkpoint, Call(0));
   EXPECT_CALL(checkpoint, Call(1));
   EXPECT_CALL(checkpoint, Call(2));
   EXPECT_CALL(checkpoint, Call(3));
   EXPECT_CALL(client_, didGetReadable());
   EXPECT_CALL(checkpoint, Call(4));
 
   checkpoint.Call(0);
-  auto reader = handle_->obtainReader(&client_);
+  auto reader = handle_->obtainReader(&client_, nullptr);
   checkpoint.Call(1);
   RunPostedTasks();
   checkpoint.Call(2);
   writer_->Close();
   checkpoint.Call(3);
   RunPostedTasks();
   checkpoint.Call(4);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, RegisterClientWhenDataExists) {
   Checkpoint checkpoint;
 
   InSequence s;
   EXPECT_CALL(checkpoint, Call(0));
   EXPECT_CALL(checkpoint, Call(1));
   EXPECT_CALL(checkpoint, Call(2));
   EXPECT_CALL(client_, didGetReadable());
   EXPECT_CALL(checkpoint, Call(3));
 
   checkpoint.Call(0);
   writer_->AddData(NewFixedData("Once "));
   checkpoint.Call(1);
-  auto reader = handle_->obtainReader(&client_);
+  auto reader = handle_->obtainReader(&client_, nullptr);
   checkpoint.Call(2);
   RunPostedTasks();
   checkpoint.Call(3);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, AddDataWhenClientIsRegistered) {
   Checkpoint checkpoint;
   char buffer[20];
   Result result;
   size_t size;
 
   InSequence s;
   EXPECT_CALL(checkpoint, Call(0));
   EXPECT_CALL(checkpoint, Call(1));
   EXPECT_CALL(client_, didGetReadable());
   EXPECT_CALL(checkpoint, Call(2));
   EXPECT_CALL(checkpoint, Call(3));
   EXPECT_CALL(checkpoint, Call(4));
   EXPECT_CALL(client_, didGetReadable());
   EXPECT_CALL(checkpoint, Call(5));
 
   checkpoint.Call(0);
-  auto reader = handle_->obtainReader(&client_);
+  auto reader = handle_->obtainReader(&client_, nullptr);
   checkpoint.Call(1);
   writer_->AddData(NewFixedData("Once "));
   checkpoint.Call(2);
   writer_->AddData(NewFixedData("upon "));
   checkpoint.Call(3);
   result = reader->read(buffer, sizeof(buffer), kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(10u, size);
   checkpoint.Call(4);
   writer_->AddData(NewFixedData("a "));
   checkpoint.Call(5);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, CloseWithClientAndData) {
   Checkpoint checkpoint;
 
   InSequence s;
   EXPECT_CALL(checkpoint, Call(0));
   EXPECT_CALL(checkpoint, Call(1));
   EXPECT_CALL(client_, didGetReadable());
   EXPECT_CALL(checkpoint, Call(2));
   EXPECT_CALL(checkpoint, Call(3));
 
   checkpoint.Call(0);
-  auto reader = handle_->obtainReader(&client_);
+  auto reader = handle_->obtainReader(&client_, nullptr);
   checkpoint.Call(1);
   writer_->AddData(NewFixedData("Once "));
   checkpoint.Call(2);
   writer_->Close();
   checkpoint.Call(3);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, ReleaseReader) {
   Checkpoint checkpoint;
 
   InSequence s;
   EXPECT_CALL(checkpoint, Call(0));
   EXPECT_CALL(checkpoint, Call(1));
   EXPECT_CALL(checkpoint, Call(2));
 
   checkpoint.Call(0);
-  auto reader = handle_->obtainReader(&client_);
+  auto reader = handle_->obtainReader(&client_, nullptr);
   checkpoint.Call(1);
   reader.reset();
   writer_->AddData(NewFixedData("Once "));
   checkpoint.Call(2);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, TwoPhaseReadShouldWait) {
   Result result;
   const void* buffer = &result;
   size_t size = 99;
 
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kShouldWait, result);
   EXPECT_EQ(nullptr, buffer);
   EXPECT_EQ(0u, size);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, TwoPhaseReadSimple) {
   writer_->AddData(NewFixedData("Once "));
 
   Result result;
   const void* buffer = &result;
   size_t size = 99;
 
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(5u, size);
   EXPECT_EQ("Once ", ToString(buffer, 5));
 
   reader->endRead(1);
 
   result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(4u, size);
@@ skipping 50 matching lines @@
   EXPECT_CALL(checkpoint, Call(2));
   EXPECT_CALL(checkpoint, Call(3));
   EXPECT_CALL(*on_clear, Call());
   EXPECT_CALL(*on_clear, Destruct());
   EXPECT_CALL(checkpoint, Call(4));
 
   checkpoint.Call(0);
   handle_.reset(new SharedMemoryDataConsumerHandle(
       kApplyBackpressure,
       base::Bind(&DestructionTrackingFunction::Call, on_clear), &writer_));
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   handle_.reset();
   on_clear = nullptr;
   checkpoint.Call(1);
   RunPostedTasks();
   checkpoint.Call(2);
   reader.reset();
   checkpoint.Call(3);
   RunPostedTasks();
   checkpoint.Call(4);
 }
@@ skipping 53 matching lines @@
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, TwoPhaseReadWithMultipleData) {
   writer_->AddData(NewFixedData("Once "));
   writer_->AddData(NewFixedData("upon "));
 
   Result result;
   const void* buffer = &result;
   size_t size = 99;
 
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
   result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(5u, size);
   EXPECT_EQ("Once ", ToString(buffer, 5));
 
   reader->endRead(1);
 
   result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(4u, size);
@@ skipping 19 matching lines @@
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, size);
   EXPECT_EQ(nullptr, buffer);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, ErrorRead) {
   Checkpoint checkpoint;
   Result result;
   char buffer[20] = {};
   size_t read = 99;
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
 
   writer_->Fail();
   result = reader->read(buffer, sizeof(buffer), kNone, &read);
 
   EXPECT_EQ(kUnexpectedError, result);
   EXPECT_EQ(0u, read);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, ErrorTwoPhaseRead) {
   Result result;
   const void* pointer = &result;
   size_t size = 99;
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
 
   writer_->Fail();
   result = reader->beginRead(&pointer, kNone, &size);
 
   EXPECT_EQ(kUnexpectedError, result);
   EXPECT_EQ(nullptr, pointer);
   EXPECT_EQ(0u, size);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, FailWhileTwoPhaseReadIsInProgress) {
   Result result;
   const void* pointer = nullptr;
   size_t size = 0;
-  auto reader = handle_->obtainReader(nullptr);
+  auto reader = handle_->obtainReader(nullptr, nullptr);
 
   writer_->AddData(NewFixedData("Once "));
   result = reader->beginRead(&pointer, kNone, &size);
   auto* buffer = static_cast<const char*>(pointer);
 
   ASSERT_EQ(kOk, result);
   ASSERT_NE(nullptr, pointer);
   ASSERT_EQ(size, 5u);
 
   writer_->Fail();
@@ skipping 15 matching lines @@
   Checkpoint checkpoint;
 
   InSequence s;
   EXPECT_CALL(checkpoint, Call(0));
   EXPECT_CALL(checkpoint, Call(1));
   EXPECT_CALL(checkpoint, Call(2));
   EXPECT_CALL(client_, didGetReadable());
   EXPECT_CALL(checkpoint, Call(3));
 
   checkpoint.Call(0);
-  auto reader = handle_->obtainReader(&client_);
+  auto reader = handle_->obtainReader(&client_, nullptr);
   checkpoint.Call(1);
   writer_->Fail();
   checkpoint.Call(2);
   RunPostedTasks();
   checkpoint.Call(3);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, FailWithClientAndData) {
   Checkpoint checkpoint;
 
   InSequence s;
   EXPECT_CALL(checkpoint, Call(0));
   EXPECT_CALL(checkpoint, Call(1));
   EXPECT_CALL(client_, didGetReadable());
   EXPECT_CALL(checkpoint, Call(2));
   EXPECT_CALL(checkpoint, Call(3));
   EXPECT_CALL(client_, didGetReadable());
   EXPECT_CALL(checkpoint, Call(4));
 
   checkpoint.Call(0);
-  auto reader = handle_->obtainReader(&client_);
+  auto reader = handle_->obtainReader(&client_, nullptr);
   checkpoint.Call(1);
   writer_->AddData(NewFixedData("Once "));
   checkpoint.Call(2);
   writer_->Fail();
   checkpoint.Call(3);
   RunPostedTasks();
   checkpoint.Call(4);
 }
 
 TEST_P(SharedMemoryDataConsumerHandleTest, RecursiveErrorNotification) {
   Checkpoint checkpoint;
 
   InSequence s;
   EXPECT_CALL(checkpoint, Call(0));
   EXPECT_CALL(checkpoint, Call(1));
   EXPECT_CALL(client_, didGetReadable())
       .WillOnce(Invoke(writer_.get(), &Writer::Fail));
   EXPECT_CALL(checkpoint, Call(2));
   EXPECT_CALL(client_, didGetReadable());
   EXPECT_CALL(checkpoint, Call(3));
 
   checkpoint.Call(0);
-  auto reader = handle_->obtainReader(&client_);
+  auto reader = handle_->obtainReader(&client_, nullptr);
   checkpoint.Call(1);
   writer_->AddData(NewFixedData("Once "));
   checkpoint.Call(2);
   RunPostedTasks();
   checkpoint.Call(3);
 }
 
 TEST(SharedMemoryDataConsumerHandleBackpressureTest, Read) {
   base::MessageLoop loop;
   char buffer[20];
   Result result;
   size_t size;
 
   std::unique_ptr<Writer> writer;
   auto handle = base::WrapUnique(
       new SharedMemoryDataConsumerHandle(kApplyBackpressure, &writer));
   scoped_refptr<Logger> logger(new Logger);
   writer->AddData(
       base::WrapUnique(new LoggingFixedReceivedData("data1", "Once ", logger)));
   writer->AddData(
       base::WrapUnique(new LoggingFixedReceivedData("data2", "upon ", logger)));
   writer->AddData(
       base::WrapUnique(new LoggingFixedReceivedData("data3", "a ", logger)));
   writer->AddData(
       base::WrapUnique(new LoggingFixedReceivedData("data4", "time ", logger)));
 
-  auto reader = handle->obtainReader(nullptr);
+  auto reader = handle->obtainReader(nullptr, nullptr);
   logger->Add("1");
   result = reader->read(buffer, 2, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, size);
   logger->Add("2");
   result = reader->read(buffer, 5, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(5u, size);
   logger->Add("3");
   result = reader->read(buffer, 6, kNone, &size);
@@ skipping 22 matching lines @@
   auto handle = base::WrapUnique(
       new SharedMemoryDataConsumerHandle(kApplyBackpressure, &writer));
   scoped_refptr<Logger> logger(new Logger);
   writer->AddData(
       base::WrapUnique(new LoggingFixedReceivedData("data1", "Once ", logger)));
   writer->AddData(
       base::WrapUnique(new LoggingFixedReceivedData("data2", "upon ", logger)));
   writer->AddData(
       base::WrapUnique(new LoggingFixedReceivedData("data3", "a ", logger)));
 
-  auto reader = handle->obtainReader(nullptr);
+  auto reader = handle->obtainReader(nullptr, nullptr);
   logger->Add("1");
   result = reader->read(buffer, 2, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, size);
   logger->Add("2");
   writer->Close();
   logger->Add("3");
   handle.reset();
   reader.reset();
   logger->Add("4");
@@ skipping 75 matching lines @@
       logger->log());
 }
 
 INSTANTIATE_TEST_CASE_P(SharedMemoryDataConsumerHandleTest,
                         SharedMemoryDataConsumerHandleTest,
                         ::testing::Values(kApplyBackpressure,
                                           kDoNotApplyBackpressure));
 }  // namespace
 
 }  // namespace content