Make ByteStream independent from DownloadInterruptReason

content/browser/streams/stream.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 "content/browser/streams/stream.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/browser/streams/stream_handle_impl.h"
@@ skipping 14 matching lines @@
                const GURL& url)
     : data_bytes_read_(0),
       can_add_data_(true),
       url_(url),
       data_length_(0),
       registry_(registry),
       read_observer_(NULL),
       write_observer_(write_observer),
       stream_handle_(NULL),
       weak_ptr_factory_(this) {
-  CreateByteStream(base::MessageLoopProxy::current(),
-                   base::MessageLoopProxy::current(),
-                   kDeferSizeThreshold,
-                   &writer_,
-                   &reader_);
+  CreateByteStream<bool>(base::MessageLoopProxy::current(),
+                         base::MessageLoopProxy::current(),
+                         kDeferSizeThreshold,
+                         &writer_,
+                         &reader_);
 
   // Setup callback for writing.
   writer_->RegisterCallback(base::Bind(&Stream::OnSpaceAvailable,
                                        weak_ptr_factory_.GetWeakPtr()));
   reader_->RegisterCallback(base::Bind(&Stream::OnDataAvailable,
                                        weak_ptr_factory_.GetWeakPtr()));
 
   registry_->RegisterStream(this);
 }
 
@@ skipping 15 matching lines @@
 void Stream::RemoveWriteObserver(StreamWriteObserver* observer) {
   DCHECK(observer == write_observer_);
   write_observer_ = NULL;
 }
 
 void Stream::AddData(scoped_refptr<net::IOBuffer> buffer, size_t size) {
   can_add_data_ = writer_->Write(buffer, size);
 }
 
 void Stream::Finalize() {
-  writer_->Close(DOWNLOAD_INTERRUPT_REASON_NONE);
+  // We don't use the status passing feature of ByteStream.
+  writer_->Close(false /* status */);
   writer_.reset(NULL);
 
   // Continue asynchronously.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&Stream::OnDataAvailable, weak_ptr_factory_.GetWeakPtr()));
 }
 
 Stream::StreamState Stream::ReadRawData(net::IOBuffer* buf,
                                         int buf_size,
                                         int* bytes_read) {
   *bytes_read = 0;
   if (!data_.get()) {
     data_length_ = 0;
     data_bytes_read_ = 0;
-    ByteStreamReader::StreamState state = reader_->Read(&data_, &data_length_);
+    ByteStreamReader<bool>::StreamState state =
+        reader_->Read(&data_, &data_length_);
     switch (state) {
-      case ByteStreamReader::STREAM_HAS_DATA:
+      case ByteStreamReader<bool>::STREAM_HAS_DATA:
         break;
-      case ByteStreamReader::STREAM_COMPLETE:
+      case ByteStreamReader<bool>::STREAM_COMPLETE:
         registry_->UnregisterStream(url());
         return STREAM_COMPLETE;
-      case ByteStreamReader::STREAM_EMPTY:
+      case ByteStreamReader<bool>::STREAM_EMPTY:
         return STREAM_EMPTY;
     }
   }
 
   const size_t remaining_bytes = data_length_ - data_bytes_read_;
   size_t to_read =
       static_cast<size_t>(buf_size) < remaining_bytes ?
       buf_size : remaining_bytes;
   memcpy(buf->data(), data_->data() + data_bytes_read_, to_read);
   data_bytes_read_ += to_read;
@@ skipping 29 matching lines @@
   if (write_observer_)
     write_observer_->OnSpaceAvailable(this);
 }
 
 void Stream::OnDataAvailable() {
   if (read_observer_)
     read_observer_->OnDataAvailable(this);
 }
 
 }  // namespace content