Fix chrome upload with content uri

webkit/browser/blob/blob_storage_context.cc

 // Copyright (c) 2013 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/browser/blob/blob_storage_context.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 156 matching lines @@
       break;
     case BlobData::Item::TYPE_BLOB: {
       scoped_ptr<BlobDataHandle> src = GetBlobDataFromUUID(item.blob_uuid());
       if (src)
         exceeded_memory = !ExpandStorageItems(target_blob_data,
                                               src->data(),
                                               item.offset(),
                                               item.length());
       break;
     }
+#if defined(OS_ANDROID)
+    case BlobData::Item::TYPE_CONTENT_URL:
+      AppendContentUrlItem(target_blob_data,
+                           item.content_url(),
+                           item.offset(),
+                           item.length(),
+                           item.expected_modification_time());
+      break;
+#endif
     default:
       NOTREACHED();
       break;
   }
 
   // If we're using too much memory, drop this blob's data.
   // TODO(michaeln): Blob memory storage does not yet spill over to disk,
   // as a stop gap, we'll prevent memory usage over a max amount.
   if (exceeded_memory) {
     memory_usage_ -= target_blob_data->GetMemoryUsage();
@@ skipping 64 matching lines @@
               iter->bytes() + static_cast<size_t>(iter->offset() + offset),
               static_cast<int64>(new_length))) {
         return false;  // exceeded memory
       }
     } else if (iter->type() == BlobData::Item::TYPE_FILE) {
       AppendFileItem(target_blob_data,
                      iter->path(),
                      iter->offset() + offset,
                      new_length,
                      iter->expected_modification_time());
+#if defined(OS_ANDROID)
+    } else if (iter->type() == BlobData::Item::TYPE_CONTENT_URL) {
+      AppendContentUrlItem(target_blob_data,
+                           iter->content_url(),
+                           iter->offset() + offset,
+                           new_length,
+                           iter->expected_modification_time());
+#endif
     } else {
       DCHECK(iter->type() == BlobData::Item::TYPE_FILE_FILESYSTEM);
       AppendFileSystemFileItem(target_blob_data,
                                iter->filesystem_url(),
                                iter->offset() + offset,
                                new_length,
                                iter->expected_modification_time());
     }
     length -= new_length;
     offset = 0;
@@ skipping 29 matching lines @@
 }
 
 void BlobStorageContext::AppendFileSystemFileItem(
     BlobData* target_blob_data,
     const GURL& filesystem_url, uint64 offset, uint64 length,
     const base::Time& expected_modification_time) {
   target_blob_data->AppendFileSystemFile(filesystem_url, offset, length,
                                          expected_modification_time);
 }
 
+#if defined(OS_ANDROID)
+void BlobStorageContext::AppendContentUrlItem(
+    BlobData* target_blob_data,
+    const GURL& content_url, uint64 offset, uint64 length,
+    const base::Time& expected_modification_time) {
+  target_blob_data->AppendContentUrlFile(content_url, offset, length,
+                                         expected_modification_time);
+}
+#endif
+
 bool BlobStorageContext::IsInUse(const std::string& uuid) {
   return blob_map_.find(uuid) != blob_map_.end();
 }
 
 bool BlobStorageContext::IsBeingBuilt(const std::string& uuid) {
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end())
     return false;
   return found->second.flags & BEING_BUILT;
 }
 
 bool BlobStorageContext::IsUrlRegistered(const GURL& blob_url) {
   return public_blob_urls_.find(blob_url) != public_blob_urls_.end();
 }
 
 }  // namespace webkit_blob