Support FileSystem URL in File object

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"
@@ skipping 47 matching lines @@
   BlobData* target_blob_data = found->second;
   DCHECK(target_blob_data);
 
   memory_usage_ -= target_blob_data->GetMemoryUsage();
 
   // The blob data is stored in the "canonical" way. That is, it only contains a
   // list of Data and File items.
   // 1) The Data item is denoted by the raw data and the range.
   // 2) The File item is denoted by the file path, the range and the expected
   //    modification time.
+  // 3) The FileSystem File item is denoted by the FileSystem URL, the range
+  //    and the expected modification time.
   // All the Blob items in the passing blob data are resolved and expanded into
   // a set of Data and File items.
 
   DCHECK(item.length > 0);
   switch (item.type) {
     case BlobData::TYPE_DATA:
       // WebBlobData does not allow partial data.
       DCHECK(!(item.offset) && item.length == item.data.size());
       target_blob_data->AppendData(item.data.c_str(), item.data.size());
       break;
     case BlobData::TYPE_DATA_EXTERNAL:
       DCHECK(!item.offset);
       target_blob_data->AppendData(item.data_external, item.length);
       break;
     case BlobData::TYPE_FILE:
       AppendFileItem(target_blob_data,
                      item.file_path,
                      item.offset,
                      item.length,
                      item.expected_modification_time);
       break;
-    case BlobData::TYPE_BLOB:
-      BlobData* src_blob_data = GetBlobDataFromUrl(item.blob_url);
+    case BlobData::TYPE_BLOB: {
+      BlobData* src_blob_data = GetBlobDataFromUrl(item.url);
       DCHECK(src_blob_data);
       if (src_blob_data)
         AppendStorageItems(target_blob_data,
                            src_blob_data,
                            item.offset,
                            item.length);
       break;
+    }
+    case BlobData::TYPE_FILE_FILESYSTEM:
+      AppendFileSystemFileItem(target_blob_data,
+                               item.url,
+                               item.offset,
+                               item.length,
+                               item.expected_modification_time);
+      break;
   }
 
   memory_usage_ += target_blob_data->GetMemoryUsage();
 
   // If we're using too much memory, drop this blob.
   // TODO(michaeln): Blob memory storage does not yet spill over to disk,
   // until it does, we'll prevent memory usage over a max amount.
   if (memory_usage_ > kMaxMemoryUsage)
     RemoveBlob(url);
 }
@@ skipping 68 matching lines @@
   std::vector<net::UploadData::Element>* uploads =
       upload_data->elements_mutable();
   std::vector<net::UploadData::Element>::iterator iter;
   for (iter = uploads->begin(); iter != uploads->end();) {
     if (iter->type() != net::UploadData::TYPE_BLOB) {
       iter++;
       continue;
     }
 
     // Find the referred blob data.
-    BlobData* blob_data = GetBlobDataFromUrl(iter->blob_url());
+    BlobData* blob_data = GetBlobDataFromUrl(iter->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);
 
@@ skipping 24 matching lines @@
               &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;
+        case BlobData::TYPE_FILE_FILESYSTEM:
+          iter->SetToFileSystemURLRange(
+              item.url,
+              item.offset,
+              item.length,
+              item.expected_modification_time);
+          break;
         default:
           NOTREACHED();
           break;
       }
     }
   }
 }
 
 void BlobStorageController::AppendStorageItems(
     BlobData* target_blob_data, BlobData* src_blob_data,
@@ skipping 39 matching lines @@
   target_blob_data->AppendFile(file_path, offset, length,
                                expected_modification_time);
 
   // It may be a temporary file that should be deleted when no longer needed.
   scoped_refptr<ShareableFileReference> shareable_file =
       ShareableFileReference::Get(file_path);
   if (shareable_file)
     target_blob_data->AttachShareableFileReference(shareable_file);
 }
 
+void BlobStorageController::AppendFileSystemFileItem(
+    BlobData* target_blob_data,
+    const GURL& url, uint64 offset, uint64 length,
+    const base::Time& expected_modification_time) {
+  target_blob_data->AppendFileSystemFile(url, offset, length,
+                                         expected_modification_time);
+}
+
 void BlobStorageController::IncrementBlobDataUsage(BlobData* blob_data) {
   blob_data_usage_count_[blob_data] += 1;
 }
 
 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