Implement WebDataConsumerHandle::Reader.

content/child/shared_memory_data_consumer_handle_unittest.cc

Index: content/child/shared_memory_data_consumer_handle_unittest.cc
diff --git a/content/child/shared_memory_data_consumer_handle_unittest.cc b/content/child/shared_memory_data_consumer_handle_unittest.cc
index 8617aa529cf2b01d95ac9f2bec33cf043948bbf1..ff5305fa457c0a14ad9689ab9f9106ad3c8e1433 100644
--- a/content/child/shared_memory_data_consumer_handle_unittest.cc
+++ b/content/child/shared_memory_data_consumer_handle_unittest.cc
@@ -107,7 +107,7 @@ class ThreadedSharedMemoryDataConsumerHandleTest : public ::testing::Test {
   class ReadDataOperation final {
    public:
     typedef WebDataConsumerHandle::Result Result;
-    ReadDataOperation(scoped_ptr<WebDataConsumerHandle> handle,
+    ReadDataOperation(scoped_ptr<SharedMemoryDataConsumerHandle> handle,
                       base::MessageLoop* main_message_loop,
                       const base::Closure& on_done)
         : handle_(handle.Pass()),
@@ -119,7 +119,7 @@ class ThreadedSharedMemoryDataConsumerHandleTest : public ::testing::Test {
     void ReadData() {
       if (!client_) {
         client_.reset(new ClientImpl(this));
-        handle_->registerClient(client_.get());
+        reader_ = handle_->obtainReaderImpl(client_.get());
       }
 
       Result rv = kOk;
@@ -127,7 +127,7 @@ class ThreadedSharedMemoryDataConsumerHandleTest : public ::testing::Test {
 
       while (true) {
         char buffer[16];
-        rv = handle_->read(&buffer, sizeof(buffer), kNone, &read_size);
+        rv = reader_->read(&buffer, sizeof(buffer), kNone, &read_size);
         if (rv != kOk)
           break;
         result_.insert(result_.size(), &buffer[0], read_size);
@@ -144,11 +144,13 @@ class ThreadedSharedMemoryDataConsumerHandleTest : public ::testing::Test {
       }
 
       // The operation is done.
+      reader_.reset();
       main_message_loop_->PostTask(FROM_HERE, on_done_);
     }
 
    private:
-    scoped_ptr<WebDataConsumerHandle> handle_;
+    scoped_ptr<SharedMemoryDataConsumerHandle> handle_;
+    scoped_ptr<WebDataConsumerHandle::Reader> reader_;
     scoped_ptr<WebDataConsumerHandle::Client> client_;
     base::MessageLoop* main_message_loop_;
     base::Closure on_done_;
@@ -161,7 +163,7 @@ class ThreadedSharedMemoryDataConsumerHandleTest : public ::testing::Test {
   }
 
   StrictMock<MockClient> client_;
-  scoped_ptr<WebDataConsumerHandle> handle_;
+  scoped_ptr<SharedMemoryDataConsumerHandle> handle_;
   scoped_ptr<Writer> writer_;
   base::MessageLoop loop_;
 };
@@ -185,7 +187,8 @@ class SharedMemoryDataConsumerHandleTest
 TEST_P(SharedMemoryDataConsumerHandleTest, ReadFromEmpty) {
   char buffer[4];
   size_t read = 88;
-  Result result = handle_->read(buffer, 4, kNone, &read);
+  auto reader = handle_->obtainReaderImpl(nullptr);
+  Result result = reader->read(buffer, 4, kNone, &read);
 
   EXPECT_EQ(kShouldWait, result);
   EXPECT_EQ(0u, read);
@@ -196,7 +199,8 @@ TEST_P(SharedMemoryDataConsumerHandleTest, AutoClose) {
   size_t read = 88;
 
   writer_.reset();
-  Result result = handle_->read(buffer, 4, kNone, &read);
+  auto reader = handle_->obtainReaderImpl(nullptr);
+  Result result = reader->read(buffer, 4, kNone, &read);
 
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, read);
@@ -207,24 +211,82 @@ TEST_P(SharedMemoryDataConsumerHandleTest, ReadSimple) {
 
   char buffer[4] = {};
   size_t read = 88;
-  Result result = handle_->read(buffer, 3, kNone, &read);
+  auto reader = handle_->obtainReaderImpl(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_->obtainReaderImpl(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, ReobtainReaderImpl) {
+  writer_->AddData(NewFixedData("hello"));
+
+  char buffer[4] = {};
+  size_t read = 88;
+  auto reader = handle_->obtainReaderImpl(nullptr);
+  Result result = reader->read(buffer, 3, kNone, &read);
 
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(3u, read);
   EXPECT_STREQ("hel", buffer);
 
-  result = handle_->read(buffer, 3, kNone, &read);
+  reader.reset();
+  reader = handle_->obtainReaderImpl(nullptr);
+
+  result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, read);
   EXPECT_STREQ("lol", buffer);
 
-  result = handle_->read(buffer, 3, kNone, &read);
+  result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kShouldWait, result);
   EXPECT_EQ(0u, read);
 
   writer_->Close();
 
-  result = handle_->read(buffer, 3, kNone, &read);
+  result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, read);
 }
@@ -235,13 +297,14 @@ TEST_P(SharedMemoryDataConsumerHandleTest, CloseBeforeReading) {
 
   char buffer[20] = {};
   size_t read = 88;
-  Result result = handle_->read(buffer, sizeof(buffer), kNone, &read);
+  auto reader = handle_->obtainReaderImpl(nullptr);
+  Result result = reader->read(buffer, sizeof(buffer), kNone, &read);
 
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(5u, read);
   EXPECT_STREQ("hello", buffer);
 
-  result = handle_->read(buffer, sizeof(buffer), kNone, &read);
+  result = reader->read(buffer, sizeof(buffer), kNone, &read);
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, read);
 }
@@ -260,37 +323,38 @@ TEST_P(SharedMemoryDataConsumerHandleTest, AddMultipleData) {
   size_t read;
   Result result;
 
+  auto reader = handle_->obtainReaderImpl(nullptr);
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
-  result = handle_->read(buffer, 6, kNone, &read);
+  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 = handle_->read(buffer, 2, kNone, &read);
+  result = reader->read(buffer, 2, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, read);
   EXPECT_STREQ("po", buffer);
 
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
-  result = handle_->read(buffer, 9, kNone, &read);
+  result = reader->read(buffer, 9, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(9u, read);
   EXPECT_STREQ("n a time ", buffer);
 
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
-  result = handle_->read(buffer, 3, kNone, &read);
+  result = reader->read(buffer, 3, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(3u, read);
   EXPECT_STREQ("the", buffer);
 
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
-  result = handle_->read(buffer, 20, kNone, &read);
+  result = reader->read(buffer, 20, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(9u, read);
   EXPECT_STREQ("re was a ", buffer);
 
-  result = handle_->read(buffer, sizeof(buffer), kNone, &read);
+  result = reader->read(buffer, sizeof(buffer), kNone, &read);
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, read);
 }
@@ -303,20 +367,21 @@ TEST_P(SharedMemoryDataConsumerHandleTest, AddMultipleDataInteractively) {
   size_t read;
   Result result;
 
+  auto reader = handle_->obtainReaderImpl(nullptr);
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
-  result = handle_->read(buffer, 6, kNone, &read);
+  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 = handle_->read(buffer, 2, kNone, &read);
+  result = reader->read(buffer, 2, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, read);
   EXPECT_STREQ("po", buffer);
 
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
-  result = handle_->read(buffer, 9, kNone, &read);
+  result = reader->read(buffer, 9, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(2u, read);
   EXPECT_STREQ("n ", buffer);
@@ -324,7 +389,7 @@ TEST_P(SharedMemoryDataConsumerHandleTest, AddMultipleDataInteractively) {
   writer_->AddData(NewFixedData("a "));
 
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
-  result = handle_->read(buffer, 1, kNone, &read);
+  result = reader->read(buffer, 1, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(1u, read);
   EXPECT_STREQ("a", buffer);
@@ -336,18 +401,18 @@ TEST_P(SharedMemoryDataConsumerHandleTest, AddMultipleDataInteractively) {
   writer_->Close();
 
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
-  result = handle_->read(buffer, 9, kNone, &read);
+  result = reader->read(buffer, 9, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(9u, read);
   EXPECT_STREQ(" time the", buffer);
 
   std::fill(&buffer[0], &buffer[arraysize(buffer)], 0);
-  result = handle_->read(buffer, 20, kNone, &read);
+  result = reader->read(buffer, 20, kNone, &read);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(9u, read);
   EXPECT_STREQ("re was a ", buffer);
 
-  result = handle_->read(buffer, sizeof(buffer), kNone, &read);
+  result = reader->read(buffer, sizeof(buffer), kNone, &read);
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, read);
 }
@@ -362,7 +427,7 @@ TEST_P(SharedMemoryDataConsumerHandleTest, RegisterClient) {
   EXPECT_CALL(checkpoint, Call(2));
 
   checkpoint.Call(0);
-  handle_->registerClient(&client_);
+  auto reader = handle_->obtainReaderImpl(&client_);
   checkpoint.Call(1);
   writer_->Close();
   checkpoint.Call(2);
@@ -374,13 +439,12 @@ TEST_P(SharedMemoryDataConsumerHandleTest, RegisterClientWhenDataExists) {
   InSequence s;
   EXPECT_CALL(checkpoint, Call(0));
   EXPECT_CALL(checkpoint, Call(1));
-  EXPECT_CALL(client_, didGetReadable());
   EXPECT_CALL(checkpoint, Call(2));

[hiroshige, 2015/06/12 10:12:09]

It would be better to test that didGetReadable() is called (or, add TODO).

[yhirano, 2015/06/15 10:23:22]

Done.

 
   checkpoint.Call(0);
   writer_->AddData(NewFixedData("Once "));
   checkpoint.Call(1);
-  handle_->registerClient(&client_);
+  auto reader = handle_->obtainReaderImpl(&client_);
   checkpoint.Call(2);
 }
 
@@ -401,13 +465,13 @@ TEST_P(SharedMemoryDataConsumerHandleTest, AddDataWhenClientIsRegistered) {
   EXPECT_CALL(checkpoint, Call(5));
 
   checkpoint.Call(0);
-  handle_->registerClient(&client_);
+  auto reader = handle_->obtainReaderImpl(&client_);
   checkpoint.Call(1);
   writer_->AddData(NewFixedData("Once "));
   checkpoint.Call(2);
   writer_->AddData(NewFixedData("upon "));
   checkpoint.Call(3);
-  result = handle_->read(buffer, sizeof(buffer), kNone, &size);
+  result = reader->read(buffer, sizeof(buffer), kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(10u, size);
   checkpoint.Call(4);
@@ -426,7 +490,7 @@ TEST_P(SharedMemoryDataConsumerHandleTest, CloseWithClientAndData) {
   EXPECT_CALL(checkpoint, Call(3));
 
   checkpoint.Call(0);
-  handle_->registerClient(&client_);
+  auto reader = handle_->obtainReaderImpl(&client_);
   checkpoint.Call(1);
   writer_->AddData(NewFixedData("Once "));
   checkpoint.Call(2);
@@ -434,7 +498,7 @@ TEST_P(SharedMemoryDataConsumerHandleTest, CloseWithClientAndData) {
   checkpoint.Call(3);
 }
 
-TEST_P(SharedMemoryDataConsumerHandleTest, UnregisterClient) {
+TEST_P(SharedMemoryDataConsumerHandleTest, ReleaseReader) {
   Checkpoint checkpoint;
 
   InSequence s;
@@ -443,9 +507,9 @@ TEST_P(SharedMemoryDataConsumerHandleTest, UnregisterClient) {
   EXPECT_CALL(checkpoint, Call(2));
 
   checkpoint.Call(0);
-  handle_->registerClient(&client_);
+  auto reader = handle_->obtainReaderImpl(&client_);
   checkpoint.Call(1);
-  handle_->unregisterClient();
+  reader.reset();
   writer_->AddData(NewFixedData("Once "));
   checkpoint.Call(2);
 }
@@ -455,7 +519,8 @@ TEST_P(SharedMemoryDataConsumerHandleTest, TwoPhaseReadShouldWait) {
   const void* buffer = &result;
   size_t size = 99;
 
-  result = handle_->beginRead(&buffer, kNone, &size);
+  auto reader = handle_->obtainReaderImpl(nullptr);
+  result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kShouldWait, result);
   EXPECT_EQ(nullptr, buffer);
   EXPECT_EQ(0u, size);
@@ -468,28 +533,29 @@ TEST_P(SharedMemoryDataConsumerHandleTest, TwoPhaseReadSimple) {
   const void* buffer = &result;
   size_t size = 99;
 
-  result = handle_->beginRead(&buffer, kNone, &size);
+  auto reader = handle_->obtainReaderImpl(nullptr);
+  result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(5u, size);
   EXPECT_EQ("Once ", ToString(buffer, 5));
 
-  handle_->endRead(1);
+  reader->endRead(1);
 
-  result = handle_->beginRead(&buffer, kNone, &size);
+  result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(4u, size);
   EXPECT_EQ("nce ", ToString(buffer, 4));
 
-  handle_->endRead(4);
+  reader->endRead(4);
 
-  result = handle_->beginRead(&buffer, kNone, &size);
+  result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kShouldWait, result);
   EXPECT_EQ(0u, size);
   EXPECT_EQ(nullptr, buffer);
 
   writer_->Close();
 
-  result = handle_->beginRead(&buffer, kNone, &size);
+  result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, size);
   EXPECT_EQ(nullptr, buffer);
@@ -503,35 +569,36 @@ TEST_P(SharedMemoryDataConsumerHandleTest, TwoPhaseReadWithMultipleData) {
   const void* buffer = &result;
   size_t size = 99;
 
-  result = handle_->beginRead(&buffer, kNone, &size);
+  auto reader = handle_->obtainReaderImpl(nullptr);
+  result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(5u, size);
   EXPECT_EQ("Once ", ToString(buffer, 5));
 
-  handle_->endRead(1);
+  reader->endRead(1);
 
-  result = handle_->beginRead(&buffer, kNone, &size);
+  result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(4u, size);
   EXPECT_EQ("nce ", ToString(buffer, 4));
 
-  handle_->endRead(4);
+  reader->endRead(4);
 
-  result = handle_->beginRead(&buffer, kNone, &size);
+  result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kOk, result);
   EXPECT_EQ(5u, size);
   EXPECT_EQ("upon ", ToString(buffer, 5));
 
-  handle_->endRead(5);
+  reader->endRead(5);
 
-  result = handle_->beginRead(&buffer, kNone, &size);
+  result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kShouldWait, result);
   EXPECT_EQ(0u, size);
   EXPECT_EQ(nullptr, buffer);
 
   writer_->Close();
 
-  result = handle_->beginRead(&buffer, kNone, &size);
+  result = reader->beginRead(&buffer, kNone, &size);
   EXPECT_EQ(kDone, result);
   EXPECT_EQ(0u, size);
   EXPECT_EQ(nullptr, buffer);