Flesh out URLLoader's download_to_file function....

webkit/tools/test_shell/simple_resource_loader_bridge.cc

 // Copyright (c) 2006-2008 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.
 //
 // This file contains an implementation of the ResourceLoaderBridge class.
 // The class is implemented using URLRequest, meaning it is a "simple" version
 // that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
 // Because URLRequest only provides an asynchronous resource loading API, this
@@ skipping 15 matching lines @@
 //
 // NOTE: The implementation in this file may be used to have WebKit fetch
 // resources in-process.  For example, it is handy for building a single-
 // process WebKit embedding (e.g., test_shell) that can use URLRequest to
 // perform URL loads.  See renderer/resource_dispatcher.h for details on an
 // alternate implementation that defers fetching to another process.
 
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
 #include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #if defined(OS_MACOSX) || defined(OS_WIN)
 #include "base/nss_util.h"
 #endif
 #include "base/ref_counted.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "net/base/cookie_store.h"
+#include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/static_cookie_policy.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_service.h"
 #if defined(OS_WIN)
 #include "net/socket/ssl_client_socket_nss_factory.h"
 #endif
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/blob/blob_storage_controller.h"
 #include "webkit/blob/blob_url_request_job.h"
+#include "webkit/blob/deletable_file_reference.h"
 #include "webkit/glue/resource_loader_bridge.h"
 #include "webkit/tools/test_shell/simple_appcache_system.h"
 #include "webkit/tools/test_shell/simple_socket_stream_bridge.h"
 #include "webkit/tools/test_shell/test_shell_request_context.h"
 #include "webkit/tools/test_shell/test_shell_webblobregistry_impl.h"
 
 using webkit_glue::ResourceLoaderBridge;
 using net::StaticCookiePolicy;
 using net::HttpResponseHeaders;
+using webkit_blob::DeletableFileReference;
 
 namespace {
 
 struct TestShellRequestContextParams {
   TestShellRequestContextParams(
       const FilePath& in_cache_path,
       net::HttpCache::Mode in_cache_mode,
       bool in_no_proxy)
       : cache_path(in_cache_path),
         cache_mode(in_cache_mode),
@@ skipping 83 matching lines @@
 
 struct RequestParams {
   std::string method;
   GURL url;
   GURL first_party_for_cookies;
   GURL referrer;
   std::string headers;
   int load_flags;
   ResourceType::Type request_type;
   int appcache_host_id;
+  bool download_to_file;
   scoped_refptr<net::UploadData> upload;
 };
 
 // The interval for calls to RequestProxy::MaybeUpdateUploadProgress
 static const int kUpdateUploadProgressIntervalMsec = 100;
 
 // The RequestProxy does most of its work on the IO thread.  The Start and
 // Cancel methods are proxied over to the IO thread, where an URLRequest object
 // is instantiated.
 class RequestProxy : public URLRequest::Delegate,
                      public base::RefCountedThreadSafe<RequestProxy> {
  public:
   // Takes ownership of the params.
   RequestProxy()
-      : buf_(new net::IOBuffer(kDataSize)),
+      : download_to_file_(false),
+        buf_(new net::IOBuffer(kDataSize)),
         last_upload_position_(0) {
   }
 
   void DropPeer() {
     peer_ = NULL;
   }
 
   void Start(ResourceLoaderBridge::Peer* peer, RequestParams* params) {
     peer_ = peer;
     owner_loop_ = MessageLoop::current();
@@ skipping 58 matching lines @@
     // race condition).  If the order of the next 2 functions were reversed, the
     // peer could generate new requests in reponse to the received data, which
     // when run on the io thread, could race against this function in doing
     // another InvokeLater.  See bug 769249.
     g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         this, &RequestProxy::AsyncReadData));
 
     peer_->OnReceivedData(buf_copy.get(), bytes_read);
   }
 
+  void NotifyDownloadedData(int bytes_read) {
+    if (!peer_)
+      return;
+
+    // Continue reading more data, see the comment in NotifyReceivedData.
+    g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+        this, &RequestProxy::AsyncReadData));
+
+    peer_->OnDownloadedData(bytes_read);
+  }
+
   void NotifyCompletedRequest(const URLRequestStatus& status,
                               const std::string& security_info,
                               const base::Time& complete_time) {
     if (peer_) {
       peer_->OnCompletedRequest(status, security_info, complete_time);
       DropPeer();  // ensure no further notifications
     }
   }
 
   void NotifyUploadProgress(uint64 position, uint64 size) {
@@ skipping 19 matching lines @@
     request_->set_referrer(params->referrer.spec());
     net::HttpRequestHeaders headers;
     headers.AddHeadersFromString(params->headers);
     request_->SetExtraRequestHeaders(headers);
     request_->set_load_flags(params->load_flags);
     request_->set_upload(params->upload.get());
     request_->set_context(g_request_context);
     SimpleAppCacheSystem::SetExtraRequestInfo(
         request_.get(), params->appcache_host_id, params->request_type);
 
+    download_to_file_ = params->download_to_file;
+    if (download_to_file_) {
+      FilePath path;
+      if (file_util::CreateTemporaryFile(&path)) {
+        downloaded_file_ = DeletableFileReference::GetOrCreate(
+            path, base::MessageLoopProxy::CreateForCurrentThread());
+        file_stream_.Open(
+            path, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE);
+      }
+    }
+
     request_->Start();
 
     if (request_->has_upload() &&
         params->load_flags & net::LOAD_ENABLE_UPLOAD_PROGRESS) {
       upload_progress_timer_.Start(
           base::TimeDelta::FromMilliseconds(kUpdateUploadProgressIntervalMsec),
           this, &RequestProxy::MaybeUpdateUploadProgress);
     }
 
     delete params;
@@ skipping 51 matching lines @@
   }
 
   virtual void OnReceivedResponse(
       const ResourceLoaderBridge::ResponseInfo& info,
       bool content_filtered) {
     owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &RequestProxy::NotifyReceivedResponse, info, content_filtered));
   }
 
   virtual void OnReceivedData(int bytes_read) {
+    if (download_to_file_) {
+      file_stream_.Write(buf_->data(), bytes_read, NULL);
+      owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+          this, &RequestProxy::NotifyDownloadedData, bytes_read));
+      return;
+    }
+
     owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &RequestProxy::NotifyReceivedData, bytes_read));
   }
 
   virtual void OnCompletedRequest(const URLRequestStatus& status,
                                   const std::string& security_info,
                                   const base::Time& complete_time) {
+    if (download_to_file_)
+      file_stream_.Close();
     owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this,
         &RequestProxy::NotifyCompletedRequest,
         status,
         security_info,
         complete_time));
   }
 
   // --------------------------------------------------------------------------
   // URLRequest::Delegate implementation:
