Rename URLFetcherImpl::Core::TempFileWriter to FileWriter

content/common/net/url_fetcher_impl.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 "content/common/net/url_fetcher_impl.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 81 matching lines @@
     int size() const {
       return fetchers_.size();
     }
 
    private:
     std::set<Core*> fetchers_;
 
     DISALLOW_COPY_AND_ASSIGN(Registry);
   };
 
-  // Class TempFileWriter encapsulates all state involved in writing
-  // response bytes to a temporary file. It is only used if
-  // |Core::response_destination_| == TEMP_FILE.  Each instance of
-  // TempFileWriter is owned by a URLFetcher::Core, which manages
+  // Class FileWriter encapsulates all state involved in writing response bytes
+  // to a file. It is only used if |Core::response_destination_| == FILE.
+  // Each instance of FileWriter is owned by a URLFetcher::Core, which manages
   // its lifetime and never transfers ownership.  While writing to
   // a file, all function calls happen on the IO thread.
-  class TempFileWriter {
+  class FileWriter {
    public:
-    TempFileWriter(
-        URLFetcherImpl::Core* core,
-        scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy);
+    FileWriter(URLFetcherImpl::Core* core,
+               scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy);
 
-    ~TempFileWriter();
+    ~FileWriter();
     void CreateTempFile();

[willchan no longer on Chromium, 2012/03/02 19:48:22]

Rename these too?

[hashimoto, 2012/03/03 02:56:37]

CreateTempFile is not renamed because it is a method which does something
specific to temporary files.
I am going to add CreateFile as a separate method to create ordinary files. 
(http://codereview.chromium.org/9585009/ is the CL in progress)

     void DidCreateTempFile(base::PlatformFileError error_code,
                            base::PassPlatformFile file_handle,
                            const FilePath& file_path);
 
     // Record |num_bytes_| response bytes in |core_->buffer_| to the file.
     void WriteBuffer(int num_bytes);
 
     // Called when a write has been done.  Continues writing if there are
     // any more bytes to write.  Otherwise, initiates a read in core_.
-    void ContinueWrite(base::PlatformFileError error_code,
-                       int bytes_written);
+    void ContinueWrite(base::PlatformFileError error_code, int bytes_written);
 
-    // Drop ownership of the file at path |temp_file_|. This class
-    // will not delete it or write to it again.
-    void DisownTempFile();
+    // Drop ownership of the file at |file_path_|.
+    // This class will not delete it or write to it again.
+    void DisownFile();
 
-    // Close the temp file if it is open.
-    void CloseTempFileAndCompleteRequest();
+    // Close the file if it is open.
+    void CloseFileAndCompleteRequest();
 
-    // Remove the temp file if we we created one.
-    void RemoveTempFile();
+    // Remove the file if we have created one.
+    void RemoveFile();
 
-    const FilePath& temp_file() const { return temp_file_; }
+    const FilePath& file_path() const { return file_path_; }
     int64 total_bytes_written() { return total_bytes_written_; }
     base::PlatformFileError error_code() const { return error_code_; }
 
    private:
-    // Callback which gets the result of closing the temp file.
-    void DidCloseTempFile(base::PlatformFileError error);
+    // Callback which gets the result of closing the file.
+    void DidCloseFile(base::PlatformFileError error);
 
     // The URLFetcherImpl::Core which instantiated this class.
     URLFetcherImpl::Core* core_;
 
     // The last error encountered on a file operation.  base::PLATFORM_FILE_OK
     // if no error occurred.
     base::PlatformFileError error_code_;
 
     // Callbacks are created for use with base::FileUtilProxy.
-    base::WeakPtrFactory<URLFetcherImpl::Core::TempFileWriter> weak_factory_;
+    base::WeakPtrFactory<URLFetcherImpl::Core::FileWriter> weak_factory_;
 
     // Message loop on which file operations should happen.
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy_;
 
-    // Path to the temporary file.  This path is empty when there
-    // is no temp file.
-    FilePath temp_file_;
+    // Path to the file.  This path is empty when there is no file.
+    FilePath file_path_;
 
-    // Handle to the temp file.
-    base::PlatformFile temp_file_handle_;
+    // Handle to the file.
+    base::PlatformFile file_handle_;
 
     // We always append to the file.  Track the total number of bytes
     // written, so that writes know the offset to give.
     int64 total_bytes_written_;
 
     // How many bytes did the last Write() try to write?  Needed so
     // that if not all the bytes get written on a Write(), we can
     // call Write() again with the rest.
     int pending_bytes_;
 
@@ skipping 33 matching lines @@
   // Store the response bytes in |buffer_| in the container indicated by
   // |response_destination_|. Return true if the write has been
   // done, and another read can overwrite |buffer_|.  If this function
   // returns false, it will post a task that will read more bytes once the
   // write is complete.
   bool WriteBuffer(int num_bytes);
 
   // Read response bytes from the request.
   void ReadResponse();
 
-  // Drop ownership of any temp file managed by |temp_file_|.
-  void DisownTempFile();
+  // Drop ownership of any file managed by |file_path_|.
+  void DisownFile();
 
   // Notify Delegate about the progress of downloading.
   void InformDelegateDownloadProgress();
   void InformDelegateDownloadProgressInDelegateThread(int64 current,
                                                       int64 total);
 
   URLFetcherImpl* fetcher_;          // Corresponding fetcher object
   GURL original_url_;                // The URL we were asked to fetch
   GURL url_;                         // The URL we eventually wound up at
   RequestType request_type_;         // What type of request is this?
@@ skipping 42 matching lines @@
   scoped_refptr<net::URLRequestThrottlerEntryInterface> url_throttler_entry_;
 
   // |num_retries_| indicates how many times we've failed to successfully
   // fetch this URL.  Once this value exceeds the maximum number of retries
   // specified by the owner URLFetcher instance, we'll give up.
   int num_retries_;
 
   // True if the URLFetcher has been cancelled.
   bool was_cancelled_;
 
-  // If writing results to a file, |temp_file_writer_| will manage creation,
+  // If writing results to a file, |file_writer_| will manage creation,
   // writing, and destruction of that file.
-  scoped_ptr<TempFileWriter> temp_file_writer_;
+  scoped_ptr<FileWriter> file_writer_;
 
   // Where should responses be saved?
   ResponseDestinationType response_destination_;
 
   // If |automatically_retry_on_5xx_| is false, 5xx responses will be
   // propagated to the observer, if it is true URLFetcher will automatically
   // re-execute the request, after the back-off delay has expired.
   // true by default.
   bool automatically_retry_on_5xx_;
   // Maximum retries allowed.
@@ skipping 27 matching lines @@
 
 void URLFetcherImpl::Core::Registry::CancelAll() {
   while (!fetchers_.empty())
     (*fetchers_.begin())->CancelURLRequest();
 }
 
 // static
 base::LazyInstance<URLFetcherImpl::Core::Registry>
     URLFetcherImpl::Core::g_registry = LAZY_INSTANCE_INITIALIZER;
 
-URLFetcherImpl::Core::TempFileWriter::TempFileWriter(
+URLFetcherImpl::Core::FileWriter::FileWriter(
     URLFetcherImpl::Core* core,
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy)
     : core_(core),
       error_code_(base::PLATFORM_FILE_OK),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       file_message_loop_proxy_(file_message_loop_proxy),
-      temp_file_handle_(base::kInvalidPlatformFileValue) {
+      file_handle_(base::kInvalidPlatformFileValue) {
 }
 
-URLFetcherImpl::Core::TempFileWriter::~TempFileWriter() {
-  RemoveTempFile();
+URLFetcherImpl::Core::FileWriter::~FileWriter() {
+  RemoveFile();
 }
 
-void URLFetcherImpl::Core::TempFileWriter::CreateTempFile() {
+void URLFetcherImpl::Core::FileWriter::CreateTempFile() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(file_message_loop_proxy_.get());
   base::FileUtilProxy::CreateTemporary(
       file_message_loop_proxy_,
       0,  // No additional file flags.
-      base::Bind(&URLFetcherImpl::Core::TempFileWriter::DidCreateTempFile,
+      base::Bind(&URLFetcherImpl::Core::FileWriter::DidCreateTempFile,
                  weak_factory_.GetWeakPtr()));
 }
 
-void URLFetcherImpl::Core::TempFileWriter::DidCreateTempFile(
+void URLFetcherImpl::Core::FileWriter::DidCreateTempFile(
     base::PlatformFileError error_code,
     base::PassPlatformFile file_handle,
     const FilePath& file_path) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
-    RemoveTempFile();
+    RemoveFile();
     core_->delegate_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::InformDelegateFetchIsComplete, core_));
     return;
   }
 
-  temp_file_ = file_path;
-  temp_file_handle_ = file_handle.ReleaseValue();
+  file_path_ = file_path;
+  file_handle_ = file_handle.ReleaseValue();
   total_bytes_written_ = 0;
 
   core_->io_message_loop_proxy_->PostTask(
       FROM_HERE, base::Bind(&Core::StartURLRequestWhenAppropriate, core_));
 }
 
-void URLFetcherImpl::Core::TempFileWriter::WriteBuffer(int num_bytes) {
+void URLFetcherImpl::Core::FileWriter::WriteBuffer(int num_bytes) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
-  // Start writing to the temp file by setting the initial state
+  // Start writing to the file by setting the initial state
   // of |pending_bytes_| and |buffer_offset_| to indicate that the
   // entire buffer has not yet been written.
   pending_bytes_ = num_bytes;
   buffer_offset_ = 0;
   ContinueWrite(base::PLATFORM_FILE_OK, 0);
 }
 
-void URLFetcherImpl::Core::TempFileWriter::ContinueWrite(
+void URLFetcherImpl::Core::FileWriter::ContinueWrite(
     base::PlatformFileError error_code,
     int bytes_written) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
-  if (temp_file_handle_ == base::kInvalidPlatformFileValue) {
+  if (file_handle_ == base::kInvalidPlatformFileValue) {
     // While a write was being done on the file thread, a request
     // to close or disown the file occured on the IO thread.  At
     // this point a request to close the file is pending on the
     // file thread.
     return;
   }
 
   // Every code path that resets |core_->request_| should reset
-  // |core->temp_file_writer_| or cause the temp file writer to
-  // disown the temp file.  In the former case, this callback can
-  // not be called, because the weak pointer to |this| will be NULL.
-  // In the latter case, the check of |temp_file_handle_| at the start
-  // of this method ensures that we can not reach this point.
+  // |core->file_writer_| or cause the file writer to disown the file.  In the
+  // former case, this callback can not be called, because the weak pointer to
+  // |this| will be NULL. In the latter case, the check of |file_handle_| at the
+  // start of this method ensures that we can not reach this point.
   CHECK(core_->request_.get());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
-    RemoveTempFile();
+    RemoveFile();
     core_->delegate_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   total_bytes_written_ += bytes_written;
   buffer_offset_ += bytes_written;
   pending_bytes_ -= bytes_written;
 
   if (pending_bytes_ > 0) {
     base::FileUtilProxy::Write(
-        file_message_loop_proxy_, temp_file_handle_,
+        file_message_loop_proxy_, file_handle_,
         total_bytes_written_,  // Append to the end
         (core_->buffer_->data() + buffer_offset_), pending_bytes_,
-        base::Bind(&URLFetcherImpl::Core::TempFileWriter::ContinueWrite,
+        base::Bind(&URLFetcherImpl::Core::FileWriter::ContinueWrite,
                    weak_factory_.GetWeakPtr()));
   } else {
     // Finished writing core_->buffer_ to the file. Read some more.
     core_->ReadResponse();
   }
 }
 
-void URLFetcherImpl::Core::TempFileWriter::DisownTempFile() {
+void URLFetcherImpl::Core::FileWriter::DisownFile() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   // Disowning is done by the delegate's OnURLFetchComplete method.
-  // The temp file should be closed by the time that method is called.
-  DCHECK(temp_file_handle_ == base::kInvalidPlatformFileValue);
+  // The file should be closed by the time that method is called.
+  DCHECK(file_handle_ == base::kInvalidPlatformFileValue);
 
-  // Forget about any temp file by reseting the path.
-  temp_file_ = FilePath();
+  // Forget about any file by reseting the path.
+  file_path_.clear();
 }
 
-void URLFetcherImpl::Core::TempFileWriter::CloseTempFileAndCompleteRequest() {
+void URLFetcherImpl::Core::FileWriter::CloseFileAndCompleteRequest() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
-  if (temp_file_handle_ != base::kInvalidPlatformFileValue) {
+  if (file_handle_ != base::kInvalidPlatformFileValue) {
     base::FileUtilProxy::Close(
-        file_message_loop_proxy_, temp_file_handle_,
-        base::Bind(&URLFetcherImpl::Core::TempFileWriter::DidCloseTempFile,
+        file_message_loop_proxy_, file_handle_,
+        base::Bind(&URLFetcherImpl::Core::FileWriter::DidCloseFile,
                    weak_factory_.GetWeakPtr()));
-    temp_file_handle_ = base::kInvalidPlatformFileValue;
+    file_handle_ = base::kInvalidPlatformFileValue;
   }
 }
 
-void URLFetcherImpl::Core::TempFileWriter::DidCloseTempFile(
-  base::PlatformFileError error_code) {
+void URLFetcherImpl::Core::FileWriter::DidCloseFile(
+    base::PlatformFileError error_code) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
-    RemoveTempFile();
+    RemoveFile();
     core_->delegate_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   // If the file was successfully closed, then the URL request is complete.
   core_->RetryOrCompleteUrlFetch();
 }
 
-void URLFetcherImpl::Core::TempFileWriter::RemoveTempFile() {
+void URLFetcherImpl::Core::FileWriter::RemoveFile() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
-  // Close the temp file if it is open.
-  if (temp_file_handle_ != base::kInvalidPlatformFileValue) {
+  // Close the file if it is open.
+  if (file_handle_ != base::kInvalidPlatformFileValue) {
     base::FileUtilProxy::Close(
-        file_message_loop_proxy_, temp_file_handle_,
+        file_message_loop_proxy_, file_handle_,
         base::FileUtilProxy::StatusCallback());  // No callback: Ignore errors.
-    temp_file_handle_ = base::kInvalidPlatformFileValue;
+    file_handle_ = base::kInvalidPlatformFileValue;
   }
 
-  if (!temp_file_.empty()) {
+  if (!file_path_.empty()) {
     base::FileUtilProxy::Delete(
-        file_message_loop_proxy_, temp_file_,
+        file_message_loop_proxy_, file_path_,
         false,  // No need to recurse, as the path is to a file.
         base::FileUtilProxy::StatusCallback());  // No callback: Ignore errors.
-    DisownTempFile();
+    DisownFile();
   }
 }
 
 static content::URLFetcherFactory* g_factory = NULL;
 static bool g_interception_enabled = false;
 
 // static
 content::URLFetcher* content::URLFetcher::Create(
     const GURL& url,
     RequestType request_type,
@@ skipping 80 matching lines @@
 }
 
 void URLFetcherImpl::Core::StartOnIOThread() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   switch (response_destination_) {
     case STRING:
       StartURLRequestWhenAppropriate();
       break;
 
-    case TEMP_FILE:
+    case FILE:
       DCHECK(file_message_loop_proxy_.get())
-        << "Need to set the file message loop proxy.";
+          << "Need to set the file message loop proxy.";
 
-      temp_file_writer_.reset(
-          new TempFileWriter(this, file_message_loop_proxy_));
+      file_writer_.reset(
+          new FileWriter(this, file_message_loop_proxy_));
 
       // If the temp file is successfully created,
       // Core::StartURLRequestWhenAppropriate() will be called.
-      temp_file_writer_->CreateTempFile();
+      file_writer_->CreateTempFile();
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void URLFetcherImpl::Core::Stop() {
-  if (delegate_loop_proxy_) {  // May be NULL in tests.
+  if (delegate_loop_proxy_)  // May be NULL in tests.
     DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
-  }
+
   delegate_ = NULL;
   fetcher_ = NULL;
   if (io_message_loop_proxy_.get()) {
     io_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::CancelURLRequest, this));
   }
 }
 
 void URLFetcherImpl::Core::ReceivedContentWasMalformed() {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
@@ skipping 25 matching lines @@
     const std::string& content, bool is_last_chunk) {
   DCHECK(is_chunked_upload_);
   DCHECK(request_.get());
   DCHECK(!content.empty());
   request_->AppendChunkToUpload(content.data(),
                                 static_cast<int>(content.length()),
                                 is_last_chunk);
 }
 
 void URLFetcherImpl::Core::AppendChunkToUpload(const std::string& content,
-                                           bool is_last_chunk) {
+                                               bool is_last_chunk) {
   DCHECK(delegate_loop_proxy_);
   DCHECK(io_message_loop_proxy_.get());
   io_message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&Core::CompleteAddingUploadDataChunk, this, content,
                  is_last_chunk));
 }
 
 // Return true if the write was done and reading may continue.
 // Return false if the write is pending, and the next read will
 // be done later.
 bool URLFetcherImpl::Core::WriteBuffer(int num_bytes) {
   bool write_complete = false;
   switch (response_destination_) {
     case STRING:
       data_.append(buffer_->data(), num_bytes);
       write_complete = true;
       break;
 
-    case TEMP_FILE:
-      temp_file_writer_->WriteBuffer(num_bytes);
+    case FILE:
+      file_writer_->WriteBuffer(num_bytes);
       // WriteBuffer() sends a request the file thread.
       // The write is not done yet.
       write_complete = false;
       break;
 
     default:
       NOTREACHED();
   }
   return write_complete;
 }
 
 void URLFetcherImpl::Core::OnReadCompleted(net::URLRequest* request,
-                                       int bytes_read) {
+                                           int bytes_read) {
   DCHECK(request == request_);
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   url_ = request->url();
   url_throttler_entry_ =
       net::URLRequestThrottlerManager::GetInstance()->RegisterRequestUrl(url_);
 
   bool waiting_on_write = false;
   do {
     if (!request_->status().is_success() || bytes_read <= 0)
@@ skipping 14 matching lines @@
 
   if (status.is_success())
     request_->GetResponseCookies(&cookies_);
 
   // See comments re: HEAD requests in ReadResponse().
   if ((!status.is_io_pending() && !waiting_on_write) ||
       (request_type_ == HEAD)) {
     status_ = status;
     ReleaseRequest();
 
-    // If a temp file is open, close it.
-    if (temp_file_writer_.get()) {
+    // If a file is open, close it.
+    if (file_writer_.get()) {
       // If the file is open, close it.  After closing the file,
       // RetryOrCompleteUrlFetch() will be called.
-      temp_file_writer_->CloseTempFileAndCompleteRequest();
+      file_writer_->CloseFileAndCompleteRequest();
     } else {
       // Otherwise, complete or retry the URL request directly.
       RetryOrCompleteUrlFetch();
     }
   }
 }
 
 void URLFetcherImpl::Core::RetryOrCompleteUrlFetch() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   base::TimeDelta backoff_delay;
 
   // Checks the response from server.
   if (response_code_ >= 500 ||
       status_.error() == net::ERR_TEMPORARILY_THROTTLED) {
     // When encountering a server error, we will send the request again
     // after backoff time.
     ++num_retries_;
 
     // Note that backoff_delay may be 0 because (a) the URLRequestThrottler
     // code does not necessarily back off on the first error, and (b) it
     // only backs off on some of the 5xx status codes.
     base::TimeTicks backoff_release_time = GetBackoffReleaseTime();
     backoff_delay = backoff_release_time - base::TimeTicks::Now();
     if (backoff_delay < base::TimeDelta())
       backoff_delay = base::TimeDelta();
 
-    if (automatically_retry_on_5xx_ &&
-        num_retries_ <= max_retries_) {
+    if (automatically_retry_on_5xx_ && num_retries_ <= max_retries_) {
       StartOnIOThread();
       return;
     }
   } else {
     backoff_delay = base::TimeDelta();
   }
   request_context_getter_ = NULL;
   bool posted = delegate_loop_proxy_->PostTask(
       FROM_HERE, base::Bind(&Core::OnCompletedURLRequest, this, backoff_delay));
 
   // If the delegate message loop does not exist any more, then the delegate
   // should be gone too.
   DCHECK(posted || !delegate_);
 }
 
 void URLFetcherImpl::Core::ReadResponse() {
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
   int bytes_read = 0;
   if (request_->status().is_success() && (request_type_ != HEAD))
     request_->Read(buffer_, kBufferSize, &bytes_read);
   OnReadCompleted(request_.get(), bytes_read);
 }
 
-void URLFetcherImpl::Core::DisownTempFile() {
-  temp_file_writer_->DisownTempFile();
+void URLFetcherImpl::Core::DisownFile() {
+  file_writer_->DisownFile();
 }
 
 void URLFetcherImpl::Core::StartURLRequest() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (was_cancelled_) {
     // Since StartURLRequest() is posted as a *delayed* task, it may
     // run after the URLFetcher was already stopped.
     return;
   }
 
   DCHECK(request_context_getter_);
   DCHECK(!request_.get());
 
   g_registry.Get().AddURLFetcherCore(this);
   current_response_bytes_ = 0;
   request_.reset(new net::URLRequest(original_url_, this));
   int flags = request_->load_flags() | load_flags_;
-  if (!g_interception_enabled) {
+  if (!g_interception_enabled)
     flags = flags | net::LOAD_DISABLE_INTERCEPT;
-  }
+
   if (is_chunked_upload_)
     request_->EnableChunkedUpload();
   request_->set_load_flags(flags);
   request_->set_context(request_context_getter_->GetURLRequestContext());
   request_->set_referrer(referrer_);
 
   switch (request_type_) {
     case GET:
       break;
 
@@ skipping 24 matching lines @@
   }
 
   if (!extra_request_headers_.IsEmpty())
     request_->SetExtraRequestHeaders(extra_request_headers_);
 
   // There might be data left over from a previous request attempt.
   data_.clear();
 
   // If we are writing the response to a file, the only caller
   // of this function should have created it and not written yet.
-  DCHECK(!temp_file_writer_.get() ||
-         temp_file_writer_->total_bytes_written() == 0);
+  DCHECK(!file_writer_.get() || file_writer_->total_bytes_written() == 0);
 
   request_->Start();
 }
 
 void URLFetcherImpl::Core::StartURLRequestWhenAppropriate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (was_cancelled_)
     return;
 
@@ skipping 20 matching lines @@
   if (request_.get()) {
     request_->Cancel();
     ReleaseRequest();
   }
   // Release the reference to the request context. There could be multiple
   // references to URLFetcher::Core at this point so it may take a while to
   // delete the object, but we cannot delay the destruction of the request
   // context.
   request_context_getter_ = NULL;
   was_cancelled_ = true;
-  temp_file_writer_.reset();
+  file_writer_.reset();
 }
 
 void URLFetcherImpl::Core::OnCompletedURLRequest(
     base::TimeDelta backoff_delay) {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
 
   // Save the status and backoff_delay so that delegates can read it.
   if (delegate_) {
     backoff_delay_ = backoff_delay;
     InformDelegateFetchIsComplete();
@@ skipping 10 matching lines @@
 
 void URLFetcherImpl::Core::InformDelegateDownloadProgressInDelegateThread(
     int64 current, int64 total) {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadProgress(fetcher_, current, total);
 }
 
 void URLFetcherImpl::Core::InformDelegateFetchIsComplete() {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
-  if (delegate_) {
+  if (delegate_)
     delegate_->OnURLFetchComplete(fetcher_);
-  }
 }
 
 void URLFetcherImpl::Core::NotifyMalformedContent() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   if (url_throttler_entry_ != NULL) {
     int status_code = response_code_;
     if (status_code == RESPONSE_CODE_INVALID) {
       // The status code will generally be known by the time clients
       // call the |ReceivedContentWasMalformed()| function (which ends up
       // calling the current function) but if it's not, we need to assume
@@ skipping 98 matching lines @@
 }
 
 
 base::TimeDelta URLFetcherImpl::GetBackoffDelay() const {
   return core_->backoff_delay_;
 }
 
 void URLFetcherImpl::SaveResponseToTemporaryFile(
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
   core_->file_message_loop_proxy_ = file_message_loop_proxy;
-  core_->response_destination_ = TEMP_FILE;
+  core_->response_destination_ = FILE;
 }
 
 net::HttpResponseHeaders* URLFetcherImpl::GetResponseHeaders() const {
   return core_->response_headers_;
 }
 
 void URLFetcherImpl::set_response_headers(
     scoped_refptr<net::HttpResponseHeaders> headers) {
   core_->response_headers_ = headers;
 }
@@ skipping 40 matching lines @@
 }
 
 const net::ResponseCookies& URLFetcherImpl::GetCookies() const {
   return core_->cookies_;
 }
 
 bool URLFetcherImpl::FileErrorOccurred(
     base::PlatformFileError* out_error_code) const {
 
   // Can't have a file error if no file is being created or written to.
-  if (!core_->temp_file_writer_.get()) {
+  if (!core_->file_writer_.get())
     return false;
-  }
 
-  base::PlatformFileError error_code = core_->temp_file_writer_->error_code();
+  base::PlatformFileError error_code = core_->file_writer_->error_code();
   if (error_code == base::PLATFORM_FILE_OK)
     return false;
 
   *out_error_code = error_code;
   return true;
 }
 
 void URLFetcherImpl::ReceivedContentWasMalformed() {
   core_->ReceivedContentWasMalformed();
 }
 
 bool URLFetcherImpl::GetResponseAsString(
     std::string* out_response_string) const {
   if (core_->response_destination_ != STRING)
     return false;
 
   *out_response_string = core_->data_;
   UMA_HISTOGRAM_MEMORY_KB("UrlFetcher.StringResponseSize",
                           (core_->data_.length() / 1024));
 
   return true;
 }
 
 bool URLFetcherImpl::GetResponseAsFilePath(bool take_ownership,
                                            FilePath* out_response_path) const {
   DCHECK(core_->delegate_loop_proxy_->BelongsToCurrentThread());
-  if (core_->response_destination_ != TEMP_FILE ||
-      !core_->temp_file_writer_.get())
+  if (core_->response_destination_ != FILE || !core_->file_writer_.get())
     return false;
 
-  *out_response_path = core_->temp_file_writer_->temp_file();
+  *out_response_path = core_->file_writer_->file_path();
 
   if (take_ownership) {
     core_->io_message_loop_proxy_->PostTask(
-        FROM_HERE, base::Bind(&Core::DisownTempFile, core_.get()));
+        FROM_HERE, base::Bind(&Core::DisownFile, core_.get()));
   }
   return true;
 }
 
 // static
 void URLFetcherImpl::CancelAll() {
   Core::CancelAll();
 }
 
 // static
 int URLFetcherImpl::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
 content::URLFetcherDelegate* URLFetcherImpl::delegate() const {
   return core_->delegate();
 }
 
 // static
 content::URLFetcherFactory* URLFetcherImpl::factory() {
   return g_factory;
 }
 
 // static
 void URLFetcherImpl::set_factory(content::URLFetcherFactory* factory) {
   g_factory = factory;
 }