[Storage] Blob Storage Refactoring pt 1

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 <algorithm>
 #include <set>
@@ skipping 76 matching lines @@
 #include "net/cookies/cookie_monster.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
+#include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/file_permission_policy.h"
 #include "storage/browser/fileapi/file_system_context.h"
-#include "storage/common/blob/blob_data.h"
-#include "storage/common/blob/shareable_file_reference.h"
 #include "url/url_constants.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using storage::ShareableFileReference;
 
 // ----------------------------------------------------------------------------
 
 namespace content {
@@ skipping 261 matching lines @@
 
 storage::BlobStorageContext* GetBlobStorageContext(
     ChromeBlobStorageContext* blob_storage_context) {
   if (!blob_storage_context)
     return NULL;
   return blob_storage_context->context();
 }
 
 void AttachRequestBodyBlobDataHandles(
     ResourceRequestBody* body,
     storage::BlobStorageContext* blob_context) {

[mmenke, 2015/01/22 00:04:47]

Is this still needed, now that you're attaching the blobs directly to the
request?

[dmurph, 2015/01/22 00:18:29]

Yes.  The Handle and Snapshot are two different things.  A handle guarentees
that the blob will not be destroyed from the blob storage context (basically
keeps a refcount of the whole blob).  The Snapshot holds refcounted data
elements, which represent the backing 'items' of a blob (which can be memory or
file backed).  The storage context can swap these items interally between ram
and disk backed representations, so we need to hold refptrs of the data elements
wherever we want to do reading from a blob. (also, items can be in multiple
blobs). See the design doc here for more info:
https://bit.ly/AutoBlobToDisk

   DCHECK(blob_context);
   for (size_t i = 0; i < body->elements()->size(); ++i) {
     const ResourceRequestBody::Element& element = (*body->elements())[i];
     if (element.type() != ResourceRequestBody::Element::TYPE_BLOB)
       continue;
     scoped_ptr<storage::BlobDataHandle> handle =
         blob_context->GetBlobDataFromUUID(element.blob_uuid());
     DCHECK(handle);
     if (!handle)
       continue;
@@ skipping 1975 matching lines @@
 
   // Add a flag to selectively bypass the data reduction proxy if the resource
   // type is not an image.
   if (request_data.resource_type != RESOURCE_TYPE_IMAGE)
     load_flags |= net::LOAD_BYPASS_DATA_REDUCTION_PROXY;
 
   return load_flags;
 }
 
 }  // namespace content