net: Move the logic reading upload elements to UploadData::Element.

net/base/upload_data.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 NET_BASE_UPLOAD_DATA_H_
 #define NET_BASE_UPLOAD_DATA_H_
 #pragma once
 
 #include <vector>
 
@@ skipping 92 matching lines @@
     bool is_last_chunk() const { return is_last_chunk_; }
     // Sets whether this is the last chunk. Used during IPC marshalling.
     void set_is_last_chunk(bool is_last_chunk) {
       is_last_chunk_ = is_last_chunk;
     }
 
     // Returns the byte-length of the element.  For files that do not exist, 0
     // is returned.  This is done for consistency with Mozilla.
     uint64 GetContentLength();
 
-    // Returns a FileStream opened for reading for this element, positioned at
-    // |file_range_offset_|.  The caller gets ownership and is responsible
-    // for cleaning up the FileStream. Returns NULL if this element is not of
-    // type TYPE_FILE or if the file is not openable.
-    FileStream* NewFileStreamForReading();
+    // Reads up to |buf_len| bytes synchronously. Returns the number of bytes
+    // read. This function never fails. If there's less data to read than we
+    // initially observed, then pad with zero (this can happen with files).
+    // |buf_len| must be greater than 0.
+    int ReadSync(char* buf, int buf_len);
+
+    // Returns the number of bytes remaining to read.
+    uint64 BytesRemaining();
+
+    // Resets the offset to zero, so that the element can be reread.
+    void ResetOffset() { offset_ = 0; }
 
    private:
+    // Returns a FileStream opened for reading for this element, positioned
+    // at |file_range_offset_|. Returns NULL if the file is not openable.
+    FileStream* OpenFileStream();
+
+    // Reads up to |buf_len| bytes synchronously from memory (i.e. type_ is
+    // TYPE_BYTES or TYPE_CHUNK).
+    int ReadFromMemorySync(char* buf, int buf_len);
+
+    // Reads up to |buf_len| bytes synchronously from a file (i.e. type_ is
+    // TYPE_FILE).
+    int ReadFromFileSync(char* buf, int buf_len);
+
     // Allows tests to override the result of GetContentLength.
     void SetContentLength(uint64 content_length) {
       override_content_length_ = true;
       content_length_ = content_length;
     }
 
     Type type_;
     std::vector<char> bytes_;
     FilePath file_path_;
     uint64 file_range_offset_;
     uint64 file_range_length_;
     base::Time expected_file_modification_time_;
     GURL blob_url_;
     bool is_last_chunk_;
     bool override_content_length_;
     bool content_length_computed_;
     uint64 content_length_;
+
+    // The byte offset from the beginning of the element data. Used to track
+    // the current position when reading data.
+    size_t offset_;
+
+    // The stream of the element data, if this element is of TYPE_FILE.
     FileStream* file_stream_;
 
     FRIEND_TEST_ALL_PREFIXES(UploadDataStreamTest, FileSmallerThanLength);
     FRIEND_TEST_ALL_PREFIXES(HttpNetworkTransactionTest,
                              UploadFileSmallerThanLength);
   };
 
   UploadData();
 
   void AppendBytes(const char* bytes, int bytes_len);
@@ skipping 26 matching lines @@
   // Returns the total size in bytes of the data to upload, for testing.
   // This version may perform file IO on the current thread. This function
   // will fail if called on a thread where file IO is prohibited. Usually
   // used for testing, but Chrome Frame also uses this version.
   uint64 GetContentLengthSync();
 
   // Returns true if the upload data is entirely in memory (i.e. the
   // upload data is not chunked, and all elemnts are of TYPE_BYTES).
   bool IsInMemory() const;
 
+  // Resets the offset of each upload data element to zero, so that the
+  // upload data can be reread. This can happen if the same upload data is
+  // reused for a new UploadDataStream.
+  void ResetOffset();
+
   std::vector<Element>* elements() {
     return &elements_;
   }
 
   void SetElements(const std::vector<Element>& elements);
 
   void swap_elements(std::vector<Element>* elements) {
     elements_.swap(*elements);
   }
 
@@ skipping 40 matching lines @@
 
 inline bool operator!=(const UploadData::Element& a,
                        const UploadData::Element& b) {
   return !(a == b);
 }
 #endif  // defined(UNIT_TEST)
 
 }  // namespace net
 
 #endif  // NET_BASE_UPLOAD_DATA_H_