net/base/upload_data_stream.h

   1 // Copyright (c) 2012 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 NET_BASE_UPLOAD_DATA_STREAM_H_
   6 #define NET_BASE_UPLOAD_DATA_STREAM_H_
   7
   8 #include "base/gtest_prod_util.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/memory/scoped_vector.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "net/base/completion_callback.h"
  13 #include "net/base/net_export.h"
  14
  15 namespace net {
  16
  17 class DrainableIOBuffer;
  18 class IOBuffer;
  19 class UploadElementReader;
  20
  21 // A class to read all elements from an UploadData object.
  22 class NET_EXPORT UploadDataStream {
  23  public:
  24   // An enum used to construct chunked data stream.
  25   enum Chunked { CHUNKED };
  26
  27   // Constructs a non-chunked data stream.
  28   // |element_readers| is cleared by this ctor.
  29   UploadDataStream(ScopedVector<UploadElementReader>* element_readers,
  30                    int64 identifier);
  31
  32   // Constructs a chunked data stream.
  33   UploadDataStream(Chunked chunked, int64 identifier);
  34
  35   ~UploadDataStream();
  36
  37   // Creates UploadDataStream with a reader.
  38   static UploadDataStream* CreateWithReader(
  39       scoped_ptr<UploadElementReader> reader,
  40       int64 identifier);
  41
  42   // Initializes the stream. This function must be called before calling any
  43   // other method. It is not valid to call any method (other than the
  44   // destructor) if Init() returns a failure. This method can be called multiple
  45   // times. Calling this method after a Init() success results in resetting the
  46   // state.
  47   //
  48   // Does the initialization synchronously and returns the result if possible,
  49   // otherwise returns ERR_IO_PENDING and runs the callback with the result.
  50   //
  51   // Returns OK on success. Returns ERR_UPLOAD_FILE_CHANGED if the expected
  52   // file modification time is set (usually not set, but set for sliced
  53   // files) and the target file is changed.
  54   int Init(const CompletionCallback& callback);
  55
  56   // When possible, reads up to |buf_len| bytes synchronously from the upload
  57   // data stream to |buf| and returns the number of bytes read; otherwise,
  58   // returns ERR_IO_PENDING and calls |callback| with the number of bytes read.
  59   // Partial reads are allowed. Zero is returned on a call to Read when there
  60   // are no remaining bytes in the stream, and IsEof() will return true
  61   // hereafter.
  62   //
  63   // If there's less data to read than we initially observed (i.e. the actual
  64   // upload data is smaller than size()), zeros are padded to ensure that
  65   // size() bytes can be read, which can happen for TYPE_FILE payloads.
  66   int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
  67
  68   // Identifies a particular upload instance, which is used by the cache to
  69   // formulate a cache key.  This value should be unique across browser
  70   // sessions.  A value of 0 is used to indicate an unspecified identifier.
  71   int64 identifier() const { return identifier_; }
  72
  73   // Returns the total size of the data stream and the current position.
  74   // size() is not to be used to determine whether the stream has ended
  75   // because it is possible for the stream to end before its size is reached,
  76   // for example, if the file is truncated. When the data is chunked, size()
  77   // always returns zero.
  78   uint64 size() const { return total_size_; }
  79   uint64 position() const { return current_position_; }
  80
  81   bool is_chunked() const { return is_chunked_; }
  82   bool last_chunk_appended() const { return last_chunk_appended_; }
  83
  84   const ScopedVector<UploadElementReader>& element_readers() const {
  85     return element_readers_;
  86   }
  87
  88   // Returns true if all data has been consumed from this upload data
  89   // stream.
  90   bool IsEOF() const;
  91
  92   // Returns true if the upload data in the stream is entirely in memory.
  93   bool IsInMemory() const;
  94
  95   // Adds the given chunk of bytes to be sent with chunked transfer encoding.
  96   void AppendChunk(const char* bytes, int bytes_len, bool is_last_chunk);
  97
  98  private:
  99   // Resets this instance to the uninitialized state.
 100   void Reset();
 101
 102   // Runs Init() for all element readers.
 103   // This method is used to implement Init().
 104   int InitInternal(int start_index, const CompletionCallback& callback);
 105
 106   // Resumes initialization and runs callback with the result when necessary.
 107   void ResumePendingInit(int start_index,
 108                          const CompletionCallback& callback,
 109                          int previous_result);
 110
 111   // Reads data from the element readers.
 112   // This method is used to implement Read().
 113   int ReadInternal(scoped_refptr<DrainableIOBuffer> buf,
 114                    const CompletionCallback& callback);
 115
 116   // Resumes pending read and calls callback with the result when necessary.
 117   void ResumePendingRead(scoped_refptr<DrainableIOBuffer> buf,
 118                          const CompletionCallback& callback,
 119                          int previous_result);
 120
 121   // Processes result of UploadElementReader::Read(). If |result| indicates
 122   // success, updates |buf|'s offset. Otherwise, sets |read_failed_| to true.
 123   void ProcessReadResult(scoped_refptr<DrainableIOBuffer> buf,
 124                          int result);
 125
 126   ScopedVector<UploadElementReader> element_readers_;
 127
 128   // Index of the current upload element (i.e. the element currently being
 129   // read). The index is used as a cursor to iterate over elements in
 130   // |upload_data_|.
 131   size_t element_index_;
 132
 133   // Size and current read position within the upload data stream.
 134   // |total_size_| is set to zero when the data is chunked.
 135   uint64 total_size_;
 136   uint64 current_position_;
 137
 138   const int64 identifier_;
 139
 140   const bool is_chunked_;
 141   bool last_chunk_appended_;
 142
 143   // True if an error occcured during read operation.
 144   bool read_failed_;
 145
 146   // True if the initialization was successful.
 147   bool initialized_successfully_;
 148
 149   // Callback to resume reading chunked data.
 150   base::Closure pending_chunked_read_callback_;
 151
 152   base::WeakPtrFactory<UploadDataStream> weak_ptr_factory_;
 153
 154   DISALLOW_COPY_AND_ASSIGN(UploadDataStream);
 155 };
 156
 157 }  // namespace net
 158
 159 #endif  // NET_BASE_UPLOAD_DATA_STREAM_H_