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