Make URLFetcherFileWriter::Finish() skip closing file when there is an error

net/url_request/url_fetcher_response_writer.cc

 // Copyright (c) 2013 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/url_request/url_fetcher_response_writer.h"
 
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner_util.h"
@@ skipping 22 matching lines @@
   return OK;
 }
 
 int URLFetcherStringWriter::Write(IOBuffer* buffer,
                                   int num_bytes,
                                   const CompletionCallback& callback) {
   data_.append(buffer->data(), num_bytes);
   return num_bytes;
 }
 
-int URLFetcherStringWriter::Finish(const CompletionCallback& callback) {
+int URLFetcherStringWriter::Finish(int net_error,
+                                   const CompletionCallback& callback) {
   // Do nothing.
   return OK;
 }
 
 URLFetcherStringWriter* URLFetcherStringWriter::AsStringWriter() {
   return this;
 }
 
 URLFetcherFileWriter::URLFetcherFileWriter(
     scoped_refptr<base::SequencedTaskRunner> file_task_runner,
     const base::FilePath& file_path)
     : file_task_runner_(file_task_runner),
       file_path_(file_path),
       owns_file_(false),
       weak_factory_(this) {
   DCHECK(file_task_runner_.get());
 }
 
 URLFetcherFileWriter::~URLFetcherFileWriter() {
   CloseAndDeleteFile();
 }
 
 int URLFetcherFileWriter::Initialize(const CompletionCallback& callback) {
   file_stream_.reset(new FileStream(file_task_runner_));
 
   int result = ERR_IO_PENDING;
+  owns_file_ = true;
   if (file_path_.empty()) {
     base::FilePath* temp_file_path = new base::FilePath;
     base::PostTaskAndReplyWithResult(
         file_task_runner_.get(),
         FROM_HERE,
         base::Bind(&base::CreateTemporaryFile, temp_file_path),
         base::Bind(&URLFetcherFileWriter::DidCreateTempFile,
                    weak_factory_.GetWeakPtr(),
                    callback,
                    base::Owned(temp_file_path)));
@@ skipping 19 matching lines @@
   int result = file_stream_->Write(buffer, num_bytes,
                                    base::Bind(&URLFetcherFileWriter::DidWrite,
                                               weak_factory_.GetWeakPtr(),
                                               callback));
   if (result < 0 && result != ERR_IO_PENDING)
     CloseAndDeleteFile();
 
   return result;
 }
 
-int URLFetcherFileWriter::Finish(const CompletionCallback& callback) {
+int URLFetcherFileWriter::Finish(int net_error,
+                                 const CompletionCallback& callback) {
+  DCHECK_NE(ERR_IO_PENDING, net_error);
+  if (net_error < 0) {
+    // If an error occurred, simply delete the file after any pending operation
+    // is done. Do not call file_stream_->Close() because there might
+    // be an operation pending. See crbug.com/487732.
+    CloseAndDeleteFile();
+    return OK;
+  }
   // If the file_stream_ still exists at this point, close it.
   if (file_stream_) {
     int result = file_stream_->Close(base::Bind(
         &URLFetcherFileWriter::CloseComplete,
         weak_factory_.GetWeakPtr(), callback));
     if (result != ERR_IO_PENDING)
       file_stream_.reset();
     return result;
   }
   return OK;
@@ skipping 32 matching lines @@
 }
 
 void URLFetcherFileWriter::DidCreateTempFile(const CompletionCallback& callback,
                                              base::FilePath* temp_file_path,
                                              bool success) {
   if (!success) {
     callback.Run(ERR_FILE_NOT_FOUND);
     return;
   }
   file_path_ = *temp_file_path;
-  owns_file_ = true;
   const int result = file_stream_->Open(
       file_path_,
       base::File::FLAG_WRITE | base::File::FLAG_ASYNC |
       base::File::FLAG_OPEN,
       base::Bind(&URLFetcherFileWriter::DidOpenFile,
                  weak_factory_.GetWeakPtr(),
                  callback));
   if (result != ERR_IO_PENDING)
     DidOpenFile(callback, result);
 }
 
 void URLFetcherFileWriter::DidOpenFile(const CompletionCallback& callback,
                                        int result) {
-  if (result == OK)
-    owns_file_ = true;
-  else
+  if (result < OK)
     CloseAndDeleteFile();
 
   callback.Run(result);
 }
 
 void URLFetcherFileWriter::CloseComplete(const CompletionCallback& callback,
                                          int result) {
   // Destroy |file_stream_| whether or not the close succeeded.
   file_stream_.reset();
   callback.Run(result);
 }
 
 }  // namespace net