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 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_.
     void ContinueWrite(base::PlatformFileError error_code, int bytes_written);
 
     // Drop ownership of the file at |file_path_|.
     // This class will not delete it or write to it again.
     void DisownFile();
 
     // Close the file if it is open.
     void CloseFileAndCompleteRequest();
 
     // Remove the file if we have created one.
     void RemoveFile();
 
     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 a permanent file creation.
+    void DidCreateFile(const FilePath& file_path,
+                       base::PlatformFileError error_code,
+                       base::PassPlatformFile file_handle,
+                       bool created);
+    // Callback which gets the result of a temporary file creation.
+    void DidCreateTempFile(base::PlatformFileError error_code,
+                           base::PassPlatformFile file_handle,
+                           const FilePath& file_path);
+    // This method is used to implement DidCreateFile and DidCreateTempFile.
+    void DidCreateFileInternal(const FilePath& file_path,
+                               base::PlatformFileError error_code,
+                               base::PassPlatformFile file_handle);
+
     // 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_;
 
@@ skipping 125 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::CreateFileAtPath(
+    const FilePath& file_path) {
+  DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(file_message_loop_proxy_.get());
+  base::FileUtilProxy::CreateOrOpen(
+      file_message_loop_proxy_,
+      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::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) {
-  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::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 59 matching lines @@
 
   if (file_handle_ != base::kInvalidPlatformFileValue) {
     base::FileUtilProxy::Close(
         file_message_loop_proxy_, file_handle_,
         base::Bind(&URLFetcherImpl::Core::FileWriter::DidCloseFile,
                    weak_factory_.GetWeakPtr()));
     file_handle_ = base::kInvalidPlatformFileValue;
   }
 }
 
+void URLFetcherImpl::Core::FileWriter::DidCreateFile(
+    const FilePath& file_path,
+    base::PlatformFileError error_code,
+    base::PassPlatformFile file_handle,
+    bool created) {
+  DidCreateFileInternal(file_path, error_code, file_handle);
+}
+
+void URLFetcherImpl::Core::FileWriter::DidCreateTempFile(
+    base::PlatformFileError error_code,
+    base::PassPlatformFile file_handle,
+    const FilePath& file_path) {
+  DidCreateFileInternal(file_path, error_code, file_handle);
+}
+
+void URLFetcherImpl::Core::FileWriter::DidCreateFileInternal(
+    const FilePath& file_path,
+    base::PlatformFileError error_code,
+    base::PassPlatformFile file_handle) {
+  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::DidCloseFile(
     base::PlatformFileError error_code) {
   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;
@@ skipping 113 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) {
+  DCHECK(core_->delegate_loop_proxy_->BelongsToCurrentThread());
+  core_->file_message_loop_proxy_ = file_message_loop_proxy;
+  core_->response_destination_ = PERMANENT_FILE;
+  core_->response_destination_file_path_ = file_path;
+}
+
 void URLFetcherImpl::SaveResponseToTemporaryFile(
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
+  DCHECK(core_->delegate_loop_proxy_->BelongsToCurrentThread());
   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;
 }