[Stream] Notify ReadObserver of Stream abortion

content/browser/streams/stream_unittest.cc

 // Copyright (c) 2013 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 <stddef.h>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "content/browser/streams/stream.h"
@@ skipping 25 matching lines @@
  protected:
   base::MessageLoop message_loop_;
   std::unique_ptr<StreamRegistry> registry_;
 
  private:
   int producing_seed_key_;
 };
 
 class TestStreamReader : public StreamReadObserver {
  public:
-  TestStreamReader() : buffer_(new net::GrowableIOBuffer()), completed_(false) {
-  }
+  TestStreamReader() : buffer_(new net::GrowableIOBuffer()) {}
   ~TestStreamReader() override {}
 
   void Read(Stream* stream) {
     const size_t kBufferSize = 32768;
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
     int bytes_read = 0;
     while (true) {
       Stream::StreamState state =
           stream->ReadRawData(buffer.get(), kBufferSize, &bytes_read);
       switch (state) {
         case Stream::STREAM_HAS_DATA:
           // TODO(tyoshino): Move these expectations to the beginning of Read()
           // method once Stream::Finalize() is fixed.
           EXPECT_FALSE(completed_);
           break;
         case Stream::STREAM_COMPLETE:
           completed_ = true;
           return;
         case Stream::STREAM_EMPTY:
           EXPECT_FALSE(completed_);
           return;
         case Stream::STREAM_ABORTED:
+          aborted_ = true;
           EXPECT_FALSE(completed_);
           return;
       }
       size_t old_capacity = buffer_->capacity();
       buffer_->SetCapacity(old_capacity + bytes_read);
       memcpy(buffer_->StartOfBuffer() + old_capacity,
              buffer->data(), bytes_read);
     }
   }
 
   void OnDataAvailable(Stream* stream) override { Read(stream); }
 
   scoped_refptr<net::GrowableIOBuffer> buffer() { return buffer_; }
 
-  bool completed() const {
-    return completed_;
-  }
+  bool completed() const { return completed_; }
+  bool aborted() const { return aborted_; }
 
  private:
   scoped_refptr<net::GrowableIOBuffer> buffer_;
-  bool completed_;
+  bool completed_ = false;
+  bool aborted_ = false;
 };
 
 class TestStreamWriter : public StreamWriteObserver {
  public:
   TestStreamWriter() {}
   ~TestStreamWriter() override {}
 
   void Write(Stream* stream,
              scoped_refptr<net::IOBuffer> buffer,
              size_t buffer_size) {
@@ skipping 95 matching lines @@
   writer.Write(stream.get(), buffer, kBufferSize);
   stream->Finalize();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(reader.completed());
 
   ASSERT_EQ(reader.buffer()->capacity(), kBufferSize);
   for (int i = 0; i < kBufferSize; i++)
     EXPECT_EQ(buffer->data()[i], reader.buffer()->data()[i]);
 }
 
+TEST_F(StreamTest, Abort) {
+  TestStreamReader reader;
+  TestStreamWriter writer;
+
+  GURL url("blob://stream");
+  scoped_refptr<Stream> stream(new Stream(registry_.get(), &writer, url));
+  EXPECT_TRUE(stream->SetReadObserver(&reader));
+
+  stream->Abort();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(reader.completed());
+  EXPECT_TRUE(reader.aborted());
+}
+
 // Test that even if a reader receives an empty buffer, once TransferData()
 // method is called on it with |source_complete| = true, following Read() calls
 // on it never returns STREAM_EMPTY. Together with StreamTest.Stream above, this
 // guarantees that Reader::Read() call returns only STREAM_HAS_DATA
 // or STREAM_COMPLETE in |data_available_callback_| call corresponding to
 // Writer::Close().
 TEST_F(StreamTest, ClosedReaderDoesNotReturnStreamEmpty) {
   TestStreamReader reader;
   TestStreamWriter writer;
 
@@ skipping 159 matching lines @@
 TEST_F(StreamTest, AbortPendingStream) {
   TestStreamWriter writer;
 
   GURL url("blob://stream");
   registry_->AbortPendingStream(url);
   scoped_refptr<Stream> stream1(new Stream(registry_.get(), &writer, url));
   ASSERT_EQ(nullptr, registry_->GetStream(url).get());
 }
 
 }  // namespace content