Support FileSystem URL in File object

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"
@@ skipping 33 matching lines @@
       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,
+
+    // For a file specified as FileSystem URL.
+    TYPE_FILE_FILESYSTEM,

[darin (slow to review), 2012/08/10 16:50:24]

Can we avoid this?  It seems unfortunate to make the network stack have to know
about filesystem URLs.  The network stack formerly didn't know anything about
them, and I don't think it should start knowing about them now.

Is this a side-effect of sending net::UploadData over IPC?  Maybe we should be
using a different data structure for IPC serialization of upload data.

   };
 
   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 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_; }
+    const GURL& url() const { return url_; }
 
     void SetToBytes(const char* bytes, int bytes_len) {
       type_ = TYPE_BYTES;
       bytes_.assign(bytes, bytes + 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;
     }
 
+    void SetToFileSystemURLRange(
+        const GURL& url,
+        uint64 offset, uint64 length,
+        const base::Time& expected_modification_time) {
+      type_ = TYPE_FILE_FILESYSTEM;
+      url_ = url;
+      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;
+      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) {
@@ skipping 35 matching lines @@
       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_;
+    GURL 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 AppendFileSystemFileRange(const GURL& url,
+                                 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
@@ skipping 66 matching lines @@
     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();
+  if (a.type() == UploadData::TYPE_BLOB ||
+      a.type() == UploadData::TYPE_FILE_FILESYSTEM)
+    return a.url() == b.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_