Clear up session only storage on localstorage shutdown

content/browser/dom_storage/local_storage_context_mojo.cc

 // Copyright 2016 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/local_storage_context_mojo.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/leveldb/public/cpp/util.h"
 #include "components/leveldb/public/interfaces/leveldb.mojom.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_database.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/browser/dom_storage/local_storage_database.pb.h"
 #include "content/browser/leveldb_wrapper_impl.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "services/file/public/interfaces/constants.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "sql/connection.h"
+#include "storage/browser/quota/special_storage_policy.h"
 #include "third_party/leveldatabase/env_chromium.h"
 
 namespace content {
 
 // LevelDB database schema
 // =======================
 //
 // Version 1 (in sorted order):
 //   key: "VERSION"
 //   value: "1"
@@ skipping 180 matching lines @@
   // called and need access  to the LevelDBWrapperImpl instance. The unique_ptr
   // could already be null, but this field should still be valid.
   LevelDBWrapperImpl* level_db_wrapper_ptr_;
   bool deleted_old_data_ = false;
 };
 
 LocalStorageContextMojo::LocalStorageContextMojo(
     service_manager::Connector* connector,
     scoped_refptr<DOMStorageTaskRunner> task_runner,
     const base::FilePath& old_localstorage_path,
-    const base::FilePath& subdirectory)
-    : connector_(connector),
+    const base::FilePath& subdirectory,
+    storage::SpecialStoragePolicy* special_storage_policy)
+    : connector_(connector ? connector->Clone() : nullptr),
       subdirectory_(subdirectory),
+      special_storage_policy_(special_storage_policy),
       task_runner_(std::move(task_runner)),
       old_localstorage_path_(old_localstorage_path),
       weak_ptr_factory_(this) {}
 
