Switch to mojo localstorage backend by default.

content/browser/dom_storage/dom_storage_context_wrapper.cc

 // Copyright 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 "content/browser/dom_storage/dom_storage_context_wrapper.h"
 
 #include <string>
 #include <vector>
 
+#include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 12 matching lines @@
 #include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 
 namespace content {
 namespace {
 
 const char kLocalStorageDirectory[] = "Local Storage";
 const char kSessionStorageDirectory[] = "Session Storage";
 
 void InvokeLocalStorageUsageCallbackHelper(
-      const DOMStorageContext::GetLocalStorageUsageCallback& callback,
-      const std::vector<LocalStorageUsageInfo>* infos) {
+    const DOMStorageContext::GetLocalStorageUsageCallback& callback,
+    std::unique_ptr<std::vector<LocalStorageUsageInfo>> infos) {
   callback.Run(*infos);
 }
 
 void GetLocalStorageUsageHelper(
-    std::vector<LocalStorageUsageInfo> mojo_usage,
     base::SingleThreadTaskRunner* reply_task_runner,
     DOMStorageContextImpl* context,
     const DOMStorageContext::GetLocalStorageUsageCallback& callback) {
-  std::vector<LocalStorageUsageInfo>* infos =
-      new std::vector<LocalStorageUsageInfo>(std::move(mojo_usage));
-  context->GetLocalStorageUsage(infos, true);
+  auto infos = base::MakeUnique<std::vector<LocalStorageUsageInfo>>();

[dcheng, 2017/06/06 22:22:55]

Out of curiosity: why wrap it in unique_ptr? vector is movable (and we appear to
take advantage of this just a few lines below)

[Marijn Kruisselbrink, 2017/06/06 22:52:35]

Good question... The old code presumably wrapped it in a base::Owned raw pointer
because when it was written vector wasn't moveable and unique_ptr didn't exist.
The reason I kept it wrapped, but now in a unique_ptr is so
InvokeLocalStorageUsageCallbackHelper can be shared between both the sqlite-only
and the sqlite&leveldb/mojo code-path.

In that case in the GetLocalStorage implementation I want to be able to pass a
(raw pointer) to the same vector to two different callbacks, after which
InvokeLocalStorageUsageCallbackHelper gets called with the unique_ptr for that
same vector. If instead I just moved the vector itself to the callback that
binds InvokeLocalStorageUsageCallbackHelper I wouldn't be able to pass the
address to the vector also to the two separate callbacks (for getting sqlite
usage and getting leveldb usage).

[dcheng, 2017/06/06 23:02:44]

Ah, I see. The code felt kind of like it wanted promises. One thing I'm not sure
about is why we need to call both GetLocalStorageUsageHelper and
GetMojoLocalStorageUsage (i.e. what's the difference), so perhaps some comments
would help with making this part of the code more understandable to readers who
aren't familiar with it.

+  context->GetLocalStorageUsage(infos.get(), true);
   reply_task_runner->PostTask(
-      FROM_HERE, base::Bind(&InvokeLocalStorageUsageCallbackHelper, callback,
-                            base::Owned(infos)));
+      FROM_HERE, base::BindOnce(&InvokeLocalStorageUsageCallbackHelper,
+                                callback, std::move(infos)));
+}
+
+void CollectLocalStorageUsage(
+    std::vector<LocalStorageUsageInfo>* out_info,
+    base::Closure done_callback,
+    const std::vector<LocalStorageUsageInfo>& in_info) {
+  out_info->insert(out_info->end(), in_info.begin(), in_info.end());
+  done_callback.Run();
+}
+
+void GotMojoLocalStorageUsage(
+    scoped_refptr<base::SingleThreadTaskRunner> reply_task_runner,
+    const DOMStorageContext::GetLocalStorageUsageCallback& callback,
+    std::vector<LocalStorageUsageInfo> usage) {
+  reply_task_runner->PostTask(FROM_HERE,
+                              base::BindOnce(callback, std::move(usage)));
 }
 
 void InvokeSessionStorageUsageCallbackHelper(
       const DOMStorageContext::GetSessionStorageUsageCallback& callback,
       const std::vector<SessionStorageUsageInfo>* infos) {
   callback.Run(*infos);
 }
 
 void GetSessionStorageUsageHelper(
     base::SingleThreadTaskRunner* reply_task_runner,
@@ skipping 29 matching lines @@
 
   context_ = new DOMStorageContextImpl(
       data_path.empty() ? data_path
                         : data_path.AppendASCII(kLocalStorageDirectory),
       data_path.empty() ? data_path
                         : data_path.AppendASCII(kSessionStorageDirectory),
       special_storage_policy,
       new DOMStorageWorkerPoolTaskRunner(std::move(primary_sequence),
                                          std::move(commit_sequence)));
 
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kMojoLocalStorage)) {
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableMojoLocalStorage)) {
     base::FilePath storage_dir;
     if (!profile_path.empty())
       storage_dir = local_partition_path.AppendASCII(kLocalStorageDirectory);
     // TODO(mek): Use a SequencedTaskRunner once mojo no longer requires a
     // SingleThreadTaskRunner (http://crbug.com/678155).
     mojo_task_runner_ =
         BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
     mojo_state_ = new LocalStorageContextMojo(
         connector, context_->task_runner(),
         data_path.empty() ? data_path
@@ skipping 10 matching lines @@
 }
 
 DOMStorageContextWrapper::~DOMStorageContextWrapper() {
   DCHECK(!mojo_state_) << "Shutdown should be called before destruction";
 }
 
 void DOMStorageContextWrapper::GetLocalStorageUsage(
     const GetLocalStorageUsageCallback& callback) {
   DCHECK(context_.get());
   if (mojo_state_) {
+    auto infos = base::MakeUnique<std::vector<LocalStorageUsageInfo>>();
+    auto* infos_ptr = infos.get();
+    base::RepeatingClosure got_local_storage_usage = base::BarrierClosure(
+        2, base::BindOnce(&InvokeLocalStorageUsageCallbackHelper, callback,
+                          std::move(infos)));
+
     // base::Unretained is safe here, because the mojo_state_ won't be deleted
     // until a ShutdownAndDelete task has been ran on the mojo_task_runner_, and
     // as soon as that task is posted, mojo_state_ is set to null, preventing
     // further tasks from being queued.
     mojo_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(
             &LocalStorageContextMojo::GetStorageUsage,
             base::Unretained(mojo_state_),
-            base::BindOnce(
-                &DOMStorageContextWrapper::GotMojoLocalStorageUsage, this,
-                callback,
-                base::RetainedRef(base::ThreadTaskRunnerHandle::Get()))));
+            base::BindOnce(&GotMojoLocalStorageUsage,
+                           base::ThreadTaskRunnerHandle::Get(),
+                           base::Bind(CollectLocalStorageUsage, infos_ptr,
+                                      got_local_storage_usage))));
+    context_->task_runner()->PostShutdownBlockingTask(
+        FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
+        base::Bind(&GetLocalStorageUsageHelper,
+                   base::RetainedRef(base::ThreadTaskRunnerHandle::Get()),
+                   base::RetainedRef(context_),
+                   base::Bind(&CollectLocalStorageUsage, infos_ptr,
+                              got_local_storage_usage)));
     return;
   }
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
       base::Bind(&GetLocalStorageUsageHelper,
-                 std::vector<LocalStorageUsageInfo>(),
                  base::RetainedRef(base::ThreadTaskRunnerHandle::Get()),
                  base::RetainedRef(context_), callback));
 }
 
 void DOMStorageContextWrapper::GetSessionStorageUsage(
     const GetSessionStorageUsageCallback& callback) {
   DCHECK(context_.get());
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
       base::Bind(&GetSessionStorageUsageHelper,
@@ skipping 96 matching lines @@
     mojo_state_ = nullptr;
   }
   memory_pressure_listener_.reset();
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE,
       DOMStorageTaskRunner::PRIMARY_SEQUENCE,
       base::Bind(&DOMStorageContextImpl::Shutdown, context_));
   if (base::FeatureList::IsEnabled(features::kMemoryCoordinator)) {
     base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
   }
