Deletable file references.

chrome/browser/renderer_host/resource_dispatcher_host.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
@@ skipping 53 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/appcache/appcache_interceptor.h"
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/blob/blob_storage_controller.h"
+#include "webkit/blob/deletable_file_reference.h"
 
 // TODO(oshima): Enable this for other platforms.
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/renderer_host/offline_resource_handler.h"
 #endif
 
 // Uncomment to enable logging of request traffic.
 // #define LOG_RESOURCE_DISPATCHER_REQUESTS
 
 #ifdef LOG_RESOURCE_DISPATCHER_REQUESTS
 # define RESOURCE_LOG(stuff) LOG(INFO) << stuff
 #else
 # define RESOURCE_LOG(stuff)
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
+using webkit_blob::DeletableFileReference;
 
 // ----------------------------------------------------------------------------
 
 // A ShutdownTask proxies a shutdown task from the UI thread to the IO thread.
 // It should be constructed on the UI thread and run in the IO thread.
 class ResourceDispatcherHost::ShutdownTask : public Task {
  public:
   explicit ShutdownTask(ResourceDispatcherHost* resource_dispatcher_host)
       : rdh_(resource_dispatcher_host) {
   }
@@ skipping 212 matching lines @@
     return socket_stream_dispatcher_host_->OnMessageReceived(
         message, receiver, message_was_ok);
   }
 
   *message_was_ok = true;
   receiver_ = receiver;
 
   IPC_BEGIN_MESSAGE_MAP_EX(ResourceDispatcherHost, message, *message_was_ok)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RequestResource, OnRequestResource)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_SyncLoad, OnSyncLoad)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_ResourceLoaderDeleted,
+                        OnResourceLoaderDeleted)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DataReceived_ACK, OnDataReceivedACK)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DataDownloaded_ACK, OnDataDownloadedACK)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UploadProgress_ACK, OnUploadProgressACK)
     IPC_MESSAGE_HANDLER(ViewHostMsg_CancelRequest, OnCancelRequest)
     IPC_MESSAGE_HANDLER(ViewHostMsg_FollowRedirect, OnFollowRedirect)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ClosePage_ACK, OnClosePageACK)
   IPC_END_MESSAGE_MAP_EX()
 
   receiver_ = NULL;
 
   return true;
 }
@@ skipping 33 matching lines @@
   if (!context) {
     URLRequestContextGetter* context_getter =
         Profile::GetDefaultRequestContext();
     if (context_getter) {
       context = static_cast<ChromeURLRequestContext*>(
           context_getter->GetURLRequestContext());
     }
   }
 
   // Might need to resolve the blob references in the upload data.
-  if (request_data.upload_data) {
+  if (request_data.upload_data && context) {
     context->blob_storage_context()->controller()->
         ResolveBlobReferencesInUploadData(request_data.upload_data.get());
   }
 
   if (is_shutdown_ ||
       !ShouldServiceRequest(process_type, child_id, request_data)) {
     URLRequestStatus status(URLRequestStatus::FAILED, net::ERR_ABORTED);
     if (sync_result) {
       SyncLoadResult result;
       result.status = status;
@@ skipping 27 matching lines @@
                                       this);
   } else {
     handler = new AsyncResourceHandler(receiver_,
                                        child_id,
                                        route_id,
                                        receiver_->handle(),
                                        request_data.url,
                                        this);
   }
 
+  // The RedirectToFileResourceHandler depends on being next in the chain.
   if (request_data.download_to_file)
     handler = new RedirectToFileResourceHandler(handler, child_id, this);
 
   if (HandleExternalProtocol(request_id, child_id, route_id,
                              request_data.url, request_data.resource_type,
                              handler)) {
     return;
   }
 
   // Construct the request.
@@ skipping 74 matching lines @@
           false,  // is download
           ResourceType::IsFrame(request_data.resource_type), // allow_download
           request_data.host_renderer_id,
           request_data.host_render_view_id);
   ApplyExtensionLocalizationFilter(request_data.url, request_data.resource_type,
                                    extra_info);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
   chrome_browser_net::SetOriginProcessUniqueIDForRequest(
       request_data.origin_child_id, request);
 
+  if (request->url().SchemeIs(chrome::kBlobScheme) && context) {
+    // Hang on to a reference to ensure the blob is not released prior
+    // to the job being started.
+    webkit_blob::BlobStorageController* controller =
+        context->blob_storage_context()->controller();
+    extra_info->set_requested_blob_data(
+        controller->GetBlobDataFromUrl(request->url()));
+  }
+
   // Have the appcache associate its extra info with the request.
   appcache::AppCacheInterceptor::SetExtraRequestInfo(
       request, context ? context->appcache_service() : NULL, child_id,
       request_data.appcache_host_id, request_data.resource_type);
 
   BeginRequestInternal(request);
 }
 
