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 26 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 103 matching lines @@
     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_);
   static const int kMinProgressDelayMS = 200;
@@ skipping 47 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