Remove SupportsUserData from ResourceRequestBodyImpl.

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 21 matching lines @@
 #include "base/profiler/scoped_tracker.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "content/browser/appcache/appcache_interceptor.h"
 #include "content/browser/appcache/appcache_navigation_handle_core.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/bad_message.h"
-#include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/browsing_data/clear_site_data_throttle.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/loader/async_resource_handler.h"
 #include "content/browser/loader/detachable_resource_handler.h"
 #include "content/browser/loader/intercepting_resource_handler.h"
 #include "content/browser/loader/loader_delegate.h"
 #include "content/browser/loader/mime_sniffing_resource_handler.h"
 #include "content/browser/loader/mojo_async_resource_handler.h"
 #include "content/browser/loader/navigation_resource_handler.h"
@@ skipping 1099 matching lines @@
   headers.AddHeadersFromString(request_data.headers);
 
   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;
   }
 
+  std::unique_ptr<BlobHandles> blob_handles;
   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) {
+        blob_handles = GetBodyBlobDataHandles(request_data.request_body.get(),
+                                              resource_context);
+        if (!blob_handles) {
           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
@@ skipping 12 matching lines @@
                                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), make_scoped_refptr(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)),
+                  base::Passed(std::move(blob_handles))));
           return;
         }
       }
     }
   }
   ContinuePendingBeginRequest(
       requester_info, request_id, request_data, sync_result_handler, route_id,
       headers, std::move(mojo_request), std::move(url_loader_client),
-      HeaderInterceptorResult::CONTINUE);
+      std::move(blob_handles), 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::URLLoaderAssociatedRequest mojo_request,
     mojom::URLLoaderClientPtr url_loader_client,
+    std::unique_ptr<BlobHandles> blob_handles,
     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);
@@ skipping 160 matching lines @@
       false,  // is stream
       allow_download, request_data.has_user_gesture,
       request_data.enable_load_timing, request_data.enable_upload_progress,
       do_not_prompt_for_login, request_data.referrer_policy,
       request_data.visibility_state, resource_context, report_raw_headers,
       !is_sync_load,
       GetPreviewsState(request_data.previews_state, delegate_, *new_request,
                        resource_context,
                        request_data.resource_type == RESOURCE_TYPE_MAIN_FRAME),
       request_data.request_body, request_data.initiated_in_secure_context);
+  extra_info->SetBlobHandles(std::move(blob_handles));
   // Request takes ownership.
   extra_info->AssociateWithRequest(new_request.get());
 
   if (new_request->url().SchemeIs(url::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
         new_request.get(), requester_info->blob_storage_context()
                                ->context()
                                ->GetBlobDataFromPublicURL(new_request->url()));
@@ skipping 688 matching lines @@
   headers.AddHeadersFromString(info.begin_params.headers);
   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();
+  std::unique_ptr<BlobHandles> blob_handles;
   if (body) {
-    bool blobs_alive = AttachRequestBodyBlobDataHandles(body, resource_context);
-    if (!blobs_alive) {
+    blob_handles = GetBodyBlobDataHandles(body, resource_context);
+    if (!blob_handles) {
       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).
@@ skipping 25 matching lines @@
       resource_context, info.report_raw_headers,
       true,  // is_async
       GetPreviewsState(info.common_params.previews_state, delegate_,
                        *new_request, resource_context, info.is_main_frame),
       info.common_params.post_data,
       // TODO(mek): Currently initiated_in_secure_context is only used for
       // subresource requests, so it doesn't matter what value it gets here.
       // If in the future this changes this should be updated to somehow get a
       // meaningful value.
       false);  // initiated_in_secure_context
+  extra_info->SetBlobHandles(std::move(blob_handles));
   extra_info->set_navigation_ui_data(std::move(navigation_ui_data));
 
   // Request takes ownership.
   extra_info->AssociateWithRequest(new_request.get());
 
   if (new_request->url().SchemeIs(url::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
         new_request.get(),
@@ skipping 602 matching lines @@
     if (iter->second > 2) {
       active_tabs++;
       if (active_tabs >= 2)
         return true;
     }
   }
   return false;
 }
 
 }  // namespace content