+void ResourceDispatcherHost::OnResourceLoaderDeleted(int request_id) {
+  DCHECK(pending_requests_.end() ==
+         pending_requests_.find(GlobalRequestID(receiver_->id(), request_id)));
+  UnregisterDownloadedTempFile(receiver_->id(), request_id);
+}
+
 void ResourceDispatcherHost::OnDataReceivedACK(int request_id) {
   DataReceivedACK(receiver_->id(), request_id);
 }
 
 void ResourceDispatcherHost::DataReceivedACK(int child_id,
                                              int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_requests_.end())
     return;
 
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
 
   // Decrement the number of pending data messages.
   info->DecrementPendingDataCount();
 
   // If the pending data count was higher than the max, resume the request.
   if (info->pending_data_count() == kMaxPendingDataMessages) {
     // Decrement the pending data count one more time because we also
     // incremented it before pausing the request.
     info->DecrementPendingDataCount();
 
     // Resume the request.
     PauseRequest(child_id, request_id, false);
   }
 }
 
+void ResourceDispatcherHost::OnDataDownloadedACK(int request_id) {
+  // TODO(michaeln): maybe throttle DataDownloaded messages
+}
+
+void ResourceDispatcherHost::RegisterDownloadedTempFile(
+    int receiver_id, int request_id, DeletableFileReference* reference) {
+  // Note: receiver_id is the child_id is the render_process_id...
+  registered_temp_files_[receiver_id][request_id] = reference;
+  ChildProcessSecurityPolicy::GetInstance()->GrantUploadFile(
+      receiver_id, reference->path());
+}
+
+void ResourceDispatcherHost::UnregisterDownloadedTempFile(
+    int receiver_id, int request_id) {
+  DeletableFilesMap& map = registered_temp_files_[receiver_id];
+  DeletableFilesMap::iterator found = map.find(request_id);
+  if (found == map.end())
+    return;
+  map.erase(found);
+  // TODO(michaeln): revoke access to this file upon the file's deletion.
+}
+
+
 bool ResourceDispatcherHost::Send(IPC::Message* message) {
   delete message;
   return false;
 }
 
 void ResourceDispatcherHost::OnUploadProgressACK(int request_id) {
   int child_id = receiver_->id();
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_requests_.end())
@@ skipping 275 matching lines @@
   return (entry == outstanding_requests_memory_cost_map_.end()) ?
       0 : entry->second;
 }
 
 // The object died, so cancel and detach all requests associated with it except
 // for downloads, which belong to the browser process even if initiated via a
 // renderer.
 void ResourceDispatcherHost::CancelRequestsForProcess(int child_id) {
   socket_stream_dispatcher_host_->CancelRequestsForProcess(child_id);
   CancelRequestsForRoute(child_id, -1 /* cancel all */);
+  registered_temp_files_.erase(child_id);
 }
 
 void ResourceDispatcherHost::CancelRequestsForRoute(int child_id,
                                                     int route_id) {
   // Since pending_requests_ is a map, we first build up a list of all of the
   // matching requests to be cancelled, and then we cancel them.  Since there
   // may be more than one request to cancel, we cannot simply hold onto the map
   // iterators found in the first loop.
 
   // Find the global ID of all matching elements.
@@ skipping 931 matching lines @@
 }
 
 // static
 bool ResourceDispatcherHost::IsResourceDispatcherHostMessage(
     const IPC::Message& message) {
   switch (message.type()) {
     case ViewHostMsg_RequestResource::ID:
     case ViewHostMsg_CancelRequest::ID:
     case ViewHostMsg_FollowRedirect::ID:
     case ViewHostMsg_ClosePage_ACK::ID:
+    case ViewHostMsg_ResourceLoaderDeleted::ID:
     case ViewHostMsg_DataReceived_ACK::ID:
-    case ViewHostMsg_DownloadProgress_ACK::ID:
+    case ViewHostMsg_DataDownloaded_ACK::ID:
     case ViewHostMsg_UploadProgress_ACK::ID:
     case ViewHostMsg_SyncLoad::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }
@@ skipping 68 matching lines @@
   return is_prefetch_enabled_;
 }
 
 // static
 void ResourceDispatcherHost::set_is_prefetch_enabled(bool value) {
   is_prefetch_enabled_ = value;
 }
 
 // static
 bool ResourceDispatcherHost::is_prefetch_enabled_ = false;