Try to flush DOMStorage too when ending the browsing session.

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/bind.h"
@@ skipping 230 matching lines @@
   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() {
+std::vector<scoped_refptr<base::SequencedTaskRunner>>
+DOMStorageContextWrapper::Flush() {
   DCHECK(context_.get());
+  std::vector<scoped_refptr<base::SequencedTaskRunner>> flush_runners;
+  if (mojo_state_) {
+    mojo_state_->Flush();
+    // TODO(michaeln): Add mojo impl task runners to flush_runners

[Marijn Kruisselbrink, 2017/04/12 21:55:58]

I'm a bit confused about the implied semantics of the list of task runners being
returned. Is it assumed that all async tasks that are necesary to flush data to
disk have been queued when Flush returns? Because that's going to be hard to
guarantee with the mojo implementation, with its multiple layers of mojo
services on top of each other... 
But anyway, for now the mojo impl would (potentially) involve at least tasks run
on the FILE and DB threads. But most of that is hidden behind mojo interfaces.

+  }
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
       base::Bind(&DOMStorageContextImpl::Flush, context_));
-  if (mojo_state_)
-    mojo_state_->Flush();
+  flush_runners.push_back(context_->task_runner()->GetSequencedTaskRunner(
+      DOMStorageTaskRunner::PRIMARY_SEQUENCE));
+  flush_runners.push_back(context_->task_runner()->GetSequencedTaskRunner(
+      DOMStorageTaskRunner::COMMIT_SEQUENCE));
+  return flush_runners;
 }
 
 void DOMStorageContextWrapper::OpenLocalStorage(
     const url::Origin& origin,
     mojom::LevelDBWrapperRequest request) {
   if (!mojo_state_)
     return;
   mojo_state_->OpenLocalStorage(origin, std::move(request));
 }
 
@@ skipping 25 matching lines @@
     GetLocalStorageUsageCallback callback,
     std::vector<LocalStorageUsageInfo> usage) {
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
       base::Bind(&GetLocalStorageUsageHelper, base::Passed(&usage),
                  base::RetainedRef(base::ThreadTaskRunnerHandle::Get()),
                  base::RetainedRef(context_), callback));
 }
 
 }  // namespace content