Add URLFetcher::SaveResponseToFileAtPath

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 82 matching lines @@
       return fetchers_.size();
     }
 
    private:
     std::set<Core*> fetchers_;
 
     DISALLOW_COPY_AND_ASSIGN(Registry);
   };
 
   // Class FileWriter encapsulates all state involved in writing response bytes
-  // to a file. It is only used if |Core::response_destination_| == FILE.
+  // to a file. It is only used if |Core::response_destination_| == TEMP_FILE ||
+  // |Core::response_destination_| == PERMANENT_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 FileWriter {
    public:
     FileWriter(URLFetcherImpl::Core* core,
                scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy);
 
     ~FileWriter();
+    void CreateFileAtPath(const FilePath& file_path);
+    void DidCreateFile(const FilePath& file_path,
+                       base::PlatformFileError error_code,
+                       base::PassPlatformFile file_handle,
+                       bool created);
     void CreateTempFile();
     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_.
@@ skipping 152 matching lines @@
   // True if the URLFetcher has been cancelled.
   bool was_cancelled_;
 
   // If writing results to a file, |file_writer_| will manage creation,
   // writing, and destruction of that file.
   scoped_ptr<FileWriter> file_writer_;
 
   // Where should responses be saved?
   ResponseDestinationType response_destination_;
 
+  // Path to the file where the response is written.
+  FilePath response_destination_file_path_;
+
   // 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.
   int max_retries_;
   // Back-off time delay. 0 by default.
   base::TimeDelta backoff_delay_;
 
@@ skipping 37 matching lines @@
       error_code_(base::PLATFORM_FILE_OK),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       file_message_loop_proxy_(file_message_loop_proxy),
       file_handle_(base::kInvalidPlatformFileValue) {
 }
 
 URLFetcherImpl::Core::FileWriter::~FileWriter() {
   RemoveFile();
 }
 
-void URLFetcherImpl::Core::FileWriter::CreateTempFile() {
+void URLFetcherImpl::Core::FileWriter::CreateFileAtPath(
+    const FilePath& file_path) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(file_message_loop_proxy_.get());
-  base::FileUtilProxy::CreateTemporary(
+  base::FileUtilProxy::CreateOrOpen(
       file_message_loop_proxy_,
-      0,  // No additional file flags.
-      base::Bind(&URLFetcherImpl::Core::FileWriter::DidCreateTempFile,
-                 weak_factory_.GetWeakPtr()));
+      file_path,
+      base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE,
+      base::Bind(&URLFetcherImpl::Core::FileWriter::DidCreateFile,
+                 weak_factory_.GetWeakPtr(),
+                 file_path));
 }
 
-void URLFetcherImpl::Core::FileWriter::DidCreateTempFile(
+void URLFetcherImpl::Core::FileWriter::DidCreateFile(
+    const FilePath& file_path,
     base::PlatformFileError error_code,
     base::PassPlatformFile file_handle,
-    const FilePath& file_path) {
+    bool created) {

[willchan no longer on Chromium, 2012/03/08 16:38:39]

Is this just ignored? It's sorta weird that DidCreateTempFile() is calling
DidCreateFile() with kCreated = true, when created is just ignored.

[hashimoto, 2012/03/09 03:22:52]

Added DidCreateFileInternal

   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
     RemoveFile();
     core_->delegate_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   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::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::FileWriter::DidCreateTempFile,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void URLFetcherImpl::Core::FileWriter::DidCreateTempFile(
+    base::PlatformFileError error_code,
+    base::PassPlatformFile file_handle,
+    const FilePath& file_path) {
+  const bool kCreated = true;
+  DidCreateFile(file_path, error_code, file_handle, kCreated);
+}
+
 void URLFetcherImpl::Core::FileWriter::WriteBuffer(int num_bytes) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   // 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);
 }
@@ skipping 192 matching lines @@
 }
 
 void URLFetcherImpl::Core::StartOnIOThread() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   switch (response_destination_) {
     case STRING:
       StartURLRequestWhenAppropriate();
       break;
 
-    case FILE:
+    case PERMANENT_FILE:
+    case TEMP_FILE:
       DCHECK(file_message_loop_proxy_.get())
           << "Need to set the file message loop proxy.";
 
-      file_writer_.reset(
-          new FileWriter(this, file_message_loop_proxy_));
+      file_writer_.reset(new FileWriter(this, file_message_loop_proxy_));
 
-      // If the temp file is successfully created,
+      // If the file is successfully created,
       // Core::StartURLRequestWhenAppropriate() will be called.
-      file_writer_->CreateTempFile();
+      switch (response_destination_) {
+        case PERMANENT_FILE:
+          file_writer_->CreateFileAtPath(response_destination_file_path_);
+          break;
+        case TEMP_FILE:
+          file_writer_->CreateTempFile();
+          break;
+        default:
+          NOTREACHED();
+      }
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void URLFetcherImpl::Core::Stop() {
   if (delegate_loop_proxy_)  // May be NULL in tests.
     DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
@@ skipping 56 matching lines @@
 // 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 FILE:
+    case PERMANENT_FILE:
+    case TEMP_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;
@@ skipping 342 matching lines @@
 
 int URLFetcherImpl::GetMaxRetries() const {
   return core_->max_retries_;
 }
 
 
 base::TimeDelta URLFetcherImpl::GetBackoffDelay() const {
   return core_->backoff_delay_;
 }
 
+void URLFetcherImpl::SaveResponseToFileAtPath(
+    const FilePath& file_path,
+    scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
+  core_->file_message_loop_proxy_ = file_message_loop_proxy;

[willchan no longer on Chromium, 2012/03/08 16:38:39]

Please DCHECK that this executes on the delegate message loop. Same with the
SaveResponseToTemporaryFile(). It'd be great to DCHECK() that Start() hasn't
been called yet too, but I don't see a good way to do that.

[hashimoto, 2012/03/09 03:22:52]

Done.
Can we do this in another change?
Maybe we should have a bool member in |core_| to remember if Start() was already
called?

+  core_->response_destination_ = PERMANENT_FILE;
+  core_->response_destination_file_path_ = file_path;
+}
+
 void URLFetcherImpl::SaveResponseToTemporaryFile(
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
   core_->file_message_loop_proxy_ = file_message_loop_proxy;
-  core_->response_destination_ = FILE;
+  core_->response_destination_ = TEMP_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 70 matching lines @@
   *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_ != FILE || !core_->file_writer_.get())
+  const bool destination_is_file = core_->response_destination_ == TEMP_FILE ||
+      core_->response_destination_ == PERMANENT_FILE;
+  if (!destination_is_file || !core_->file_writer_.get())
     return false;
 
   *out_response_path = core_->file_writer_->file_path();
 
   if (take_ownership) {
     core_->io_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::DisownFile, core_.get()));
   }
   return true;
 }
@@ skipping 14 matching lines @@
 
 // static
 content::URLFetcherFactory* URLFetcherImpl::factory() {
   return g_factory;
 }
 
 // static
 void URLFetcherImpl::set_factory(content::URLFetcherFactory* factory) {
   g_factory = factory;
 }