Set error on WebDataConsumerHandle while loading body.

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 2c9e4ba605b60de9b1e179ab766cb3dc08cefae7..5dfb1f5c2f7f12af5cb93575757421fa06708943 100644
--- a/content/child/shared_memory_data_consumer_handle_unittest.cc
+++ b/content/child/shared_memory_data_consumer_handle_unittest.cc
@@ -35,6 +35,7 @@ const WebDataConsumerHandle::Flags kNone = WebDataConsumerHandle::FlagNone;
 const Result kOk = WebDataConsumerHandle::Ok;
 const Result kDone = WebDataConsumerHandle::Done;
 const Result kShouldWait = WebDataConsumerHandle::ShouldWait;
+const Result kUnexpectedError = WebDataConsumerHandle::UnexpectedError;
 
 using ::testing::_;
 using ::testing::InSequence;
@@ -620,6 +621,97 @@ TEST_P(SharedMemoryDataConsumerHandleTest, TwoPhaseReadWithMultipleData) {
   EXPECT_EQ(nullptr, buffer);
 }
 
+TEST_P(SharedMemoryDataConsumerHandleTest, ErrorRead) {
+  Checkpoint checkpoint;
+  Result result;
+  char buffer[20] = {};
+  size_t read = 99;
+  auto reader = handle_->obtainReader(nullptr);
+
+  writer_->Error();
+  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);
+
+  writer_->Error();
+  result = reader->beginRead(&pointer, kNone, &size);
+
+  EXPECT_EQ(kUnexpectedError, result);
+  EXPECT_EQ(nullptr, pointer);
+  EXPECT_EQ(0u, size);
+}
+
+TEST_P(SharedMemoryDataConsumerHandleTest, ErrorWhileTwoPhaseReadIsInProgress) {
+  Result result;
+  const void* pointer = nullptr;
+  size_t size = 0;
+  auto reader = handle_->obtainReader(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_->Error();
+
+  // We can access the buffer after calling |Error|. I hope ASAN will detect
+  // an error if the region is already freed.
+  EXPECT_EQ('O', buffer[0]);
+  EXPECT_EQ('n', buffer[1]);
+  EXPECT_EQ('c', buffer[2]);
+  EXPECT_EQ('e', buffer[3]);
+  EXPECT_EQ(' ', buffer[4]);
+
+  reader->endRead(size);

[hiroshige, 2015/06/18 07:01:21]

Should we add EXPECT_EQ(kUnexpectedError) for the return value?

[yhirano, 2015/06/18 08:13:33]

Currently it returns Ok and I'm fine with it. I don't have a strong opinion on
this return value.

[hiroshige, 2015/06/18 08:35:11]

OK; endRead() returns OK because we can read 'Once ' here, and next read() would
return UnexpectedError; reasonable.

optional: check that next beginRead() returns UnexpectedError.

[yhirano, 2015/06/18 08:40:55]

Done.

+}
+
+TEST_P(SharedMemoryDataConsumerHandleTest, ErrorWithClient) {
+  Checkpoint checkpoint;
+
+  InSequence s;
+  EXPECT_CALL(checkpoint, Call(0));
+  EXPECT_CALL(checkpoint, Call(1));
+  EXPECT_CALL(client_, didGetReadable());
+  EXPECT_CALL(checkpoint, Call(2));
+
+  checkpoint.Call(0);
+  auto reader = handle_->obtainReader(&client_);
+  checkpoint.Call(1);
+  writer_->Error();
+  checkpoint.Call(2);
+}
+
+TEST_P(SharedMemoryDataConsumerHandleTest, ErrorWithClientAndData) {
+  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(client_, didGetReadable());
+  EXPECT_CALL(checkpoint, Call(3));
+
+  checkpoint.Call(0);
+  auto reader = handle_->obtainReader(&client_);
+  checkpoint.Call(1);
+  writer_->AddData(NewFixedData("Once "));
+  checkpoint.Call(2);
+  writer_->Error();
+  checkpoint.Call(3);
+}
+
 TEST(SharedMemoryDataConsumerHandleBackpressureTest, Read) {
   base::MessageLoop loop;
   char buffer[20];