net: Move write flush responsiblity from URLFetcherResponseWriter to URLFetcherCore

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/file_util.h"
 #include "base/location.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
@@ skipping 73 matching lines @@
   }
   return result;
 }
 
 int URLFetcherFileWriter::Write(IOBuffer* buffer,
                                 int num_bytes,
                                 const CompletionCallback& callback) {
   DCHECK(file_stream_);
   DCHECK(owns_file_);
 
-  ContinueWrite(new DrainableIOBuffer(buffer, num_bytes), callback, OK);
-  return ERR_IO_PENDING;
+  int result = file_stream_->Write(buffer, num_bytes,
+                                   base::Bind(&URLFetcherFileWriter::DidWrite,
+                                              weak_factory_.GetWeakPtr(),
+                                              callback));
+  DCHECK_LT(result, 0);

[wtc, 2013/05/23 01:00:16]

Does this DCHECK mean we expect to get either ERR_IO_PENDING
or a real error?

The comments in net/base/file_stream.h say FileStream::Write
may succeed synchronously and return the number of bytes
written.

It seems that this function is still correct even when
|result| is > 0.

[hashimoto, 2013/05/23 04:33:24]

I thought DCHECK_LT(result, 0) was a good idea because we provide
PLATFORM_FILE_ASYNC for FileStream and both file_stream_context_win.cc and
file_stream_context_posix.cc always return negative values on
FileStream::Context::WriteAsync().
But this DCHECK turns out to be quite inappropriate because, as you said,
|result >= 0| can be handled with the current code with no cost, and we should
have error handling code for result<0 cases.
Fixed.

+  return result;
 }
 
 int URLFetcherFileWriter::Finish(const CompletionCallback& callback) {
   file_stream_.reset();
   return OK;
 }
 
-void URLFetcherFileWriter::ContinueWrite(
-    scoped_refptr<DrainableIOBuffer> buffer,
-    const CompletionCallback& callback,
-    int result) {
-  // |file_stream_| should be alive when write is in progress.
-  DCHECK(file_stream_);
-
+void URLFetcherFileWriter::DidWrite(const CompletionCallback& callback,
+                                    int result) {
   if (result < 0) {
     error_code_ = result;
     CloseAndDeleteFile();
-    callback.Run(result);
-    return;
   }
-
-  total_bytes_written_ += result;
-  buffer->DidConsume(result);
-
-  if (buffer->BytesRemaining() > 0) {
-    file_stream_->Write(buffer, buffer->BytesRemaining(),
-                        base::Bind(&URLFetcherFileWriter::ContinueWrite,
-                                   weak_factory_.GetWeakPtr(),
-                                   buffer,
-                                   callback));
-  } else {
-    // Finished writing buffer to the file.
-    callback.Run(buffer->size());
-  }
+  callback.Run(result);
 }
 
 void URLFetcherFileWriter::DisownFile() {
   // Disowning is done by the delegate's OnURLFetchComplete method.
   // The file should be closed by the time that method is called.
   DCHECK(!file_stream_);
 
   owns_file_ = false;
 }
 
@@ skipping 36 matching lines @@
     total_bytes_written_ = 0;
     owns_file_ = true;
   } else {
     error_code_ = result;
     CloseAndDeleteFile();
   }
   callback.Run(result);
 }
 
 }  // namespace net