[Storage] Blob Storage Refactoring pt 1

content/browser/fileapi/fileapi_message_filter.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 "content/browser/fileapi/fileapi_message_filter.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/fileapi/blob_storage_host.h"
 #include "content/browser/fileapi/browser_file_system_helper.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/streams/stream_registry.h"
 #include "content/common/fileapi/file_system_messages.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "content/public/browser/user_metrics.h"
 #include "ipc/ipc_platform_file.h"
 #include "net/base/mime_util.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_storage_context.h"
+#include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/file_observers.h"
 #include "storage/browser/fileapi/file_permission_policy.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/isolated_context.h"
-#include "storage/common/blob/blob_data.h"
-#include "storage/common/blob/shareable_file_reference.h"
+#include "storage/common/data_element.h"
 #include "storage/common/fileapi/directory_entry.h"
 #include "storage/common/fileapi/file_system_info.h"
 #include "storage/common/fileapi/file_system_types.h"
 #include "storage/common/fileapi/file_system_util.h"
 #include "url/gurl.h"
 
 using storage::FileSystemFileUtil;
 using storage::FileSystemBackend;
 using storage::FileSystemOperation;
 using storage::FileSystemURL;
-using storage::BlobData;
+using storage::BlobDataBuilder;
 using storage::BlobStorageContext;
 
 namespace content {
 
 namespace {
 
 const uint32 kFilteredMessageClasses[] = {
   BlobMsgStart,
   FileSystemMsgStart,
 };
@@ skipping 454 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   in_transit_snapshot_files_.erase(request_id);
 }
 
 void FileAPIMessageFilter::OnStartBuildingBlob(const std::string& uuid) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ignore_result(blob_storage_host_->StartBuildingBlob(uuid));
 }
 
 void FileAPIMessageFilter::OnAppendBlobDataItemToBlob(
-    const std::string& uuid, const BlobData::Item& item) {
+    const std::string& uuid,
+    const storage::DataElement& item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (item.type() == BlobData::Item::TYPE_FILE_FILESYSTEM) {
+  if (item.type() == storage::DataElement::TYPE_FILE_FILESYSTEM) {
     FileSystemURL filesystem_url(context_->CrackURL(item.filesystem_url()));
     if (!FileSystemURLIsValid(context_, filesystem_url) ||
         !security_policy_->CanReadFileSystemFile(process_id_, filesystem_url)) {
       ignore_result(blob_storage_host_->CancelBuildingBlob(uuid));
       return;
     }
   }
-  if (item.type() == BlobData::Item::TYPE_FILE &&
+  if (item.type() == storage::DataElement::TYPE_FILE &&
       !security_policy_->CanReadFile(process_id_, item.path())) {
     ignore_result(blob_storage_host_->CancelBuildingBlob(uuid));
     return;
   }
   if (item.length() == 0) {
     BadMessageReceived();
     return;
   }
   ignore_result(blob_storage_host_->AppendBlobDataItem(uuid, item));
 }
@@ skipping 10 matching lines @@
 #if defined(OS_WIN)
   base::SharedMemory shared_memory(handle, true, PeerHandle());
 #else
   base::SharedMemory shared_memory(handle, true);
 #endif
   if (!shared_memory.Map(buffer_size)) {
     ignore_result(blob_storage_host_->CancelBuildingBlob(uuid));
     return;
   }
 
-  BlobData::Item item;
+  storage::DataElement item;
   item.SetToSharedBytes(static_cast<char*>(shared_memory.memory()),
                         buffer_size);
   ignore_result(blob_storage_host_->AppendBlobDataItem(uuid, item));
 }
 
 void FileAPIMessageFilter::OnFinishBuildingBlob(
     const std::string& uuid, const std::string& content_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ignore_result(blob_storage_host_->FinishBuildingBlob(uuid, content_type));
   // TODO(michaeln): check return values once blink has migrated, crbug/174200
@@ skipping 32 matching lines @@
   }
   // Use an empty security origin for now. Stream accepts a security origin
   // but how it's handled is not fixed yet.
   new Stream(stream_context_->registry(),
              NULL /* write_observer */,
              url);
   stream_urls_.insert(url.spec());
 }
 
 void FileAPIMessageFilter::OnAppendBlobDataItemToStream(
-    const GURL& url, const BlobData::Item& item) {
+    const GURL& url,
+    const storage::DataElement& item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   scoped_refptr<Stream> stream(GetStreamForURL(url));
   // Stream instances may be deleted on error. Just abort if there's no Stream
   // instance for |url| in the registry.
   if (!stream.get())
     return;
 
   // Data for stream is delivered as TYPE_BYTES item.
-  if (item.type() != BlobData::Item::TYPE_BYTES) {
+  if (item.type() != storage::DataElement::TYPE_BYTES) {
     BadMessageReceived();
     return;
   }
   stream->AddData(item.bytes(), item.length());
 }
 
 void FileAPIMessageFilter::OnAppendSharedMemoryToStream(
     const GURL& url, base::SharedMemoryHandle handle, size_t buffer_size) {
   DCHECK(base::SharedMemory::IsHandleValid(handle));
   if (!buffer_size) {
@@ skipping 243 matching lines @@
   }
 
   return true;
 }
 
 scoped_refptr<Stream> FileAPIMessageFilter::GetStreamForURL(const GURL& url) {
   return stream_context_->registry()->GetStream(url);
 }
 
 }  // namespace content