[Blob] Blob paging to disk patch.

storage/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 "storage/browser/blob/blob_storage_context.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_data_item.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
 #include "storage/browser/blob/shareable_blob_data_item.h"
 #include "url/gurl.h"
 
 namespace storage {
 using BlobRegistryEntry = BlobStorageRegistry::Entry;
 using BlobState = BlobStorageRegistry::BlobState;
 
-BlobStorageContext::BlobStorageContext() : memory_usage_(0) {}
+BlobStorageContext::BlobStorageContext() {}
+
+BlobStorageContext::BlobStorageContext(
+    bool enable_disk,
+    const base::FilePath& blob_storage_dir,
+    scoped_refptr<base::TaskRunner> file_runner)
+    : memory_controller_(enable_disk, blob_storage_dir, file_runner) {}
 
 BlobStorageContext::~BlobStorageContext() {
 }
 
 scoped_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromUUID(
     const std::string& uuid) {
   scoped_ptr<BlobDataHandle> result;
   BlobRegistryEntry* entry = registry_.GetEntry(uuid);
   if (!entry || entry->state != BlobState::ACTIVE || entry->exceeded_memory) {
     LOG(ERROR) << "Could not find blob " << uuid;
@@ skipping 173 matching lines @@
       case BlobState::CONSTRUCTION:
         memory_freeing = entry->data_builder->GetNonsharedMemoryUsage();
         entry->data_builder->RemoveBlobFromShareableItems(uuid);
         break;
       case BlobState::ASYNC_TRANSPORTATION:
       case BlobState::RESERVED:
         break;
     }
     DCHECK_LE(memory_freeing, memory_usage_);
     memory_usage_ -= memory_freeing;
+    for (const auto& item_refptr : entry->data->items_) {
+      if (item_refptr->num_referencing_blob() == 0) {
+        memory_controller_.RemoveBlobItemInRecents(item_refptr->item_id());
+      }
+    }
     registry_.DeleteEntry(uuid);
   }
 }
 
 void BlobStorageContext::BlobEntryExceededMemory(BlobRegistryEntry* entry) {
   // 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.
   memory_usage_ -= entry->data_builder->GetNonsharedMemoryUsage();
   entry->exceeded_memory = true;
@@ skipping 27 matching lines @@
                        memory_usage_ / 1024);
   switch (data_element.type()) {
     case DataElement::TYPE_BYTES:
       UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Bytes", length / 1024);
       DCHECK(!offset);
       if (memory_usage_ + length > kBlobStorageMaxMemoryUsage) {
         exceeded_memory = true;
         break;
       }
       memory_usage_ += length;
-      target_blob_builder->AppendSharedBlobItem(
-          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+          target_blob_uuid, GetAndIncrementItemId(), blob_item));
       break;
     case DataElement::TYPE_FILE: {
       bool full_file = (length == std::numeric_limits<uint64>::max());
       UMA_HISTOGRAM_BOOLEAN("Storage.BlobItemSize.File.Unknown", full_file);
       if (!full_file) {
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.File",
                              (length - offset) / 1024);
       }
-      target_blob_builder->AppendSharedBlobItem(
-          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+          target_blob_uuid, GetAndIncrementItemId(), blob_item));
       break;
     }
     case DataElement::TYPE_FILE_FILESYSTEM: {
       bool full_file = (length == std::numeric_limits<uint64>::max());
       UMA_HISTOGRAM_BOOLEAN("Storage.BlobItemSize.FileSystem.Unknown",
                             full_file);
       if (!full_file) {
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.FileSystem",
                              (length - offset) / 1024);
       }
-      target_blob_builder->AppendSharedBlobItem(
-          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+          target_blob_uuid, GetAndIncrementItemId(), blob_item));
       break;
     }
     case DataElement::TYPE_BLOB: {
       UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Blob",
                            (length - offset) / 1024);
       // We grab the handle to ensure it stays around while we copy it.
       scoped_ptr<BlobDataHandle> src =
           GetBlobDataFromUUID(data_element.blob_uuid());
       if (src) {
         BlobRegistryEntry* other_entry =
             registry_.GetEntry(data_element.blob_uuid());
         DCHECK(other_entry->data);
         exceeded_memory = !AppendBlob(target_blob_uuid, *other_entry->data,
                                       offset, length, target_blob_builder);
       }
       break;
     }
     case DataElement::TYPE_DISK_CACHE_ENTRY: {
       UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.CacheEntry",
                            (length - offset) / 1024);
