Make ByteStream independent from DownloadInterruptReason

content/browser/byte_stream.h

 // Copyright (c) 2012 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.
 
 #ifndef CONTENT_BROWSER_BYTE_STREAM_H_
 #define CONTENT_BROWSER_BYTE_STREAM_H_
 
 #include <deque>
 #include <set>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
-#include "content/public/browser/download_interrupt_reasons.h"
+#include "content/common/content_export.h"
 #include "net/base/io_buffer.h"
 
 namespace base {
 class SequencedTaskRunner;
 }
 
 namespace content {
 
 // A byte stream is a pipe to transfer bytes between a source and a
 // sink, which may be on different threads.  It is intended to be the
 // only connection between source and sink; they need have no
 // direct awareness of each other aside from the byte stream.  The source and
 // the sink have different interfaces to a byte stream, |ByteStreamWriter|
 // and |ByteStreamReader|.  A pair of connected interfaces is generated by
 // calling |CreateByteStream|.
 //
 // The source adds bytes to the bytestream via |ByteStreamWriter::Write|
 // and the sink retrieves bytes already written via |ByteStreamReader::Read|.
 //
 // When the source has no more data to add, it will call
-// |ByteStreamWriter::Close| to indicate that.  Errors at the source
-// are indicated to the sink via a non-DOWNLOAD_INTERRUPT_REASON_NONE code.
+// |ByteStreamWriter::Close| to indicate that.  Operation status at the source
+// is indicated to the sink via an int passed to the Close() method and returned
+// from the GetStatus() method. Source and sink must agree on the interpretation
+// of this int.
 //
 // Normally the source is not managed after the relationship is setup;
 // it is expected to provide data and then close itself.  If an error
 // occurs on the sink, it is not signalled to the source via this
 // mechanism; instead, the source will write data until it exausts the
 // available space.  If the source needs to be aware of errors occuring
 // on the sink, this must be signalled in some other fashion (usually
 // through whatever controller setup the relationship).
 //
 // Callback lifetime management: No lifetime management is done in this
@@ skipping 58 matching lines @@
 //    void ReceivingClass::DataAvailable() {
 //      scoped_refptr<net::IOBuffer> data;
 //      size_t length = 0;
 //
 //      while (ByteStreamReader::STREAM_HAS_DATA ==
 //             (state = reader->Read(&data, &length))) {
 //        // Process |data|.
 //      }
 //
 //      if (ByteStreamReader::STREAM_COMPLETE == state) {
-//        DownloadInterruptReason status = reader->GetStatus();
+//        int status = reader->GetStatus();
 //        // Process error or successful completion in |status|.
 //      }
 //
 //      // if |state| is STREAM_EMPTY, we're done for now; we'll be called
 //      // again when there's more data.
 //    }
 class CONTENT_EXPORT ByteStreamWriter {
-public:
+ public:
   // Inverse of the fraction of the stream buffer that must be full before
   // a notification is sent to paired Reader that there's more data.
   static const int kFractionBufferBeforeSending;
 
   virtual ~ByteStreamWriter() = 0;
 
   // Always adds the data passed into the ByteStream.  Returns true
   // if more data may be added without exceeding the class limit
   // on data.  Takes ownership of |buffer|.
   virtual bool Write(scoped_refptr<net::IOBuffer> buffer,
                      size_t byte_count) = 0;
 
   // Flushes contents buffered in this writer to the corresponding reader
   // regardless if buffer filling rate is greater than
   // kFractionBufferBeforeSending or not. Does nothing if there's no contents
   // buffered.
   virtual void Flush() = 0;
 
   // Signal that all data that is going to be sent, has been sent,
-  // and provide a status.  |DOWNLOAD_INTERRUPT_REASON_NONE| should be
-  // passed for successful completion.
-  virtual void Close(DownloadInterruptReason status) = 0;
+  // and provide a status.
+  virtual void Close(int status) = 0;
 
   // Register a callback to be called when the stream transitions from
   // full to having space available.  The callback will always be
   // called on the task runner associated with the ByteStreamWriter.
   // This callback will only be called if a call to Write has previously
   // returned false (i.e. the ByteStream has been filled).
   // Multiple calls to this function are supported, though note that it
   // is the callers responsibility to handle races with space becoming
   // available (i.e. in the case of that race either of the before
   // or after callbacks may be called).
@@ skipping 14 matching lines @@
   // Returns STREAM_EMPTY if there is no data on the ByteStream and
   // Close() has not been called, and STREAM_COMPLETE if there
   // is no data on the ByteStream and Close() has been called.
   // If there is data on the ByteStream, returns STREAM_HAS_DATA
   // and fills in |*data| with a pointer to the data, and |*length|
   // with its length.
   virtual StreamState Read(scoped_refptr<net::IOBuffer>* data,
                            size_t* length) = 0;
 
   // Only valid to call if Read() has returned STREAM_COMPLETE.
-  virtual DownloadInterruptReason GetStatus() const = 0;
+  virtual int GetStatus() const = 0;
 
   // Register a callback to be called when data is added or the source
   // completes.  The callback will be always be called on the owning
   // task runner.  Multiple calls to this function are supported,
   // though note that it is the callers responsibility to handle races
   // with data becoming available (i.e. in the case of that race
   // either of the before or after callbacks may be called).
   // The callback will not be called after ByteStreamReader destruction.
   virtual void RegisterCallback(const base::Closure& sink_callback) = 0;
 };
 
 CONTENT_EXPORT void CreateByteStream(
     scoped_refptr<base::SequencedTaskRunner> input_task_runner,
     scoped_refptr<base::SequencedTaskRunner> output_task_runner,
     size_t buffer_size,
     scoped_ptr<ByteStreamWriter>* input,
     scoped_ptr<ByteStreamReader>* output);
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BYTE_STREAM_H_