Set error on WebDataConsumerHandle while loading body.

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 <string.h>
 #include <string>
 #include <vector>
 
@@ skipping 17 matching lines @@
 using BackpressureMode = SharedMemoryDataConsumerHandle::BackpressureMode;
 const BackpressureMode kApplyBackpressure =
     SharedMemoryDataConsumerHandle::kApplyBackpressure;
 const BackpressureMode kDoNotApplyBackpressure =
     SharedMemoryDataConsumerHandle::kDoNotApplyBackpressure;
 
 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;
 using ::testing::MockFunction;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 using Checkpoint = StrictMock<MockFunction<void(int)>>;
 using ReceivedData = RequestPeer::ReceivedData;
 
@@ skipping 565 matching lines @@
   EXPECT_EQ(nullptr, buffer);
 
   writer_->Close();
 
   result = reader->beginRead(&buffer, kNone, &size);
   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);
+
+  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];
   Result result;
   size_t size;
 
   scoped_ptr<Writer> writer;
   auto handle = make_scoped_ptr(
       new SharedMemoryDataConsumerHandle(kApplyBackpressure, &writer));
   scoped_refptr<Logger> logger(new Logger);
@@ skipping 135 matching lines @@
       logger->log());
 }
 
 INSTANTIATE_TEST_CASE_P(SharedMemoryDataConsumerHandleTest,
                         SharedMemoryDataConsumerHandleTest,
                         ::testing::Values(kApplyBackpressure,
                                           kDoNotApplyBackpressure));
 }  // namespace
 
 }  // namespace content