Split net::UploadData into two: for IPC and for upload handling

webkit/blob/blob_storage_controller.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.
 
 #include "webkit/blob/blob_storage_controller.h"
 
 #include "base/logging.h"
 #include "googleurl/src/gurl.h"
-#include "net/base/upload_data.h"
 #include "webkit/blob/blob_data.h"
+#include "webkit/glue/resource_request_body.h"
+
+using webkit_glue::ResourceRequestBody;
 
 namespace webkit_blob {
 
 namespace {
 
 // We can't use GURL directly for these hash fragment manipulations
 // since it doesn't have specific knowlege of the BlobURL format. GURL
 // treats BlobURLs as if they were PathURLs which don't support hash
 // fragments.
 
@@ skipping 141 matching lines @@
   return true;
 }
 
 
 BlobData* BlobStorageController::GetBlobDataFromUrl(const GURL& url) {
   BlobMap::iterator found = blob_map_.find(
       BlobUrlHasRef(url) ? ClearBlobUrlRef(url).spec() : url.spec());
   return (found != blob_map_.end()) ? found->second : NULL;
 }
 
-void BlobStorageController::ResolveBlobReferencesInUploadData(
-    net::UploadData* upload_data) {
-  DCHECK(upload_data);
+void BlobStorageController::ResolveBlobReferencesInResourceRequestBody(

[darin (slow to review), 2012/08/15 17:49:55]

nit: I'd be OK dropping the "Resource" in this function name just as you did on
ResourceLoaderBridge with the SetRequestBody method.

[kinuko, 2012/08/16 08:14:59]

Done.

+    ResourceRequestBody* resource_request_body) {
+  DCHECK(resource_request_body);
 
-  std::vector<net::UploadData::Element>* uploads =
-      upload_data->elements_mutable();
-  std::vector<net::UploadData::Element>::iterator iter;
+  std::vector<ResourceRequestBody::Element>* uploads =
+      resource_request_body->elements_mutable();
+  std::vector<ResourceRequestBody::Element>::iterator iter;
   for (iter = uploads->begin(); iter != uploads->end();) {
-    if (iter->type() != net::UploadData::TYPE_BLOB) {
+    if (iter->type() != ResourceRequestBody::TYPE_BLOB) {
       iter++;
       continue;
     }
 
     // Find the referred blob data.
     BlobData* blob_data = GetBlobDataFromUrl(iter->blob_url());
     DCHECK(blob_data);
     if (!blob_data) {
       // TODO(jianli): We should probably fail uploading the data
       iter++;
       continue;
     }
 
     // Remove this element.
     iter = uploads->erase(iter);
 
     // If there is no element in the referred blob data, continue the loop.
     // Note that we should not increase iter since it already points to the one
     // after the removed element.
     if (blob_data->items().empty())
       continue;
 
     // Ensure the blob and any attached shareable files survive until
     // upload completion.
-    upload_data->SetUserData(blob_data,
-                             new base::UserDataAdapter<BlobData>(blob_data));
+    resource_request_body->SetUserData(
+        blob_data, new base::UserDataAdapter<BlobData>(blob_data));
 
     // Insert the elements in the referred blob data.
     // Note that we traverse from the bottom so that the elements can be
     // inserted in the original order.
     for (size_t i = blob_data->items().size(); i > 0; --i) {
-      iter = uploads->insert(iter, net::UploadData::Element());
+      iter = uploads->insert(iter, ResourceRequestBody::Element());
 
       const BlobData::Item& item = blob_data->items().at(i - 1);
       switch (item.type) {
         case BlobData::TYPE_DATA:
-          // TODO(jianli): Figure out how to avoid copying the data.
-          // TODO(michaeln): Now that blob_data surives for the duration,
-          // maybe UploadData could take a raw ptr without having to copy.
-          iter->SetToBytes(
+          iter->SetToSharedBytes(
               &item.data.at(0) + static_cast<int>(item.offset),
               static_cast<int>(item.length));
           break;
         case BlobData::TYPE_FILE:
           iter->SetToFilePathRange(
               item.file_path,
               item.offset,
               item.length,
               item.expected_modification_time);
           break;
@@ skipping 63 matching lines @@
 bool BlobStorageController::DecrementBlobDataUsage(BlobData* blob_data) {
   BlobDataUsageMap::iterator found = blob_data_usage_count_.find(blob_data);
   DCHECK(found != blob_data_usage_count_.end());
   if (--(found->second))
     return false;  // Still in use
   blob_data_usage_count_.erase(found);
   return true;
 }
 
 }  // namespace webkit_blob