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

net/base/upload_data_stream.cc

 // Copyright (c) 2010 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_stream.h"
 
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
-UploadDataStream::UploadDataStream(const UploadData* data)
+UploadDataStream::UploadDataStream(UploadData* data)
     : data_(data),
       buf_(new IOBuffer(kBufSize)),
       buf_len_(0),
       next_element_(data->elements().begin()),
       next_element_offset_(0),
       next_element_remaining_(0),
       total_size_(data->GetContentLength()),
       current_position_(0),
       eof_(false) {
   FillBuf();
@@ skipping 36 matching lines @@
       buf_len_ += bytes_copied;
 
       if (bytes_copied == count) {
         advance_to_next_element = true;
       } else {
         next_element_offset_ += bytes_copied;
       }
     } else {
       DCHECK(element.type() == UploadData::TYPE_FILE);
 
-      if (!next_element_stream_.IsOpen()) {
-        int flags = base::PLATFORM_FILE_OPEN |
-                    base::PLATFORM_FILE_READ;
-        int rv = next_element_stream_.Open(element.file_path(), flags);
-        // If the file does not exist, that's technically okay.. we'll just
-        // upload an empty file.  This is for consistency with Mozilla.
-        DLOG_IF(WARNING, rv != OK) << "Failed to open \""
-                                   << element.file_path().value()
-                                   << "\" for reading: " << rv;
+      if (element.file_range_length() == 0) {
+        // If we failed to open the file, then the length is set to zero. The
+        // length used when calculating the POST size was also zero. This
+        // matches the behaviour of Mozilla.
+        next_element_remaining_ = 0;
+      } else {
+        if (!next_element_stream_.IsOpen()) {
+          // We ignore the return value of Open becuase we've already checked
+          // !IsOpen, above.
+          int flags = base::PLATFORM_FILE_READ |
+                      base::PLATFORM_FILE_WRITE;
+          next_element_stream_.Open(element.platform_file(), flags);
 
-        next_element_remaining_ = 0;  // Default to reading nothing.
-        if (rv == OK) {
           uint64 offset = element.file_range_offset();
           if (offset && next_element_stream_.Seek(FROM_BEGIN, offset) < 0) {
             DLOG(WARNING) << "Failed to seek \"" << element.file_path().value()
                           << "\" to offset: " << offset;
           } else {
             next_element_remaining_ = element.file_range_length();
           }
         }
       }
 
       int rv = 0;
-      int count = static_cast<int>(std::min(
-          static_cast<uint64>(size_remaining), next_element_remaining_));
-      if (count > 0 &&
-          (rv = next_element_stream_.Read(buf_->data() + buf_len_,
-                                          count, NULL)) > 0) {
+      if (next_element_remaining_ > 0) {
+        int count =
+            static_cast<int>(std::min(next_element_remaining_,
+                                      static_cast<uint64>(size_remaining)));
+        rv = next_element_stream_.Read(buf_->data() + buf_len_, count, NULL);
+        if (rv < 1) {
+          // If the file was truncated between the time that we opened it and
+          // now, or if we got an error on reading, then we pad with NULs.
+          memset(buf_->data() + buf_len_, 0, count);
+          rv = count;
+        }
+
         buf_len_ += rv;
         next_element_remaining_ -= rv;
       } else {
         advance_to_next_element = true;
       }
     }
 
     if (advance_to_next_element) {
       ++next_element_;
       next_element_offset_ = 0;
-      next_element_stream_.Close();
+      next_element_stream_.Release();
     }
   }
 
-  if (next_element_ == end && !buf_len_)
+  if (next_element_ == end && !buf_len_) {
     eof_ = true;
+    data_->CloseFiles();
+  }
 }
 
 }  // namespace net