Add chunked uploads support to SPDY

net/base/upload_data_stream.h

 // Copyright (c) 2010 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 NET_BASE_UPLOAD_DATA_STREAM_H_
 #define NET_BASE_UPLOAD_DATA_STREAM_H_
 #pragma once
 
 #include "base/scoped_ptr.h"
 #include "net/base/upload_data.h"
 
 namespace net {
 
 class FileStream;
 class IOBuffer;
 
 class UploadDataStream {
  public:
   ~UploadDataStream();
 
   // Returns a new instance of UploadDataStream if it can be created and
   // initialized successfully. If not, NULL will be returned and the error
   // code will be set if the output parameter error_code is not empty.
   static UploadDataStream* Create(UploadData* data, int* error_code);
 
   // Returns the stream's buffer and buffer length.
   IOBuffer* buf() const { return buf_; }
   size_t buf_len() const { return buf_len_; }
 
+  // TODO(satish): We should ideally have UploadDataStream expose a Read()
+  // method which returns data in a caller provided IOBuffer. That would do away
+  // with this method and make the interface cleaner as well with less memmove
+  // calls.
+  size_t GetMaxBufferSize() const { return kBufSize; }
+
   // Call to indicate that a portion of the stream's buffer was consumed.  This
   // call modifies the stream's buffer so that it contains the next segment of
   // the upload data to be consumed.
   void MarkConsumedAndFillBuffer(size_t num_bytes);
 
   // Sets the callback to be invoked when new chunks are available to upload.
   void set_chunk_callback(ChunkCallback* callback) {
     data_->set_chunk_callback(callback);
   }
 
   // Returns the total size of the data stream and the current position.
   // size() is not to be used to determine whether the stream has ended
   // because it is possible for the stream to end before its size is reached,
   // for example, if the file is truncated.
   uint64 size() const { return total_size_; }
   uint64 position() const { return current_position_; }
 
   bool is_chunked() const { return data_->is_chunked(); }
 
   // Returns whether there is no more data to read, regardless of whether
   // position < size.
   bool eof() const { return eof_; }
 
+  // Returns whether the data available in buf() includes the last chunk in a
+  // chunked data stream. This method returns true once the final chunk has been
+  // placed in the IOBuffer returned by buf(), in contrast to eof() which
+  // returns true only after the data in buf() has been consumed.
+  bool IsOnLastChunk() const;
+
+#if UNIT_TEST

[willchan no longer on Chromium, 2011/03/03 23:42:32]

most chromium code does defined(UNIT_TEST), not just #if UNIT_TEST. It's
probably best to be consistent.

Please add a TODO to remove this. And I expect you to do this one after you
submit this changelist, because this is kludgy. I think you should add stuff to
UploadData one by one.

[Satish, 2011/03/03 23:50:59]

Will do.
With the current mock read/write testing model, I can't find easily how to break
in the middle of an ongoing sequence and add more chunks to the stream. If you
have any suggestions please let me know, perhaps topic for a separate mail
thread.

+  static void set_merge_chunks(bool merge) { merge_chunks_ = merge; }
+#endif
+
  private:
   enum { kBufSize = 16384 };
 
   // Protects from public access since now we have a static creator function
   // which will do both creation and initialization and might return an error.
   explicit UploadDataStream(UploadData* data);
 
   // Fills the buffer with any remaining data and sets eof_ if there was nothing
   // left to fill the buffer with.
   // Returns OK if the operation succeeds. Otherwise error code is returned.
@@ skipping 23 matching lines @@
   // if the next element is of TYPE_FILE.
   uint64 next_element_remaining_;
 
   // Size and current read position within the stream.
   uint64 total_size_;
   uint64 current_position_;
 
   // Whether there is no data left to read.
   bool eof_;
 
+  static bool merge_chunks_;
+
   DISALLOW_COPY_AND_ASSIGN(UploadDataStream);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_UPLOAD_DATA_STREAM_H_