Split net::UploadData into two: for IPC and for upload handling

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_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/supports_user_data.h"
 #include "base/time.h"
-#include "googleurl/src/gurl.h"
 #include "net/base/net_export.h"
 
 namespace net {
 
 class FileStream;
 
 // Interface implemented by callers who require callbacks when new chunks
 // of data are added.
 class NET_EXPORT_PRIVATE ChunkCallback {
  public:
@@ skipping 11 matching lines @@
 // Until there is a more abstract class for this, this one derives from
 // SupportsUserData to allow users to stash random data by
 // key and ensure its destruction when UploadData is finally deleted.
 class NET_EXPORT UploadData
     : public base::RefCounted<UploadData>,
       public base::SupportsUserData {
  public:
   enum Type {
     TYPE_BYTES,
     TYPE_FILE,
-    TYPE_BLOB,
 
     // A block of bytes to be sent in chunked encoding immediately, without
     // waiting for rest of the data.
     TYPE_CHUNK,
   };
 
   class NET_EXPORT Element {
    public:
     Element();
     ~Element();
 
     Type type() const { return type_; }
     // Explicitly sets the type of this Element. Used during IPC
     // marshalling.
     void set_type(Type type) {
       type_ = type;
     }
 
-    const std::vector<char>& bytes() const { return bytes_; }
+    const char* bytes() const { return bytes_start_ ? bytes_start_ : &buf_[0]; }

[darin (slow to review), 2012/08/15 17:49:55]

maybe you should just ensure that bytes_start_ is always set?

[kinuko, 2012/08/16 08:14:59]

To do so we need to allocate memory by ourselves and have a flag to free it
(since Element is copyable), and I thought having wrapper getter might be
easier.

+    uint64 bytes_length() const { return buf_.size() + bytes_length_; }
     const FilePath& file_path() const { return file_path_; }
     uint64 file_range_offset() const { return file_range_offset_; }
     uint64 file_range_length() const { return file_range_length_; }
     // If NULL time is returned, we do not do the check.
     const base::Time& expected_file_modification_time() const {
       return expected_file_modification_time_;
     }
-    const GURL& blob_url() const { return blob_url_; }
 
     void SetToBytes(const char* bytes, int bytes_len) {
       type_ = TYPE_BYTES;
-      bytes_.assign(bytes, bytes + bytes_len);
+      buf_.assign(bytes, bytes + bytes_len);
+    }
+
+    void SetToSharedBytes(const char* bytes, int bytes_len) {

[darin (slow to review), 2012/08/15 17:49:55]

You should probably add a warning here about memory management.  The trick about
having to use UserData to ensure that the lifetime of this pointer remains valid
for the lifetime of the UploadData object is not so obvious.  A comment about
that might help.

[kinuko, 2012/08/16 08:14:59]

Done.

+      type_ = TYPE_BYTES;
+      bytes_start_ = bytes;
+      bytes_length_ = bytes_len;
     }
 
     void SetToFilePath(const FilePath& path) {
       SetToFilePathRange(path, 0, kuint64max, base::Time());
     }
 
     // If expected_modification_time is NULL, we do not check for the file
     // change. Also note that the granularity for comparison is time_t, not
     // the full precision.
     void SetToFilePathRange(const FilePath& path,
                             uint64 offset, uint64 length,
                             const base::Time& expected_modification_time) {
       type_ = TYPE_FILE;
       file_path_ = path;
       file_range_offset_ = offset;
       file_range_length_ = length;
       expected_file_modification_time_ = expected_modification_time;
     }
 
-    // TODO(jianli): UploadData should not contain any blob reference. We need
-    // to define another structure to represent WebKit::WebHTTPBody.
-    void SetToBlobUrl(const GURL& blob_url) {
-      type_ = TYPE_BLOB;
-      blob_url_ = blob_url;
-    }
-
     // Though similar to bytes, a chunk indicates that the element is sent via
     // chunked transfer encoding and not buffered until the full upload data
     // is available.
     void SetToChunk(const char* bytes, int bytes_len, bool is_last_chunk);
 
     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;
     }
@@ skipping 28 matching lines @@
     // 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_;
+    std::vector<char> buf_;
+    const char* bytes_start_;
+    uint64 bytes_length_;
     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);
     FRIEND_TEST_ALL_PREFIXES(HttpNetworkTransactionSpdy2Test,
                              UploadFileSmallerThanLength);
     FRIEND_TEST_ALL_PREFIXES(HttpNetworkTransactionSpdy3Test,
                              UploadFileSmallerThanLength);
   };
 
   UploadData();
 
   void AppendBytes(const char* bytes, int bytes_len);
 
   void AppendFileRange(const FilePath& file_path,
                        uint64 offset, uint64 length,
                        const base::Time& expected_modification_time);
 
-  void AppendBlob(const GURL& blob_url);
-
   // Adds the given chunk of bytes to be sent immediately with chunked transfer
   // encoding.
   void AppendChunk(const char* bytes, int bytes_len, bool is_last_chunk);
 
   // Sets the callback to be invoked when a new chunk is available to upload.
   void set_chunk_callback(ChunkCallback* callback);
 
   // Initializes the object to send chunks of upload data over time rather
   // than all at once.
   void set_is_chunked(bool set) { is_chunked_ = set; }
@@ skipping 50 matching lines @@
   virtual ~UploadData();
 
   std::vector<Element> elements_;
   int64 identifier_;
   ChunkCallback* chunk_callback_;
   bool is_chunked_;
 
   DISALLOW_COPY_AND_ASSIGN(UploadData);
 };
 
-#if defined(UNIT_TEST)
-inline bool operator==(const UploadData::Element& a,
-                       const UploadData::Element& b) {
-  if (a.type() != b.type())
-    return false;
-  if (a.type() == UploadData::TYPE_BYTES)
-    return a.bytes() == b.bytes();
-  if (a.type() == UploadData::TYPE_FILE) {
-    return a.file_path() == b.file_path() &&
-           a.file_range_offset() == b.file_range_offset() &&
-           a.file_range_length() == b.file_range_length() &&
-           a.expected_file_modification_time() ==
-              b.expected_file_modification_time();
-  }
-  if (a.type() == UploadData::TYPE_BLOB)
-    return a.blob_url() == b.blob_url();
-  return false;
-}
-
-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_