[BlobAsync] Disk support for blob storage

content/browser/blob_storage/chrome_blob_storage_context.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/blob_storage/chrome_blob_storage_context.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/guid.h"
+#include "base/files/file.h"
+#include "base/files/file_enumerator.h"
+#include "base/files/file_util.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/task_runner.h"
+#include "base/single_thread_task_runner.h"
 #include "content/public/browser/blob_handle.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 
+using base::FilePath;
 using base::UserDataAdapter;
 using storage::BlobStorageContext;
 
 namespace content {
 
 namespace {
+const char kBlobStorageParentDirectory[] = "blob_storage";
+
+void CreateBlobDirectory(const FilePath& blob_storage_dir,
+                         scoped_refptr<base::TaskRunner> io_runner,
+                         const base::Closure& done) {
+  base::File::Error error;
+  bool success = base::CreateDirectoryAndGetError(blob_storage_dir, &error);
+  LOCAL_HISTOGRAM_BOOLEAN("Storage.Blob.DirectorySuccess", success);
+  if (!success) {
+    LOCAL_HISTOGRAM_ENUMERATION("Storage.Blob.DirectorySuccess.Error", -error,
+                                -base::File::FILE_ERROR_MAX);
+  } else {
+    io_runner->PostTask(FROM_HERE, done);
+  }
+}
+
+// Removes all folders in the parent directory except for the
+// |current_run_dir| folder. If this path is empty, then we delete all folders.
+void RemoveOldBlobStorageDirectories(const FilePath& blob_storage_parent,
+                                     const FilePath& current_run_dir) {
+  if (!base::DirectoryExists(blob_storage_parent)) {
+    return;
+  }
+  base::FileEnumerator enumerator(blob_storage_parent, false,
+                                  base::FileEnumerator::DIRECTORIES);
+  std::vector<std::string> components;
+  bool success = true;
+  for (base::FilePath name = enumerator.Next(); !name.empty();
+       name = enumerator.Next()) {
+    if (current_run_dir.empty() || name != current_run_dir)
+      success &= base::DeleteFile(name, true);
+  }
+  LOCAL_HISTOGRAM_BOOLEAN("Storage.Blob.CleanupSuccess", success);
+}
 
 const char kBlobStorageContextKeyName[] = "content_blob_storage_context";
 
 class BlobHandleImpl : public BlobHandle {
  public:
   explicit BlobHandleImpl(std::unique_ptr<storage::BlobDataHandle> handle)
       : handle_(std::move(handle)) {}
 
   ~BlobHandleImpl() override {}
 
   std::string GetUUID() override { return handle_->uuid(); }
 
  private:
   std::unique_ptr<storage::BlobDataHandle> handle_;
 };
 
 }  // namespace
 
 ChromeBlobStorageContext::ChromeBlobStorageContext() {}
 
 ChromeBlobStorageContext* ChromeBlobStorageContext::GetFor(
     BrowserContext* context) {
   if (!context->GetUserData(kBlobStorageContextKeyName)) {
     scoped_refptr<ChromeBlobStorageContext> blob =
         new ChromeBlobStorageContext();
     context->SetUserData(
         kBlobStorageContextKeyName,
         new UserDataAdapter<ChromeBlobStorageContext>(blob.get()));
+
     // Check first to avoid memory leak in unittests.
-    if (BrowserThread::IsMessageLoopValid(BrowserThread::IO)) {
+    bool io_thread_valid = BrowserThread::IsMessageLoopValid(BrowserThread::IO);

[michaeln, 2016/07/07 20:05:21]

Maybe early return for this case to simplify?

I wonder if this is even needed anymore? It be nice to not have the "for
testing" condition at all in production code.

+    if (io_thread_valid) {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&ChromeBlobStorageContext::InitializeOnIOThread, blob));
     }
+
+    // If we're not incognito mode, schedule all of our file tasks to enable
+    // disk on the storage context.
+    if (!context->IsOffTheRecord() && io_thread_valid &&
+        BrowserThread::IsMessageLoopValid(BrowserThread::FILE)) {
+      // Resolve our storage directories.
+      base::FilePath blob_storage_parent =
+          context->GetPath().Append(kBlobStorageParentDirectory);
+      base::FilePath blob_storage_dir =
+          blob_storage_parent.Append(base::GenerateGUID());
+
+      scoped_refptr<base::SingleThreadTaskRunner> io_runner =
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
+      scoped_refptr<base::SingleThreadTaskRunner> file_runner =
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
+
+      // This creates our directory and calls |OnBlobDirectoryCreated| if we're
+      // successful.
+      BrowserThread::PostAfterStartupTask(

[michaeln, 2016/07/07 20:05:21]

Can creation/deletion of the active directory be managed internally by the
BlobStorageContext. We know at the time of construction time what path to
provide, seems like the context could create it on demand when it determines
it's needed.


Could/should the BlobStorageContext do this as needed so the blob system's
behavior early on isn't necessarily different compared to "afterstartup"? Also
creating the directory seems like something that could be more fully
encapsulated inside of the BlobStorageContext proper so there's less variability
in how initialization happens.

+          FROM_HERE, file_runner,
+          base::Bind(
+              &CreateBlobDirectory, blob_storage_dir, io_runner,
+              base::Bind(&ChromeBlobStorageContext::OnBlobDirectoryCreated,
+                         blob, blob_storage_dir)));
+      // Removes our old blob directories if they exist.
+      BrowserThread::PostAfterStartupTask(
+          FROM_HERE, file_runner,
+          base::Bind(&RemoveOldBlobStorageDirectories, blob_storage_parent,
+                     blob_storage_dir));
+    }
   }
 
   return UserDataAdapter<ChromeBlobStorageContext>::Get(
       context, kBlobStorageContextKeyName);
 }
 
 void ChromeBlobStorageContext::InitializeOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   context_.reset(new BlobStorageContext());
+  if (!blob_storage_dir_.empty()) {
+    // This happens if we create our blob storage folder before this method is
+    // called, so we enable disk here.
+    context_->EnableDisk(
+        blob_storage_dir_,
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
+  }
 }
 
 std::unique_ptr<BlobHandle> ChromeBlobStorageContext::CreateMemoryBackedBlob(
     const char* data,
     size_t length) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   std::string uuid(base::GenerateGUID());
   storage::BlobDataBuilder blob_data_builder(uuid);
   blob_data_builder.AppendData(data, length);
@@ skipping 25 matching lines @@
     return std::unique_ptr<BlobHandle>();
 
   std::unique_ptr<BlobHandle> blob_handle(
       new BlobHandleImpl(std::move(blob_data_handle)));
   return blob_handle;
 }
 
 ChromeBlobStorageContext::~ChromeBlobStorageContext() {}
 
 void ChromeBlobStorageContext::DeleteOnCorrectThread() const {
+  // Schedule a task to delete all blob directories.
+  if (!blob_storage_dir_.empty()) {
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&RemoveOldBlobStorageDirectories,
+                   blob_storage_dir_.DirName(), base::FilePath()));
+  }
   if (BrowserThread::IsMessageLoopValid(BrowserThread::IO) &&
       !BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, this);
     return;
   }
   delete this;
 }
 
+void ChromeBlobStorageContext::OnBlobDirectoryCreated(
+    const base::FilePath& blob_storage_directory) {
+  LOG(ERROR) << "Blob directory successfully created "
+             << blob_storage_directory.value();
+  DCHECK(blob_storage_dir_.empty());
+  blob_storage_dir_ = blob_storage_directory;
+  if (context_) {
+    context_->EnableDisk(
+        blob_storage_dir_,
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
+  }
+}
+
 }  // namespace content