Home | History | Annotate | Download | only in streams 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CONTENT_BROWSER_STREAMS_STREAM_H_
      6 #define CONTENT_BROWSER_STREAMS_STREAM_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/memory/ref_counted.h"
     10 #include "base/memory/weak_ptr.h"
     11 #include "content/browser/byte_stream.h"
     12 #include "content/common/content_export.h"
     13 #include "url/gurl.h"
     14 
     15 namespace net {
     16 class HttpResponseHeaders;
     17 class IOBuffer;
     18 }
     19 
     20 namespace content {
     21 
     22 class StreamHandle;
     23 class StreamHandleImpl;
     24 class StreamReadObserver;
     25 class StreamRegistry;
     26 class StreamWriteObserver;
     27 
     28 // A stream that sends data from an arbitrary source to an internal URL
     29 // that can be read by an internal consumer.  It will continue to pull from the
     30 // original URL as long as there is data available.  It can be read from
     31 // multiple clients, but only one can be reading at a time. This allows a
     32 // reader to consume part of the stream, then pass it along to another client
     33 // to continue processing the stream.
     34 class CONTENT_EXPORT Stream : public base::RefCountedThreadSafe<Stream> {
     35  public:
     36   enum StreamState {
     37     STREAM_HAS_DATA,
     38     STREAM_COMPLETE,
     39     STREAM_EMPTY,
     40     STREAM_ABORTED,
     41   };
     42 
     43   // Creates a stream.
     44   //
     45   // Security origin of Streams is checked in Blink (See BlobRegistry,
     46   // BlobURL and SecurityOrigin to understand how it works). There's no security
     47   // origin check in Chromium side for now.
     48   Stream(StreamRegistry* registry,
     49          StreamWriteObserver* write_observer,
     50          const GURL& url);
     51 
     52   // Sets the reader of this stream. Returns true on success, or false if there
     53   // is already a reader.
     54   bool SetReadObserver(StreamReadObserver* observer);
     55 
     56   // Removes the read observer.  |observer| must be the current observer.
     57   void RemoveReadObserver(StreamReadObserver* observer);
     58 
     59   // Removes the write observer.  |observer| must be the current observer.
     60   void RemoveWriteObserver(StreamWriteObserver* observer);
     61 
     62   // Stops accepting new data, clears all buffer, unregisters this stream from
     63   // |registry_| and make coming ReadRawData() calls return STREAM_ABORTED.
     64   void Abort();
     65 
     66   // Adds the data in |buffer| to the stream.  Takes ownership of |buffer|.
     67   void AddData(scoped_refptr<net::IOBuffer> buffer, size_t size);
     68   // Adds data of |size| at |data| to the stream. This method creates a copy
     69   // of the data, and then passes it to |writer_|.
     70   void AddData(const char* data, size_t size);
     71 
     72   // Notifies this stream that it will not be receiving any more data.
     73   void Finalize();
     74 
     75   // Reads a maximum of |buf_size| from the stream into |buf|.  Sets
     76   // |*bytes_read| to the number of bytes actually read.
     77   // Returns STREAM_HAS_DATA if data was read, STREAM_EMPTY if no data was read,
     78   // and STREAM_COMPLETE if the stream is finalized and all data has been read.
     79   StreamState ReadRawData(net::IOBuffer* buf, int buf_size, int* bytes_read);
     80 
     81   scoped_ptr<StreamHandle> CreateHandle(
     82       const GURL& original_url,
     83       const std::string& mime_type,
     84       scoped_refptr<net::HttpResponseHeaders> response_headers);
     85   void CloseHandle();
     86 
     87   // Indicates whether there is space in the buffer to add more data.
     88   bool can_add_data() const { return can_add_data_; }
     89 
     90   const GURL& url() const { return url_; }
     91 
     92   // For StreamRegistry to remember the last memory usage reported to it.
     93   size_t last_total_buffered_bytes() const {
     94     return last_total_buffered_bytes_;
     95   }
     96 
     97  private:
     98   friend class base::RefCountedThreadSafe<Stream>;
     99 
    100   virtual ~Stream();
    101 
    102   void OnSpaceAvailable();
    103   void OnDataAvailable();
    104 
    105   // Clears |data_| and related variables.
    106   void ClearBuffer();
    107 
    108   bool can_add_data_;
    109 
    110   GURL url_;
    111 
    112   // Buffer for storing data read from |reader_| but not yet read out from this
    113   // Stream by ReadRawData() method.
    114   scoped_refptr<net::IOBuffer> data_;
    115   // Number of bytes read from |reader_| into |data_| including bytes already
    116   // read out.
    117   size_t data_length_;
    118   // Number of bytes in |data_| that are already read out.
    119   size_t data_bytes_read_;
    120 
    121   // Last value returned by writer_->TotalBufferedBytes() in AddData(). Stored
    122   // in order to check memory usage.
    123   size_t last_total_buffered_bytes_;
    124 
    125   scoped_ptr<ByteStreamWriter> writer_;
    126   scoped_ptr<ByteStreamReader> reader_;
    127 
    128   StreamRegistry* registry_;
    129   StreamReadObserver* read_observer_;
    130   StreamWriteObserver* write_observer_;
    131 
    132   StreamHandleImpl* stream_handle_;
    133 
    134   base::WeakPtrFactory<Stream> weak_ptr_factory_;
    135   DISALLOW_COPY_AND_ASSIGN(Stream);
    136 };
    137 
    138 }  // namespace content
    139 
    140 #endif  // CONTENT_BROWSER_STREAMS_STREAM_H_
    141