Fail when uploading blob is non-existant

content/browser/loader/resource_dispatcher_host_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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <stddef.h>
 
@@ skipping 1139 matching lines @@
 
   if (is_shutdown_ ||
       !ShouldServiceRequest(child_id, request_data, headers, requester_info,
                             resource_context)) {
     AbortRequestBeforeItStarts(requester_info->filter(), sync_result_handler,
                                request_id, std::move(url_loader_client));
     return;
   }
 
   if (!is_navigation_stream_request) {
+    storage::BlobStorageContext* blob_context =
+        GetBlobStorageContext(requester_info->blob_storage_context());
+    // Resolve elements from request_body and prepare upload data.
+    if (request_data.request_body.get()) {
+      // |blob_context| could be null when the request is from the plugins
+      // because ResourceMessageFilters created in PluginProcessHost don't have
+      // the blob context.
+      if (blob_context) {
+        // Attaches the BlobDataHandles to request_body not to free the blobs
+        // and any attached shareable files until upload completion. These data
+        // will be used in UploadDataStream and ServiceWorkerURLRequestJob.
+        bool blobs_alive = AttachRequestBodyBlobDataHandles(
+            request_data.request_body.get(), resource_context);
+        if (!blobs_alive) {
+          AbortRequestBeforeItStarts(requester_info->filter(),
+                                     sync_result_handler, request_id,
+                                     std::move(url_loader_client));
+          return;
+        }
+      }
+    }
+
     // Check if we have a registered interceptor for the headers passed in. If
     // yes then we need to mark the current request as pending and wait for the
     // interceptor to invoke the callback with a status code indicating whether
     // the request needs to be aborted or continued.
     for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();) {
       HeaderInterceptorMap::iterator index =
           http_header_interceptor_map_.find(it.name());
       if (index != http_header_interceptor_map_.end()) {
         HeaderInterceptorInfo& interceptor_info = index->second;
 
         bool call_interceptor = true;
         if (!interceptor_info.starts_with.empty()) {
           call_interceptor =
               base::StartsWith(it.value(), interceptor_info.starts_with,
                                base::CompareCase::INSENSITIVE_ASCII);
         }
         if (call_interceptor) {
           interceptor_info.interceptor.Run(
               it.name(), it.value(), child_id, resource_context,
               base::Bind(
                   &ResourceDispatcherHostImpl::ContinuePendingBeginRequest,
                   base::Unretained(this), requester_info, request_id,
                   request_data, sync_result_handler, route_id, headers,
                   base::Passed(std::move(mojo_request)),
-                  base::Passed(std::move(url_loader_client))));
+                  base::Passed(std::move(url_loader_client)), blob_context));
           return;
         }
       }
     }
   }
   ContinuePendingBeginRequest(
       requester_info, request_id, request_data, sync_result_handler, route_id,
-      headers, std::move(mojo_request), std::move(url_loader_client),
+      headers, std::move(mojo_request), std::move(url_loader_client), nullptr,

[michaeln, 2017/06/02 21:36:37]

it's crashing because of this nullptr

       HeaderInterceptorResult::CONTINUE);
 }
 
 void ResourceDispatcherHostImpl::ContinuePendingBeginRequest(
     scoped_refptr<ResourceRequesterInfo> requester_info,
     int request_id,
     const ResourceRequest& request_data,
     const SyncLoadResultCallback& sync_result_handler,  // only valid for sync
     int route_id,
     const net::HttpRequestHeaders& headers,
     mojom::URLLoaderRequest mojo_request,
     mojom::URLLoaderClientPtr url_loader_client,
+    storage::BlobStorageContext* blob_context,
     HeaderInterceptorResult interceptor_result) {
   DCHECK(requester_info->IsRenderer() || requester_info->IsNavigationPreload());
   if (interceptor_result != HeaderInterceptorResult::CONTINUE) {
     if (requester_info->IsRenderer() &&
         interceptor_result == HeaderInterceptorResult::KILL) {
       // TODO(ananta): Find a way to specify the right error code here. Passing
       // in a non-content error code is not safe, but future header interceptors
       // might say to kill for reasons other than illegal origins.
       bad_message::ReceivedBadMessage(requester_info->filter(),
                                       bad_message::RDH_ILLEGAL_ORIGIN);
     }
     AbortRequestBeforeItStarts(requester_info->filter(), sync_result_handler,
                                request_id, std::move(url_loader_client));
     return;
   }
   int child_id = requester_info->child_id();
-  storage::BlobStorageContext* blob_context = nullptr;
   bool allow_download = false;
   bool do_not_prompt_for_login = false;
   bool report_raw_headers = false;
   bool is_sync_load = !!sync_result_handler;
   int load_flags = BuildLoadFlagsForRequest(request_data, is_sync_load);
   bool is_navigation_stream_request =
       IsBrowserSideNavigationEnabled() &&
       IsResourceTypeFrame(request_data.resource_type);
 
   ResourceContext* resource_context = NULL;
@@ skipping 61 matching lines @@
     // checked previously. So don't set the referrer for this stream request, or
     // else it will fail for SSL redirects since net/ will think the blob:https
     // for the stream is not a secure scheme (specifically, in the call to
     // ComputeReferrerForRedirect).
     const Referrer referrer(
         request_data.referrer, request_data.referrer_policy);
     Referrer::SetReferrerForRequest(new_request.get(), referrer);
 
     new_request->SetExtraRequestHeaders(headers);
 
-    blob_context =
-        GetBlobStorageContext(requester_info->blob_storage_context());

[michaeln, 2017/06/02 21:36:37]

you could retain the local variable and avoid the extra param to the
ContinuePendingBeginRequest method

[dmurph, 2017/06/02 23:00:33]

Done.

     // Resolve elements from request_body and prepare upload data.
     if (request_data.request_body.get()) {
-      // |blob_context| could be null when the request is from the plugins
-      // because ResourceMessageFilters created in PluginProcessHost don't have
-      // the blob context.
-      if (blob_context) {
-        // Attaches the BlobDataHandles to request_body not to free the blobs
-        // and any attached shareable files until upload completion. These data
-        // will be used in UploadDataStream and ServiceWorkerURLRequestJob.
-        AttachRequestBodyBlobDataHandles(request_data.request_body.get(),
-                                         resource_context);
-      }
       new_request->set_upload(UploadDataStreamBuilder::Build(
           request_data.request_body.get(), blob_context,
           requester_info->file_system_context(),
           BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get()));
     }
 
     allow_download = request_data.allow_download &&
                      IsResourceTypeFrame(request_data.resource_type);
     do_not_prompt_for_login = request_data.do_not_prompt_for_login;
 
@@ skipping 737 matching lines @@
   new_request->SetExtraRequestHeaders(headers);
 
   new_request->SetLoadFlags(load_flags);
 
   storage::BlobStorageContext* blob_context = GetBlobStorageContext(
       GetChromeBlobStorageContextForResourceContext(resource_context));
 
   // Resolve elements from request_body and prepare upload data.
   ResourceRequestBodyImpl* body = info.common_params.post_data.get();
   if (body) {
-    AttachRequestBodyBlobDataHandles(body, resource_context);
+    bool blobs_alive = AttachRequestBodyBlobDataHandles(body, resource_context);
+    if (!blobs_alive) {
+      new_request->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
+      loader->NotifyRequestFailed(false, net::ERR_ABORTED);
+      return;
+    }
     new_request->set_upload(UploadDataStreamBuilder::Build(
         body, blob_context, upload_file_system_context,
         BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get()));
   }
 
   // Make extra info and read footer (contains request ID).
   //
   // TODO(davidben): Associate the request with the FrameTreeNode and/or tab so
   // that IO thread -> UI thread hops will work.
   ResourceRequestInfoImpl* extra_info = new ResourceRequestInfoImpl(
@@ skipping 601 matching lines @@
                                  &throttles);
     if (!throttles.empty()) {
       handler.reset(new ThrottlingResourceHandler(std::move(handler), request,
                                                   std::move(throttles)));
     }
   }
   return handler;
 }
 
 }  // namespace content