Flesh out URLLoader's download_to_file function....

chrome/browser/renderer_host/redirect_to_file_resource_handler.cc

 // Copyright (c) 2010 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/browser/renderer_host/redirect_to_file_resource_handler.h"
 
 #include "base/file_util.h"
 #include "base/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/task.h"
 #include "chrome/browser/child_process_security_policy.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 #include "chrome/common/resource_response.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/net_errors.h"
+#include "webkit/blob/deletable_file_reference.h"
+
+using webkit_blob::DeletableFileReference;
 
 // TODO(darin): Use the buffer sizing algorithm from AsyncResourceHandler.
 static const int kReadBufSize = 32768;
 
 RedirectToFileResourceHandler::RedirectToFileResourceHandler(
     ResourceHandler* next_handler,
     int process_id,
     ResourceDispatcherHost* host)
     : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       host_(host),
@@ skipping 20 matching lines @@
     ResourceResponse* response,
     bool* defer) {
   return next_handler_->OnRequestRedirected(request_id, new_url, response,
                                             defer);
 }
 
 bool RedirectToFileResourceHandler::OnResponseStarted(
     int request_id,
     ResourceResponse* response) {
   if (response->response_head.status.is_success()) {
-    DCHECK(!file_path_.empty());
-    response->response_head.download_file_path = file_path_;
+    DCHECK(deletable_file_ && !deletable_file_->path().empty());
+    response->response_head.download_file_path = deletable_file_->path();
   }
   return next_handler_->OnResponseStarted(request_id, response);
 }
 
 bool RedirectToFileResourceHandler::OnWillStart(int request_id,
                                                 const GURL& url,
                                                 bool* defer) {
   request_id_ = request_id;
-  if (file_path_.empty()) {
+  if (!deletable_file_) {
     // Defer starting the request until we have created the temporary file.
     // TODO(darin): This is sub-optimal.  We should not delay starting the
     // network request like this.
     *defer = true;
     base::FileUtilProxy::CreateTemporary(
         ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE),
         callback_factory_.NewCallback(
             &RedirectToFileResourceHandler::DidCreateTemporaryFile));
     return true;
   }
@@ skipping 36 matching lines @@
 
   // We use the buffer's offset field to record the end of the buffer.
 
   int new_offset = buf_->offset() + *bytes_read;
   DCHECK(new_offset <= buf_->capacity());
   buf_->set_offset(new_offset);
 
   if (BufIsFull())
     host_->PauseRequest(process_id_, request_id, true);
 
+  if (*bytes_read > 0)
+    next_handler_->OnDataDownloaded(request_id, *bytes_read);
+
   return WriteMore();
 }
 
 bool RedirectToFileResourceHandler::OnResponseCompleted(
     int request_id,
     const URLRequestStatus& status,
     const std::string& security_info) {
   return next_handler_->OnResponseCompleted(request_id, status, security_info);
 }
 
 void RedirectToFileResourceHandler::OnRequestClosed() {
-  next_handler_->OnRequestClosed();
-
-  // The renderer no longer has a WebURLLoader open to this request, so we can
-  // close and unlink the file.
-
   // We require this explicit call to Close since file_stream_ was constructed
   // directly from a PlatformFile.
   file_stream_->Close();
   file_stream_.reset();
+  deletable_file_ = NULL;
 
-  // TODO(dumi): delete the temp file when it's no longer needed.
-  // TODO(dumi): revoke the privilege to upload this file.
-  // base::FileUtilProxy::Delete(
-  //       ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE),
-  //       file_path_, NULL);
+  next_handler_->OnRequestClosed();
 }
 
 RedirectToFileResourceHandler::~RedirectToFileResourceHandler() {
   DCHECK(!file_stream_.get());
 }
 
 void RedirectToFileResourceHandler::DidCreateTemporaryFile(
     base::PlatformFileError /*error_code*/,
     base::PassPlatformFile file_handle,
     FilePath file_path) {
-  file_path_ = file_path;
+  deletable_file_ = DeletableFileReference::GetOrCreate(
+      file_path,
+      ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE));
   file_stream_.reset(new net::FileStream(file_handle.ReleaseValue(),
                                          base::PLATFORM_FILE_WRITE |
                                          base::PLATFORM_FILE_ASYNC));
-  ChildProcessSecurityPolicy::GetInstance()->GrantReadFile(
-      process_id_, file_path);
+  host_->RegisterDownloadedTempFile(
+      process_id_, request_id_, deletable_file_.get());
   host_->StartDeferredRequest(process_id_, request_id_);
 }
 
 void RedirectToFileResourceHandler::DidWriteToFile(int result) {
   write_callback_pending_ = false;
 
   bool failed = false;
   if (result > 0) {
     write_cursor_ += result;
     failed = !WriteMore();
@@ skipping 35 matching lines @@
   }
 }
 
 bool RedirectToFileResourceHandler::BufIsFull() const {
   // This is a hack to workaround BufferedResourceHandler's inability to
   // deal with a ResourceHandler that returns a buffer size of less than
   // 2 * net::kMaxBytesToSniff from its OnWillRead method.
   // TODO(darin): Fix this retardation!
   return buf_->RemainingCapacity() <= (2 * net::kMaxBytesToSniff);
 }