Fix the case where the browser livelocks if we cannot open a file.

net/base/upload_data.h

 // Copyright (c) 2006-2008 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/file_path.h"
 #include "base/ref_counted.h"
 
 namespace net {
 
 class UploadData : public base::RefCounted<UploadData> {
  public:
   UploadData() : identifier_(0) {}
 
   enum Type {
     TYPE_BYTES,
     TYPE_FILE
   };
 
   class Element {
    public:
     Element() : type_(TYPE_BYTES), file_range_offset_(0),
-                file_range_length_(kuint64max) {
+                file_range_length_(kuint64max), expected_file_length_(-1) {
     }
 
     Type type() const { return 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_; }
+    int64 expected_length() const { return expected_file_length_; }

[wtc, 2010/01/12 19:51:02]

Nit: rename this method expected_file_size and the
underlying member expected_file_size_.

[agl, 2010/01/25 14:14:09]

Done.

 
     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);
     }
 
     void SetToFilePathRange(const FilePath& path,
                             uint64 offset, uint64 length) {
       type_ = TYPE_FILE;
       file_path_ = path;
       file_range_offset_ = offset;
       file_range_length_ = length;
     }
 
     // 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() const;
 
    private:
     Type type_;
     std::vector<char> bytes_;
     FilePath file_path_;
     uint64 file_range_offset_;
     uint64 file_range_length_;
+
+    // If this Element is a file, then this is the length that we expect it to
+    // have. This allows us to detect when a file has been truncated from under
+    // us. This is only valid after calling GetContentLength().
+    mutable int64 expected_file_length_;

[wtc, 2010/01/12 19:51:02]

Does this member need to be mutable?

[agl, 2010/01/25 14:14:09]

It's changed inside of GetContextLength, which is a const member. However, I
tried working backwards and removing consts and it wasn't so bad. So this is no
longer mutable.

   };
 
   void AppendBytes(const char* bytes, int bytes_len) {
     if (bytes_len > 0) {
       elements_.push_back(Element());
       elements_.back().SetToBytes(bytes, bytes_len);
     }
   }
 
   void AppendFile(const FilePath& file_path) {
@@ skipping 33 matching lines @@
 
   ~UploadData() {}
 
   std::vector<Element> elements_;
   int64 identifier_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_UPLOAD_DATA_H_