Schetch changes required to support URLFetcher saving response to a file

chrome/common/net/url_fetcher.cc

 // Copyright (c) 2011 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 "chrome/common/net/url_fetcher.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
+#include "base/file_path.h"
+#include "base/file_util_proxy.h"
 #include "base/lazy_instance.h"
+#include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
+#include "base/platform_file.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
+#include "content/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/host_port_pair.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 53 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.
+  class TempFileWriter {
+   public:
+    TempFileWriter(
+        URLFetcher::Core* core,
+        scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy);
+
+    ~TempFileWriter();
+    void CreateTempFile();
+    void DidCreateTemporaryFile(base::PlatformFileError error_code,
+                                base::PassPlatformFile file_handle,
+                                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);
+
+    // Remove any file created.
+    void Destroy();
+
+    const FilePath& temp_file() const { return temp_file_; }
+    int64 total_bytes_written() { return total_bytes_written_; }
+
+   private:
+    // The URLFetcher::Core which instantiated this class.
+    URLFetcher::Core* core_;
+
+    // Callbacks are created for use with base::FileUtilProxy.
+    base::ScopedCallbackFactory<URLFetcher::Core::TempFileWriter>
+        callback_factory_;
+
+    // Message loop on which file opperations 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_;
+
+    // Handle to the temp file.
+    base::PlatformFile temp_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_;
+
+    // When writing, how many bytes from the buffer have been successfully
+    // written so far?
+    int buffer_offset_;
+  };
+
   virtual ~Core();
 
   // Wrapper functions that allow us to ensure actions happen on the right
   // thread.
   void StartURLRequest();
   void StartURLRequestWhenAppropriate();
   void CancelURLRequest();
   void OnCompletedURLRequest(const net::URLRequestStatus& status);
   void NotifyMalformedContent();
 
   // Deletes the request, removes it from the registry, and removes the
   // destruction observer.
   void ReleaseRequest();
 
   // Returns the max value of exponential back-off release time for
   // |original_url_| and |url_|.
   base::TimeTicks GetBackoffReleaseTime();
 
   void CompleteAddingUploadDataChunk(const std::string& data,
                                      bool is_last_chunk);
 
-  // Adds a block of data to be uploaded in a POST body. This can only be called
-  // after Start().
+  // Adds a block of data to be uploaded in a POST body. This can only be
+  // called after Start().
   void AppendChunkToUpload(const std::string& data, bool is_last_chunk);
 
+  // Store the response bytes in |buffer_| in the container indicated by
+  // |fetcher_->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();
+
   URLFetcher* 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?
   URLFetcher::Delegate* delegate_;   // Object to notify on completion
   scoped_refptr<base::MessageLoopProxy> delegate_loop_proxy_;
                                      // Message loop proxy of the creating
                                      // thread.
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
                                      // The message loop proxy for the thread
                                      // on which the request IO happens.
+  scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy_;
+                                     // The message loop proxy for the thread
+                                     // on which file access happens.
   scoped_ptr<net::URLRequest> request_;   // The actual request this wraps
   int load_flags_;                   // Flags for the load operation
   int response_code_;                // HTTP status code for the request
-  std::string data_;                 // Results of the request
+  std::string data_;                 // Results of the request, when we are
+                                     // storing the response as a string.
   scoped_refptr<net::IOBuffer> buffer_;
                                      // Read buffer
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
                                      // Cookie/cache info for the request
   net::ResponseCookies cookies_;     // Response cookies
   net::HttpRequestHeaders extra_request_headers_;
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
   bool was_fetched_via_proxy_;
   net::HostPortPair socket_address_;
 
@@ skipping 20 matching lines @@
   // specified by the owner URLFetcher instance, we'll give up.
   int num_retries_;
 
   // True if the URLFetcher has been cancelled.
   bool was_cancelled_;
 
   // Since GetBackoffReleaseTime() can only be called on the IO thread, we cache
   // its value to be used by OnCompletedURLRequest on the creating thread.
   base::TimeTicks backoff_release_time_;
 
+  // If writing results to a file, |temp_file_writer_| will manage creation,
+  // writing, and destruction of that file.
+  scoped_ptr<TempFileWriter> temp_file_writer_;
+
   static base::LazyInstance<Registry> g_registry;
 
   friend class URLFetcher;
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 URLFetcher::Core::Registry::Registry() {}
 URLFetcher::Core::Registry::~Registry() {}
 
 void URLFetcher::Core::Registry::AddURLFetcherCore(Core* core) {
   DCHECK(!ContainsKey(fetchers_, core));
   fetchers_.insert(core);
 }
 
 void URLFetcher::Core::Registry::RemoveURLFetcherCore(Core* core) {
   DCHECK(ContainsKey(fetchers_, core));
   fetchers_.erase(core);
 }
 
 void URLFetcher::Core::Registry::CancelAll() {
   while (!fetchers_.empty())
     (*fetchers_.begin())->CancelURLRequest();
 }
 
 // static
 base::LazyInstance<URLFetcher::Core::Registry>
     URLFetcher::Core::g_registry(base::LINKER_INITIALIZED);
 
