Remove support for a URLRequest having a NULL Delegate.

storage/browser/fileapi/file_writer_delegate.cc

 // 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.
 
 #include "storage/browser/fileapi/file_writer_delegate.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util_proxy.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 27 matching lines @@
 
 void FileWriterDelegate::Start(scoped_ptr<net::URLRequest> request,
                                const DelegateWriteCallback& write_callback) {
   write_callback_ = write_callback;
   request_ = request.Pass();
   request_->Start();
 }
 
 void FileWriterDelegate::Cancel() {
   if (request_) {
-    // This halts any callbacks on this delegate.
-    request_->set_delegate(NULL);
-    request_->Cancel();
+    // Destroy the request to prevent it from invoking any callbacks.
+    request_.reset();
   }
 
   const int status = file_stream_writer_->Cancel(
       base::Bind(&FileWriterDelegate::OnWriteCancelled,
                  weak_factory_.GetWeakPtr()));
   // Return true to finish immediately if we have no pending writes.
   // Otherwise we'll do the final cleanup in the Cancel callback.
   if (status != net::ERR_IO_PENDING) {
     write_callback_.Run(base::File::FILE_ERROR_ABORT, 0,
                         GetCompletionStatusOnError());
@@ skipping 90 matching lines @@
     OnError(NetErrorToFileError(write_response));
   }
 }
 
 void FileWriterDelegate::OnDataWritten(int write_response) {
   if (write_response > 0) {
     OnProgress(write_response, false);
     cursor_->DidConsume(write_response);
     bytes_written_ += write_response;
     if (bytes_written_ == bytes_read_)
       Read();

[michaeln, 2015/12/14 20:27:26]

Not sure? I think you may need a null check in Read() now.

[mmenke, 2015/12/14 20:38:23]

I don't think so.  From FileStreamWriter::Cancel:

// In either case, the callback function passed to the in-flight async
// operation is dismissed immediately when Cancel() is called, and thus
// will never be called.

If that documentation is accurate, the call to FileStreamWriter::Cancel in
FileWriterDelegate::Cancel should ensure this isn't called after cancellation,
right?

[michaeln, 2015/12/14 20:58:30]

What about the other .reset() callsite in OnError? It's hard to be convinced
this isn't reentrant in unexpected ways?

     else
       Write();
   } else {
     OnError(NetErrorToFileError(write_response));
   }
 }
 
 FileWriterDelegate::WriteProgressStatus
 FileWriterDelegate::GetCompletionStatusOnError() const {
   return writing_started_ ? ERROR_WRITE_STARTED : ERROR_WRITE_NOT_STARTED;
 }
 
 void FileWriterDelegate::OnError(base::File::Error error) {
   if (request_) {
-    request_->set_delegate(NULL);
-    request_->Cancel();
+    // Destroy the request to prevent it from invoking any callbacks.
+    request_.reset();
   }
 
   if (writing_started_)
     MaybeFlushForCompletion(error, 0, ERROR_WRITE_STARTED);
   else
     write_callback_.Run(error, 0, ERROR_WRITE_NOT_STARTED);
 }
 
 void FileWriterDelegate::OnProgress(int bytes_written, bool done) {
   DCHECK(bytes_written + bytes_written_backlog_ >= bytes_written_backlog_);
@@ skipping 48 matching lines @@
   if (error == base::File::FILE_OK && flush_error != net::OK) {
     // If the Flush introduced an error, overwrite the status.
     // Otherwise, keep the original error status.
     error = NetErrorToFileError(flush_error);
     progress_status = GetCompletionStatusOnError();
   }
   write_callback_.Run(error, bytes_written, progress_status);
 }
 
 }  // namespace storage