@@ skipping 82 matching lines @@
   }
 
   void PopulateResponseInfo(URLRequest* request,
                             ResourceLoaderBridge::ResponseInfo* info) const {
     info->request_time = request->request_time();
     info->response_time = request->response_time();
     info->headers = request->response_headers();
     request->GetMimeType(&info->mime_type);
     request->GetCharset(&info->charset);
     info->content_length = request->GetExpectedContentSize();
+    if (downloaded_file_)
+      info->download_file_path = downloaded_file_->path();
     SimpleAppCacheSystem::GetExtraResponseInfo(
         request,
         &info->appcache_id,
         &info->appcache_manifest_url);
   }
 
   scoped_ptr<URLRequest> request_;
 
+  // Support for request.download_to_file behavior.
+  bool download_to_file_;
+  net::FileStream file_stream_;
+  scoped_refptr<DeletableFileReference> downloaded_file_;
+
   // Size of our async IO data buffers
   static const int kDataSize = 16*1024;
 
   // read buffer for async IO
   scoped_refptr<net::IOBuffer> buf_;
 
   MessageLoop* owner_loop_;
 
   // This is our peer in WebKit (implemented as ResourceHandleInternal). We do
   // not manage its lifetime, and we may only access it from the owner's
@@ skipping 39 matching lines @@
     result_->url = new_url;
   }
 
   virtual void OnReceivedResponse(
       const ResourceLoaderBridge::ResponseInfo& info,
       bool content_filtered) {
     *static_cast<ResourceLoaderBridge::ResponseInfo*>(result_) = info;
   }
 
   virtual void OnReceivedData(int bytes_read) {
-    result_->data.append(buf_->data(), bytes_read);
+    if (download_to_file_)
+      file_stream_.Write(buf_->data(), bytes_read, NULL);
+    else
+      result_->data.append(buf_->data(), bytes_read);
     AsyncReadData();  // read more (may recurse)
   }
 
   virtual void OnCompletedRequest(const URLRequestStatus& status,
                                   const std::string& security_info,
                                   const base::Time& complete_time) {
+    if (download_to_file_)
+      file_stream_.Close();
     result_->status = status;
     event_.Signal();
   }
 
  private:
   ResourceLoaderBridge::SyncLoadResponse* result_;
   base::WaitableEvent event_;
 };
 
 //-----------------------------------------------------------------------------
 
 class ResourceLoaderBridgeImpl : public ResourceLoaderBridge {
  public:
   ResourceLoaderBridgeImpl(
       const webkit_glue::ResourceLoaderBridge::RequestInfo& request_info)
       : params_(new RequestParams),
         proxy_(NULL) {
-    DCHECK(!request_info.download_to_file);  // Not implemented yet!
     params_->method = request_info.method;
     params_->url = request_info.url;
     params_->first_party_for_cookies = request_info.first_party_for_cookies;
     params_->referrer = request_info.referrer;
     params_->headers = request_info.headers;
     params_->load_flags = request_info.load_flags;
     params_->request_type = request_info.request_type;
     params_->appcache_host_id = request_info.appcache_host_id;
+    params_->download_to_file = request_info.download_to_file;
   }
 
   virtual ~ResourceLoaderBridgeImpl() {
     if (proxy_) {
       proxy_->DropPeer();
       // Let the proxy die on the IO thread
       g_io_thread->message_loop()->ReleaseSoon(FROM_HERE, proxy_);
     }
   }
 
@@ skipping 273 matching lines @@
 
 // static
 scoped_refptr<base::MessageLoopProxy>
     SimpleResourceLoaderBridge::GetIoThread() {
   if (!EnsureIOThread()) {
     LOG(DFATAL) << "Failed to create IO thread.";
     return NULL;
   }
   return g_io_thread->message_loop_proxy();
 }