-LocalStorageContextMojo::~LocalStorageContextMojo() {}
-
 void LocalStorageContextMojo::OpenLocalStorage(
     const url::Origin& origin,
     mojom::LevelDBWrapperRequest request) {
   RunWhenConnected(base::BindOnce(&LocalStorageContextMojo::BindLocalStorage,
                                   weak_ptr_factory_.GetWeakPtr(), origin,
                                   std::move(request)));
 }
 
 void LocalStorageContextMojo::GetStorageUsage(
     GetStorageUsageCallback callback) {
   RunWhenConnected(
       base::BindOnce(&LocalStorageContextMojo::RetrieveStorageUsage,
                      weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void LocalStorageContextMojo::DeleteStorage(const url::Origin& origin) {
   if (connection_state_ != CONNECTION_FINISHED) {
-    RunWhenConnected(base::BindOnce(&LocalStorageContextMojo::DeleteStorage,
-                                    weak_ptr_factory_.GetWeakPtr(), origin));
+    RunWhenConnected(
+        base::BindOnce(&LocalStorageContextMojo::DeleteStorage, this, origin));
     return;
   }
 
   LevelDBWrapperImpl* wrapper = GetOrCreateDBWrapper(origin);
   // Renderer process expects |source| to always be two newline separated
   // strings.
   wrapper->DeleteAll("\n", base::Bind(&NoOpSuccess));
   wrapper->ScheduleImmediateCommit();
 }
 
 void LocalStorageContextMojo::DeleteStorageForPhysicalOrigin(
     const url::Origin& origin) {
   GetStorageUsage(base::BindOnce(
-      &LocalStorageContextMojo::OnGotStorageUsageForDeletePhysicalOrigin,
-      weak_ptr_factory_.GetWeakPtr(), origin));
+      &LocalStorageContextMojo::OnGotStorageUsageForDeletePhysicalOrigin, this,
+      origin));
 }
 
 void LocalStorageContextMojo::Flush() {
   if (connection_state_ != CONNECTION_FINISHED) {
     RunWhenConnected(base::BindOnce(&LocalStorageContextMojo::Flush,
                                     weak_ptr_factory_.GetWeakPtr()));
     return;
   }
   for (const auto& it : level_db_wrappers_)
     it.second->level_db_wrapper()->ScheduleImmediateCommit();
 }
 
+void LocalStorageContextMojo::Shutdown() {
+  DCHECK(!is_shutdown_);
+  DCHECK_NE(connection_state_, CONNECTION_SHUTDOWN);
+
+  // Nothing to do if no connection to the database was ever made.
+  if (connection_state_ == NO_CONNECTION) {
+    connection_state_ = CONNECTION_SHUTDOWN;
+    is_shutdown_ = true;
+    return;
+  }
+
+  if (connection_state_ != CONNECTION_FINISHED) {

[michaeln, 2017/05/03 21:01:29]

Similar to the NO_CONNECTION case, maybe we don't need to go thru the shutdown
sequence here either? If we're shutting down prior to being connected, either
the connection was taking forever to happen or the browsing session is super
short, both are exceptional cases in one way or another. I'd vote to try to do
less here and slam the connection state SHUTDOWN.

 670   is_shutdown_ = true;
 671   file_system_.reset();
 672   directory_.reset();
 673   leveldb_service_.reset();
 674   level_db_wrappers_.clear();
 675   database_.reset();
 676   connector_.reset();

Would it work to just pull the plug like that?

[Marijn Kruisselbrink, 2017/05/04 23:03:46]

Yeah, agreed that it makes sense to just immediately self-destruct when no
connection has been made yet. Incidentally I think that might also fix some
other (unrelated) issues I was having in a different CL...

+    RunWhenConnected(base::BindOnce(&LocalStorageContextMojo::Shutdown, this));
+    return;
+  }
+
+  connection_state_ = CONNECTION_SHUTDOWN;
+
+  // Flush any uncommitted data.
+  for (const auto& it : level_db_wrappers_)
+    it.second->level_db_wrapper()->ScheduleImmediateCommit();
+
+  // Respect the content policy settings about what to
+  // keep and what to discard.
+  if (force_keep_session_state_) {
+    OnShutdownCommitComplete(leveldb::mojom::DatabaseError::OK);
+    return;  // Keep everything.
+  }
+
+  bool has_session_only_origins =
+      special_storage_policy_.get() &&
+      special_storage_policy_->HasSessionOnlyOrigins();
+
+  if (has_session_only_origins) {
+    RetrieveStorageUsage(base::BindOnce(
+        &LocalStorageContextMojo::OnGotStorageUsageForShutdown, this));
+  } else {
+    OnShutdownCommitComplete(leveldb::mojom::DatabaseError::OK);
+  }
+}
+
 void LocalStorageContextMojo::PurgeMemory() {
   for (const auto& it : level_db_wrappers_)
     it.second->level_db_wrapper()->PurgeMemory();
 }
 
 leveldb::mojom::LevelDBDatabaseAssociatedRequest
 LocalStorageContextMojo::DatabaseRequestForTesting() {
   DCHECK_EQ(connection_state_, NO_CONNECTION);
   connection_state_ = CONNECTION_IN_PROGRESS;
   leveldb::mojom::LevelDBDatabaseAssociatedRequest request =
       MakeIsolatedRequest(&database_);
   OnDatabaseOpened(true, leveldb::mojom::DatabaseError::OK);
   return request;
 }
 
 // static
 std::vector<uint8_t> LocalStorageContextMojo::MigrateString(
     const base::string16& input) {
   static const uint8_t kUTF16Format = 0;
 
   const uint8_t* data = reinterpret_cast<const uint8_t*>(input.data());
   std::vector<uint8_t> result;
   result.reserve(input.size() * sizeof(base::char16) + 1);
   result.push_back(kUTF16Format);
   result.insert(result.end(), data, data + input.size() * sizeof(base::char16));
   return result;
 }
 
+LocalStorageContextMojo::~LocalStorageContextMojo() {
+  DCHECK(is_shutdown_);
+  DCHECK_EQ(connection_state_, CONNECTION_SHUTDOWN);
+}
+
 void LocalStorageContextMojo::RunWhenConnected(base::OnceClosure callback) {
+  DCHECK_NE(connection_state_, CONNECTION_SHUTDOWN);
+
   // If we don't have a filesystem_connection_, we'll need to establish one.
   if (connection_state_ == NO_CONNECTION) {
     connection_state_ = CONNECTION_IN_PROGRESS;
     InitiateConnection();
   }
 
   if (connection_state_ == CONNECTION_IN_PROGRESS) {
     // Queue this OpenLocalStorage call for when we have a level db pointer.
     on_database_opened_callbacks_.push_back(std::move(callback));
     return;
@@ skipping 261 matching lines @@
     std::vector<LocalStorageUsageInfo> usage) {
   for (const auto& info : usage) {
     url::Origin origin_candidate(info.origin);
     if (!origin_candidate.IsSameOriginWith(origin) &&
         origin_candidate.IsSamePhysicalOriginWith(origin))
       DeleteStorage(origin_candidate);
   }
   DeleteStorage(origin);
 }
 
+void LocalStorageContextMojo::OnGotStorageUsageForShutdown(
+    std::vector<LocalStorageUsageInfo> usage) {
+  std::vector<leveldb::mojom::BatchedOperationPtr> operations;
+  for (const auto& info : usage) {
+    if (special_storage_policy_->IsStorageProtected(info.origin))
+      continue;
+    if (!special_storage_policy_->IsStorageSessionOnly(info.origin))
+      continue;
+
+    url::Origin origin(info.origin);

[michaeln, 2017/05/03 21:01:29]

i see you've copied the behavior for the sqlite impl, not for this cl, but i'm
not sure this properly accounts for suborigins?

[Marijn Kruisselbrink, 2017/05/04 23:03:46]

Not sure.. but I imagine properly accounting for suborigins should happen inside
SpecialStoragePolicy's IsStorageProtected and IsStorageSessionOnly methods,
after which this should automatically do the right thing.

+    leveldb::mojom::BatchedOperationPtr item =
+        leveldb::mojom::BatchedOperation::New();
+    item->type = leveldb::mojom::BatchOperationType::DELETE_PREFIXED_KEY;
+    item->key = leveldb::StdStringToUint8Vector(
+        kDataPrefix + origin.Serialize() + kOriginSeparator);
+    operations.push_back(std::move(item));
+
+    item = leveldb::mojom::BatchedOperation::New();
+    item->type = leveldb::mojom::BatchOperationType::DELETE_KEY;
+    item->key = CreateMetaDataKey(origin);
+    operations.push_back(std::move(item));
+  }
+
+  if (!operations.empty()) {
+    database_->Write(
+        std::move(operations),
+        base::Bind(&LocalStorageContextMojo::OnShutdownCommitComplete, this));
+  } else {
+    OnShutdownCommitComplete(leveldb::mojom::DatabaseError::OK);
+  }
+}
+
+void LocalStorageContextMojo::OnShutdownCommitComplete(
+    leveldb::mojom::DatabaseError error) {
+  is_shutdown_ = true;
+  file_system_.reset();
+  directory_.reset();
+  leveldb_service_.reset();
+  level_db_wrappers_.clear();
+  database_.reset();
+  connector_.reset();
+}
+
 }  // namespace content