Make WebDataConsumerHandleImpl return OK while zero-length reading of closed pipe.

content/child/web_data_consumer_handle_impl_unittest.cc

 // Copyright 2014 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/web_data_consumer_handle_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 175 matching lines @@
 
 class WebDataConsumerHandleImplTest : public ::testing::Test {
  public:
   typedef WebDataConsumerHandle::Result Result;
 
   void SetUp() override {
     MojoCreateDataPipeOptions options;
     options.struct_size = sizeof(MojoCreateDataPipeOptions);
     options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
     options.element_num_bytes = 1;
-    options.capacity_num_bytes = 4;
+    options.capacity_num_bytes = kDataPipeCapacity;
 
     MojoResult result = mojo::CreateDataPipe(&options, &producer_, &consumer_);
     ASSERT_EQ(MOJO_RESULT_OK, result);
   }
 
+ protected:
+  static int kDataPipeCapacity;

[yhirano, 2016/09/23 06:55:55]

+ constexpr

[horo, 2016/09/23 07:38:37]

Done.

   // This function can be blocked if the associated consumer doesn't consume
   // the data.
   std::string ProduceData(size_t total_size) {
     int index = 0;
     std::string expected;
     for (size_t i = 0; i < total_size; ++i) {
       expected += static_cast<char>(index + 'a');
       index = (37 * index + 11) % 26;
     }
 
@@ skipping 15 matching lines @@
     }
     return expected;
   }
 
   base::MessageLoop message_loop_;
 
   mojo::ScopedDataPipeProducerHandle producer_;
   mojo::ScopedDataPipeConsumerHandle consumer_;
 };
 
+int WebDataConsumerHandleImplTest::kDataPipeCapacity = 4;
+
 TEST_F(WebDataConsumerHandleImplTest, ReadData) {
   base::RunLoop run_loop;
   auto operation = base::MakeUnique<ReadDataOperation>(
       std::move(consumer_), &message_loop_, run_loop.QuitClosure());
 
   base::Thread t("DataConsumerHandle test thread");
   ASSERT_TRUE(t.Start());
 
   t.task_runner()->PostTask(FROM_HERE,
                             base::Bind(&ReadDataOperation::ReadData,
@@ skipping 22 matching lines @@
 
   std::string expected = ProduceData(24 * 1024);
   producer_.reset();
 
   run_loop.Run();
   t.Stop();
 
   EXPECT_EQ(expected, operation->result());
 }
 
+TEST_F(WebDataConsumerHandleImplTest, ZeroSizeRead) {
+  ASSERT_GT(kDataPipeCapacity - 1, 0);
+  const size_t data_size = kDataPipeCapacity - 1;

[yhirano, 2016/09/23 06:55:55]

constexpr

[horo, 2016/09/23 07:38:37]

Done.

+  std::string expected = ProduceData(data_size);
+  producer_.reset();
+  std::unique_ptr<WebDataConsumerHandleImpl> handle(
+      new WebDataConsumerHandleImpl(std::move(consumer_)));
+  std::unique_ptr<WebDataConsumerHandle::Reader> reader(
+      handle->obtainReader(nullptr));
+
+  size_t read_size;
+  WebDataConsumerHandle::Result rv =
+      reader->read(nullptr, 0, WebDataConsumerHandle::FlagNone, &read_size);
+  EXPECT_EQ(WebDataConsumerHandle::Result::Ok, rv);
+
+  char buffer[16];
+  rv = reader->read(&buffer, sizeof(buffer), WebDataConsumerHandle::FlagNone,
+                    &read_size);
+  EXPECT_EQ(WebDataConsumerHandle::Result::Ok, rv);
+  EXPECT_EQ(data_size, read_size);
+  EXPECT_EQ(expected, std::string(buffer, read_size));
+}
+
 }  // namespace
 
 }  // namespace content