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

net/base/upload_data.cc

 // 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.
 
 #include "net/base/upload_data.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 
 namespace net {
 
 uint64 UploadData::GetContentLength() const {
   uint64 len = 0;
   std::vector<Element>::const_iterator it = elements_.begin();
   for (; it != elements_.end(); ++it)
     len += (*it).GetContentLength();
   return len;
 }
 
 uint64 UploadData::Element::GetContentLength() const {
   if (type_ == TYPE_BYTES)
     return static_cast<uint64>(bytes_.size());
 
   DCHECK(type_ == TYPE_FILE);
 
-  // TODO(darin): This size calculation could be out of sync with the state of
-  // the file when we get around to reading it.  We should probably find a way
-  // to lock the file or somehow protect against this error condition.
+  expected_file_length_ = 0;
 
-  int64 length = 0;
+  if (!file_util::PathIsReadable(file_path_))

[darin (slow to review), 2010/01/12 07:57:45]

on windows, it might be nice to combine these two calls since you can get the
file size from an open file handle.

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

PathIsReadable no longer obtains a file handle, so there's nothing to merge now.

+    return 0;
+
+  int64 length;
   if (!file_util::GetFileSize(file_path_, &length))
     return 0;
 
   if (file_range_offset_ >= static_cast<uint64>(length))
     return 0;  // range is beyond eof
 
   // compensate for the offset and clip file_range_length_ to eof
-  return std::min(length - file_range_offset_, file_range_length_);
+  expected_file_length_ = std::min(length - file_range_offset_,
+                                   file_range_length_);
+  return expected_file_length_;
 }
 
 }  // namespace net