-      target_blob_builder->AppendSharedBlobItem(
-          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+          target_blob_uuid, GetAndIncrementItemId(), blob_item));
       break;
     }
     case DataElement::TYPE_BYTES_DESCRIPTION:
     case DataElement::TYPE_UNKNOWN:
       NOTREACHED();
       break;
   }
   UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeAfterAppend",
                        memory_usage_ / 1024);
 
@@ skipping 44 matching lines @@
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.Bytes",
                              new_length / 1024);
         if (memory_usage_ + new_length > kBlobStorageMaxMemoryUsage) {
           return false;
         }
         DCHECK(!item.offset());
         scoped_ptr<DataElement> element(new DataElement());
         element->SetToBytes(item.bytes() + offset,
                             static_cast<int64>(new_length));
         memory_usage_ += new_length;
-        target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
-            target_blob_uuid, new BlobDataItem(element.Pass())));
+        target_blob_builder->AppendSharedBlobItem(
+            new ShareableBlobDataItem(target_blob_uuid, GetAndIncrementItemId(),
+                                      new BlobDataItem(element.Pass())));
       } break;
       case DataElement::TYPE_FILE: {
         DCHECK_NE(item.length(), std::numeric_limits<uint64>::max())
             << "We cannot use a section of a file with an unknown length";
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.File",
                              new_length / 1024);
         scoped_ptr<DataElement> element(new DataElement());
         element->SetToFilePathRange(item.path(), item.offset() + offset,
                                     new_length,
                                     item.expected_modification_time());
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
-            target_blob_uuid,
+            target_blob_uuid, GetAndIncrementItemId(),
             new BlobDataItem(element.Pass(), item.data_handle_)));
       } break;
       case DataElement::TYPE_FILE_FILESYSTEM: {
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.FileSystem",
                              new_length / 1024);
         scoped_ptr<DataElement> element(new DataElement());
         element->SetToFileSystemUrlRange(item.filesystem_url(),
                                          item.offset() + offset, new_length,
                                          item.expected_modification_time());
-        target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
-            target_blob_uuid, new BlobDataItem(element.Pass())));
+        target_blob_builder->AppendSharedBlobItem(
+            new ShareableBlobDataItem(target_blob_uuid, GetAndIncrementItemId(),
+                                      new BlobDataItem(element.Pass())));
       } break;
       case DataElement::TYPE_DISK_CACHE_ENTRY: {
         scoped_ptr<DataElement> element(new DataElement());
         element->SetToDiskCacheEntryRange(item.offset() + offset,
                                           new_length);
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
-            target_blob_uuid,
+            target_blob_uuid, GetAndIncrementItemId(),
             new BlobDataItem(element.Pass(), item.data_handle_,
                              item.disk_cache_entry(),
                              item.disk_cache_stream_index())));
       } break;
       case DataElement::TYPE_BYTES_DESCRIPTION:
       case DataElement::TYPE_BLOB:
       case DataElement::TYPE_UNKNOWN:
         CHECK(false) << "Illegal blob item type: " << item.type();
     }
     length -= new_length;
@@ skipping 46 matching lines @@
     return false;
   }
   for (const auto& callback : entry->construction_complete_callbacks) {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback, false));
   }
   registry_.DeleteEntry(uuid);
   return true;
 }
 
+uint64_t BlobStorageContext::GetAndIncrementItemId() {
+  return next_item_id_++;
+}
+
+void BlobStorageContext::UpdateItemsInRecents(BlobRegistryEntry* entry) {
+  for (const auto& item_refptr : entry->data->items_) {
+    memory_controller_.UpdateBlobItemInRecents(item_refptr.get());
+  }
+}
+
 }  // namespace storage