[Storage] Blob Storage Refactoring pt 1

content/browser/indexed_db/indexed_db_dispatcher_host.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/indexed_db/indexed_db_dispatcher_host.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
@@ skipping 205 matching lines @@
 uint32 IndexedDBDispatcherHost::TransactionIdToProcessId(
     int64 host_transaction_id) {
   return (host_transaction_id >> 32) & 0xffffffff;
 }
 
 std::string IndexedDBDispatcherHost::HoldBlobData(
     const IndexedDBBlobInfo& blob_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   std::string uuid = blob_info.uuid();
   storage::BlobStorageContext* context = blob_storage_context_->context();
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle;
+  scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle;
   if (uuid.empty()) {
     uuid = base::GenerateGUID();
-    scoped_refptr<storage::BlobData> blob_data = new storage::BlobData(uuid);
+    scoped_ptr<storage::BlobDataBuilder> blob_data(
+        new storage::BlobDataBuilder(uuid));
     blob_data->set_content_type(base::UTF16ToUTF8(blob_info.type()));
     blob_data->AppendFile(blob_info.file_path(), 0, blob_info.size(),
                           blob_info.last_modified());
-    blob_data_handle = context->AddFinishedBlob(blob_data.get());
+    blob_data_handle = context->AddFinishedBlob(*blob_data.get());
   } else {
     auto iter = blob_data_handle_map_.find(uuid);
     if (iter != blob_data_handle_map_.end()) {
       iter->second.second += 1;
       return uuid;
     }
     blob_data_handle = context->GetBlobDataFromUUID(uuid);
   }
 
   DCHECK(!ContainsKey(blob_data_handle_map_, uuid));
   blob_data_handle_map_[uuid] = std::make_pair(blob_data_handle.release(), 1);

[michaeln, 2015/01/16 00:09:09]

also for this use case, we really only want to retain the uuid and allow the
data underneath to be swapped out

[dmurph, 2015/01/16 23:45:56]

I think this is fixed from the decoupling of the snapshot and the handle.

   return uuid;
 }
 
 void IndexedDBDispatcherHost::DropBlobData(const std::string& uuid) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BlobDataHandleMap::iterator iter = blob_data_handle_map_.find(uuid);
   if (iter != blob_data_handle_map_.end()) {
     DCHECK_GE(iter->second.second, 1);
     if (iter->second.second == 1) {
       delete iter->second.first;
@@ skipping 109 matching lines @@
       new IndexedDBCallbacks(
           this, params.ipc_thread_id, params.ipc_callbacks_id),
       origin_url,
       indexed_db_path);
 }
 
 // OnPutHelper exists only to allow us to hop threads while holding a reference
 // to the IndexedDBDispatcherHost.
 void IndexedDBDispatcherHost::OnPutHelper(
     const IndexedDBHostMsg_DatabasePut_Params& params,
-    std::vector<storage::BlobDataHandle*> handles) {
+    std::vector<storage::BlobDataSnapshotHandle*> handles) {
   database_dispatcher_host_->OnPut(params, handles);
 }
 
 void IndexedDBDispatcherHost::OnAckReceivedBlobs(
     const std::vector<std::string>& uuids) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   for (const auto& uuid : uuids)
     DropBlobData(uuid);
 }
 
@@ skipping 252 matching lines @@
       parent_->HostTransactionId(params.transaction_id),
       params.object_store_id,
       params.index_id,
       make_scoped_ptr(new IndexedDBKeyRange(params.key_range)),
       params.key_only,
       callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPutWrapper(
     const IndexedDBHostMsg_DatabasePut_Params& params) {
-  std::vector<storage::BlobDataHandle*> handles;
+  std::vector<storage::BlobDataSnapshotHandle*> handles;
   for (size_t i = 0; i < params.blob_or_file_info.size(); ++i) {
     const IndexedDBMsg_BlobOrFileInfo& info = params.blob_or_file_info[i];
     handles.push_back(parent_->blob_storage_context_->context()
                           ->GetBlobDataFromUUID(info.uuid)
                           .release());
   }
   parent_->indexed_db_context_->TaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &IndexedDBDispatcherHost::OnPutHelper, parent_, params, handles));
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPut(
     const IndexedDBHostMsg_DatabasePut_Params& params,
-    std::vector<storage::BlobDataHandle*> handles) {
+    std::vector<storage::BlobDataSnapshotHandle*> handles) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
-  ScopedVector<storage::BlobDataHandle> scoped_handles;
+  ScopedVector<storage::BlobDataSnapshotHandle> scoped_handles;
   scoped_handles.swap(handles);
 
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
 
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
@@ skipping 344 matching lines @@
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDestroyed(
     int32 ipc_object_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 }  // namespace content