-
 }
 
 void DOMStorageContextWrapper::Flush() {
   DCHECK(context_.get());
 
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
       base::Bind(&DOMStorageContextImpl::Flush, context_));
   if (mojo_state_) {
     // base::Unretained is safe here, because the mojo_state_ won't be deleted
@@ skipping 14 matching lines @@
   // base::Unretained is safe here, because the mojo_state_ won't be deleted
   // until a ShutdownAndDelete task has been ran on the mojo_task_runner_, and
   // as soon as that task is posted, mojo_state_ is set to null, preventing
   // further tasks from being queued.
   mojo_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(&LocalStorageContextMojo::OpenLocalStorage,
                                 base::Unretained(mojo_state_), origin,
                                 std::move(request)));
 }
 
+void DOMStorageContextWrapper::SetLocalStorageDatabaseForTesting(
+    leveldb::mojom::LevelDBDatabaseAssociatedPtr database) {
+  if (!mojo_state_)
+    return;
+  // base::Unretained is safe here, because the mojo_state_ won't be deleted
+  // until a ShutdownAndDelete task has been ran on the mojo_task_runner_, and
+  // as soon as that task is posted, mojo_state_ is set to null, preventing
+  // further tasks from being queued.
+  mojo_task_runner_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&LocalStorageContextMojo::SetDatabaseForTesting,
+                     base::Unretained(mojo_state_), std::move(database)));
+}
+
 void DOMStorageContextWrapper::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   DOMStorageContextImpl::PurgeOption purge_option =
       DOMStorageContextImpl::PURGE_UNOPENED;
   if (memory_pressure_level ==
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
     purge_option = DOMStorageContextImpl::PURGE_AGGRESSIVE;
   }
   PurgeMemory(purge_option);
 }
@@ skipping 11 matching lines @@
     // base::Unretained is safe here, because the mojo_state_ won't be deleted
     // until a ShutdownAndDelete task has been ran on the mojo_task_runner_, and
     // as soon as that task is posted, mojo_state_ is set to null, preventing
     // further tasks from being queued.
     mojo_task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&LocalStorageContextMojo::PurgeMemory,
                                   base::Unretained(mojo_state_)));
   }
 }
 
-void DOMStorageContextWrapper::GotMojoLocalStorageUsage(
-    GetLocalStorageUsageCallback callback,
-    base::SingleThreadTaskRunner* reply_task_runner,
-    std::vector<LocalStorageUsageInfo> usage) {
-  context_->task_runner()->PostShutdownBlockingTask(
-      FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
-      base::Bind(&GetLocalStorageUsageHelper, base::Passed(&usage),
-                 base::RetainedRef(reply_task_runner),
-                 base::RetainedRef(context_), callback));
-}
-
 }  // namespace content