+URLFetcher::Core::TempFileWriter::TempFileWriter(
+    URLFetcher::Core* core,
+    scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy)
+    : core_(core),
+      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      file_message_loop_proxy_(file_message_loop_proxy) {
+}
+
+URLFetcher::Core::TempFileWriter::~TempFileWriter() {
+  Destroy();
+}
+
+void URLFetcher::Core::TempFileWriter::CreateTempFile() {
+  CHECK(file_message_loop_proxy_.get());
+  base::FileUtilProxy::CreateTemporary(
+      file_message_loop_proxy_,
+      callback_factory_.NewCallback(
+          &URLFetcher::Core::TempFileWriter::DidCreateTemporaryFile));
+}
+
+void URLFetcher::Core::TempFileWriter::DidCreateTemporaryFile(
+    base::PlatformFileError error_code,
+    base::PassPlatformFile file_handle,
+    FilePath file_path) {
+  if (base::PLATFORM_FILE_OK != error_code) {
+    core_->delegate_->OnFileWriteError(core_->fetcher_,
+                                       core_->url_,
+                                       error_code);
+    return;
+  }
+
+  temp_file_handle_ = file_handle.ReleaseValue();
+  temp_file_ = file_path;
+  total_bytes_written_ = 0;
+
+  core_->io_message_loop_proxy_->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(core_, &Core::StartURLRequestWhenAppropriate));
+
+}
+
+void URLFetcher::Core::TempFileWriter::WriteBuffer(int num_bytes) {
+  // Start writing to the temp 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 URLFetcher::Core::TempFileWriter::ContinueWrite(
+    base::PlatformFileError error_code,
+    int bytes_written) {
+  if (base::PLATFORM_FILE_OK != error_code) {
+    core_->delegate_->OnFileWriteError(core_->fetcher_,
+                                       core_->url_,
+                                       error_code);
+    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_,
+        total_bytes_written_,  // Append
+        (core_->buffer_->data() + buffer_offset_),
+        pending_bytes_,
+        callback_factory_.NewCallback(
+            &URLFetcher::Core::TempFileWriter::ContinueWrite));
+  } else {
+    // Finished writing core_->buffer_ to the file. Read some more.
+    core_->ReadResponse();
+  }
+}
+
+void URLFetcher::Core::TempFileWriter::Destroy() {
+  if (!temp_file_.empty()) {
+    base::FileUtilProxy::Delete(
+        file_message_loop_proxy_,
+        temp_file_,
+        false,  // No need to recurse, as the path is to a file.
+        NULL);  // No callback.
+  }
+  temp_file_ = FilePath();
+}
+
 // static
 URLFetcher::Factory* URLFetcher::factory_ = NULL;
 
+void URLFetcher::Delegate::OnURLFetchComplete(
+    const URLFetcher* source,
+    const GURL& url,
+    const net::URLRequestStatus& status,
+    int response_code,
+    const net::ResponseCookies& cookies,
+    const std::string& data) {
+  NOTREACHED() << "If you don't implemnt this, the no-data version "
+               << "should also be implemented, in which case this "
+               << "method won't be called...";
+}
+
+// TODO(skerner): This default implementation will be removed, and the
+// method made pure virtual, once all users of URLFetcher are updated
+// to not expect response data as a string argument.
+void URLFetcher::Delegate::OnURLFetchComplete(
+    const URLFetcher* source,
+    const GURL& url,
+    const net::URLRequestStatus& status,
+    int response_code,
+    const net::ResponseCookies& cookies) {
+
+  std::string data;
+  CHECK(source->GetResponseAsString(&data));
+
+  // To avoid updating all callers, thunk to the old prototype for now.
+  OnURLFetchComplete(source, url, status, response_code, cookies, data);
+}
+
+void URLFetcher::Delegate::OnFileWriteError(const URLFetcher* source,
+                                            const GURL& url,
+                                            base::PlatformFileError error) {
+  NOTREACHED()
+      << "If you set the response destination to TEMP_FILE, "
+      << "you need to implement  URLFetcher::Delegate::OnFileWriteError()";
+}
+
 // static
 bool URLFetcher::g_interception_enabled = false;
 
 URLFetcher::URLFetcher(const GURL& url,
                        RequestType request_type,
                        Delegate* d)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
       core_(new Core(this, url, request_type, d))),
       automatically_retry_on_5xx_(true),
