Cancel loading when body stream reader is detached.

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 67 matching lines @@
   int encoded_length() const override { return static_cast<int>(data_.size()); }
 
  private:
   const std::string name_;
   const std::vector<char> data_;
   scoped_refptr<Logger> logger_;
 
   DISALLOW_COPY_AND_ASSIGN(LoggingFixedReceivedData);
 };
 
+class DestructionTrackingFunction
+    : public base::RefCountedThreadSafe<DestructionTrackingFunction> {
+ public:
+  MOCK_METHOD0(Destruct, void(void));
+  MOCK_METHOD0(Call, void(void));
+
+ protected:
+  friend class base::RefCountedThreadSafe<DestructionTrackingFunction>;
+  virtual ~DestructionTrackingFunction() { Destruct(); }
+};
+
 class MockClient : public WebDataConsumerHandle::Client {
  public:
   MOCK_METHOD0(didGetReadable, void());
 };
 
 std::string ToString(const void* p, size_t size) {
   const char* q = static_cast<const char*>(p);
   return std::string(q, q + size);
 }
 
@@ skipping 477 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, CallOnClearWhenDestructed1) {
+  // Call |on_clear| when the handle is gone and if there is no reader.
+  Checkpoint checkpoint;
+  scoped_refptr<DestructionTrackingFunction> on_clear(
+      new StrictMock<DestructionTrackingFunction>);
+
+  InSequence s;
+  EXPECT_CALL(checkpoint, Call(0));
+  EXPECT_CALL(checkpoint, Call(1));
+  EXPECT_CALL(*on_clear, Call());
+  EXPECT_CALL(*on_clear, Destruct());
+  EXPECT_CALL(checkpoint, Call(2));
+
+  checkpoint.Call(0);
+  handle_.reset(new SharedMemoryDataConsumerHandle(
+      kApplyBackpressure,
+      base::Bind(&DestructionTrackingFunction::Call, on_clear), &writer_));
+  handle_.reset();
+  on_clear = nullptr;
+  checkpoint.Call(1);
+  RunPostedTasks();
+  checkpoint.Call(2);
+}
+
+TEST_P(SharedMemoryDataConsumerHandleTest, CallOnClearWhenDestructed2) {
+  // Call |on_clear| when the reader is gone if the handle is alredy gone.
+  Checkpoint checkpoint;
+  scoped_refptr<DestructionTrackingFunction> on_clear(
+      new StrictMock<DestructionTrackingFunction>);
+
+  InSequence s;
+  EXPECT_CALL(checkpoint, Call(0));
+  EXPECT_CALL(checkpoint, Call(1));
+  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);
+  handle_.reset();
+  on_clear = nullptr;
+  checkpoint.Call(1);
+  RunPostedTasks();
+  checkpoint.Call(2);
+  reader.reset();
+  checkpoint.Call(3);
+  RunPostedTasks();
+  checkpoint.Call(4);
+}
+
+TEST_P(SharedMemoryDataConsumerHandleTest, DoNotCallOnClearWhenDone) {
+  Checkpoint checkpoint;
+  scoped_refptr<DestructionTrackingFunction> on_clear(
+      new StrictMock<DestructionTrackingFunction>);
+
+  InSequence s;
+  EXPECT_CALL(checkpoint, Call(0));
+  EXPECT_CALL(checkpoint, Call(1));
+  EXPECT_CALL(*on_clear, Destruct());
+  EXPECT_CALL(checkpoint, Call(2));
+  EXPECT_CALL(checkpoint, Call(3));
+  EXPECT_CALL(checkpoint, Call(4));
+
+  checkpoint.Call(0);
+  handle_.reset(new SharedMemoryDataConsumerHandle(
+      kApplyBackpressure,
+      base::Bind(&DestructionTrackingFunction::Call, on_clear), &writer_));
+  on_clear = nullptr;
+  checkpoint.Call(1);
+  writer_->Close();
+  checkpoint.Call(2);
+  handle_.reset();
+  checkpoint.Call(3);
+  RunPostedTasks();
+  checkpoint.Call(4);
+}
+
+TEST_P(SharedMemoryDataConsumerHandleTest, DoNotCallOnClearWhenErrored) {
+  Checkpoint checkpoint;
+  scoped_refptr<DestructionTrackingFunction> on_clear(
+      new StrictMock<DestructionTrackingFunction>);
+
+  InSequence s;
+  EXPECT_CALL(checkpoint, Call(0));
+  EXPECT_CALL(checkpoint, Call(1));
+  EXPECT_CALL(*on_clear, Destruct());
+  EXPECT_CALL(checkpoint, Call(2));
+  EXPECT_CALL(checkpoint, Call(3));
+  EXPECT_CALL(checkpoint, Call(4));
+
+  checkpoint.Call(0);
+  handle_.reset(new SharedMemoryDataConsumerHandle(
+      kApplyBackpressure,
+      base::Bind(&DestructionTrackingFunction::Call, on_clear), &writer_));
+  on_clear = nullptr;
+  checkpoint.Call(1);
+  writer_->Fail();
+  checkpoint.Call(2);
+  handle_.reset();
+  checkpoint.Call(3);
+  RunPostedTasks();
+  checkpoint.Call(4);
+}
+
 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);
   result = reader->beginRead(&buffer, kNone, &size);
@@ skipping 301 matching lines @@
       logger->log());
 }
 
 INSTANTIATE_TEST_CASE_P(SharedMemoryDataConsumerHandleTest,
                         SharedMemoryDataConsumerHandleTest,
                         ::testing::Values(kApplyBackpressure,
                                           kDoNotApplyBackpressure));
 }  // namespace
 
 }  // namespace content