-      max_retries_(0) {
+      max_retries_(0),
+      response_destination_(STRING) {
 }
 
 URLFetcher::~URLFetcher() {
   core_->Stop();
 }
 
 // static
 URLFetcher* URLFetcher::Create(int id, const GURL& url,
                                RequestType request_type, Delegate* d) {
   return factory_ ? factory_->CreateURLFetcher(id, url, request_type, d) :
                     new URLFetcher(url, request_type, d);
 }
 
 URLFetcher::Core::Core(URLFetcher* fetcher,
                        const GURL& original_url,
                        RequestType request_type,
                        URLFetcher::Delegate* d)
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
-      delegate_loop_proxy_(base::MessageLoopProxy::CreateForCurrentThread()),
+      delegate_loop_proxy_(
+          base::MessageLoopProxy::CreateForCurrentThread()),
       request_(NULL),
       load_flags_(net::LOAD_NORMAL),
       response_code_(-1),
       buffer_(new net::IOBuffer(kBufferSize)),
       is_chunked_upload_(false),
       num_retries_(0),
       was_cancelled_(false) {
 }
 
 URLFetcher::Core::~Core() {
   // |request_| should be NULL.  If not, it's unsafe to delete it here since we
   // may not be on the IO thread.
   DCHECK(!request_.get());
 }
 
 void URLFetcher::Core::Start() {
   DCHECK(delegate_loop_proxy_);
   CHECK(request_context_getter_) << "We need an URLRequestContext!";
+
   io_message_loop_proxy_ = request_context_getter_->GetIOMessageLoopProxy();
   CHECK(io_message_loop_proxy_.get()) << "We need an IO message loop proxy";
 
-  io_message_loop_proxy_->PostTask(
-      FROM_HERE,
-      NewRunnableMethod(this, &Core::StartURLRequestWhenAppropriate));
+  switch (fetcher_->response_destination()) {
+    case STRING:
+      io_message_loop_proxy_->PostTask(
+          FROM_HERE,
+          NewRunnableMethod(this, &Core::StartURLRequestWhenAppropriate));
+      break;
+
+    case TEMP_FILE:
+      CHECK(file_message_loop_proxy_.get())
+          << "Need to set the file message loop proxy.";
+
+      temp_file_writer_.reset(
+          new TempFileWriter(this, file_message_loop_proxy_));
+
+      // CreateTempFile() will invoke Core::StartURLRequestWhenAppropriate
+      // once the file is created.
+      temp_file_writer_->CreateTempFile();
+
+      break;
+
+    default:
+      NOTREACHED();
+  }
 }
 
 void URLFetcher::Core::Stop() {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
   delegate_ = NULL;
   fetcher_ = NULL;
   if (io_message_loop_proxy_.get()) {
     io_message_loop_proxy_->PostTask(
         FROM_HERE, NewRunnableMethod(this, &Core::CancelURLRequest));
   }
@@ skipping 14 matching lines @@
 void URLFetcher::Core::OnResponseStarted(net::URLRequest* request) {
   DCHECK_EQ(request, request_.get());
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   if (request_->status().is_success()) {
     response_code_ = request_->GetResponseCode();
     response_headers_ = request_->response_headers();
     socket_address_ = request_->GetSocketAddress();
     was_fetched_via_proxy_ = request_->was_fetched_via_proxy();
   }
 
-  int bytes_read = 0;
-  // 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).
-  if (request_->status().is_success() && (request_type_ != HEAD))
-    request_->Read(buffer_, kBufferSize, &bytes_read);
-  OnReadCompleted(request_.get(), bytes_read);
+  ReadResponse();
 }
 
 void URLFetcher::Core::CompleteAddingUploadDataChunk(
     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 URLFetcher::Core::AppendChunkToUpload(const std::string& content,
                                            bool is_last_chunk) {
   DCHECK(delegate_loop_proxy_);
   CHECK(io_message_loop_proxy_.get());
   io_message_loop_proxy_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &Core::CompleteAddingUploadDataChunk, 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 URLFetcher::Core::WriteBuffer(int num_bytes) {
+  bool write_complete = false;
+  switch (fetcher_->response_destination_) {
+    case STRING:
+      data_.append(buffer_->data(), num_bytes);
+      write_complete = true;
+      break;
+
+    case TEMP_FILE:
+      temp_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 URLFetcher::Core::OnReadCompleted(net::URLRequest* request,
                                        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)
       break;
-    data_.append(buffer_->data(), bytes_read);
+
+    if (!WriteBuffer(bytes_read)) {
+      // If WriteBuffer() returns false, we have a pending write to
+      // wait on before reading further.
+      waiting_on_write = true;
+      break;
+    }
   } while (request_->Read(buffer_, kBufferSize, &bytes_read));
 
   if (request_->status().is_success())
     request_->GetResponseCookies(&cookies_);
 
-  // See comments re: HEAD requests in OnResponseStarted().
-  if (!request_->status().is_io_pending() || (request_type_ == HEAD)) {
+  // See comments re: HEAD requests in ReadResponse().
+  if ((!request_->status().is_io_pending() && !waiting_on_write) ||
+      (request_type_ == HEAD)) {
     backoff_release_time_ = GetBackoffReleaseTime();
 
     bool posted = delegate_loop_proxy_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this,
                           &Core::OnCompletedURLRequest,
                           request_->status()));
     // If the delegate message loop does not exist any more, then the delegate
     // should be gone too.
     DCHECK(posted || !delegate_);
     ReleaseRequest();
   }
 }
 
+void URLFetcher::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 URLFetcher::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;
   }
 
   CHECK(request_context_getter_);
@@ skipping 35 matching lines @@
     default:
       NOTREACHED();
   }
 
   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.
+  CHECK(!temp_file_writer_.get() ||
+        temp_file_writer_->total_bytes_written() == 0);
+
   request_->Start();
 }
 
 void URLFetcher::Core::StartURLRequestWhenAppropriate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (was_cancelled_)
     return;
 
   if (original_url_throttler_entry_ == NULL) {
@@ 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();
 }
 
 void URLFetcher::Core::OnCompletedURLRequest(
     const net::URLRequestStatus& status) {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
 
   // Checks the response from server.
   if (response_code_ >= 500 ||
       status.os_error() == net::ERR_TEMPORARILY_THROTTLED) {
     // When encountering a server error, we will send the request again
     // after backoff time.
     ++num_retries_;
     // Restarts the request if we still need to notify the delegate.
     if (delegate_) {
       fetcher_->backoff_delay_ = backoff_release_time_ - base::TimeTicks::Now();
       if (fetcher_->backoff_delay_ < base::TimeDelta())
         fetcher_->backoff_delay_ = base::TimeDelta();
 
       if (fetcher_->automatically_retry_on_5xx_ &&
           num_retries_ <= fetcher_->max_retries()) {
         io_message_loop_proxy_->PostTask(
             FROM_HERE,
             NewRunnableMethod(this, &Core::StartURLRequestWhenAppropriate));
       } else {
-        delegate_->OnURLFetchComplete(fetcher_, url_, status, response_code_,
-                                      cookies_, data_);
+        delegate_->OnURLFetchComplete(
+            fetcher_, url_, status, response_code_, cookies_);
       }
     }
   } else {
     if (delegate_) {
       fetcher_->backoff_delay_ = base::TimeDelta();
-      delegate_->OnURLFetchComplete(fetcher_, url_, status, response_code_,
-                                    cookies_, data_);
+      delegate_->OnURLFetchComplete(
+          fetcher_, url_, status, response_code_, cookies_);
     }
   }
 }
 
 void URLFetcher::Core::NotifyMalformedContent() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   if (url_throttler_entry_ != NULL)
     url_throttler_entry_->ReceivedContentWasMalformed();
 }
 
@@ skipping 61 matching lines @@
     const std::string& extra_request_headers) {
   core_->extra_request_headers_.Clear();
   core_->extra_request_headers_.AddHeadersFromString(extra_request_headers);
 }
 
 void URLFetcher::set_request_context(
     net::URLRequestContextGetter* request_context_getter) {
   core_->request_context_getter_ = request_context_getter;
 }
 
+void URLFetcher::set_file_message_loop_proxy(
+    scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
+  core_->file_message_loop_proxy_ = file_message_loop_proxy;
+}
+
 void URLFetcher::set_automatically_retry_on_5xx(bool retry) {
   automatically_retry_on_5xx_ = retry;
 }
 
 net::HttpResponseHeaders* URLFetcher::response_headers() const {
   return core_->response_headers_;
 }
 
 // TODO(panayiotis): socket_address_ is written in the IO thread,
 // if this is accessed in the UI thread, this could result in a race.
@@ skipping 11 matching lines @@
 }
 
 const GURL& URLFetcher::url() const {
   return core_->url_;
 }
 
 void URLFetcher::ReceivedContentWasMalformed() {
   core_->ReceivedContentWasMalformed();
 }
 
+bool URLFetcher::GetResponseAsString(std::string* response_string) const {
+  if (response_destination_ != STRING)
+    return false;
+
+  *response_string = core_->data_;
+  return true;
+}
+
+bool URLFetcher::GetResponseAsFilePath(FilePath* response_path) const {
+  if (response_destination_ != TEMP_FILE || !core_->temp_file_writer_.get())
+    return false;
+
+  *response_path = core_->temp_file_writer_->temp_file();
+  return true;
+}
+
 // static
 void URLFetcher::CancelAll() {
   Core::CancelAll();
 }
 
 // static
 int URLFetcher::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }