Add method to delete storage for origins to LocalStorageContextMojo.

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/strings/string_number_conversions.h"
 #include "components/leveldb/public/cpp/util.h"
 #include "components/leveldb/public/interfaces/leveldb.mojom.h"
@@ skipping 30 matching lines @@
 const int64_t kCurrentSchemaVersion = 1;
 
 std::vector<uint8_t> CreateMetaDataKey(const url::Origin& origin) {
   auto serialized_origin = leveldb::StdStringToUint8Vector(origin.Serialize());
   std::vector<uint8_t> key;
   key.reserve(arraysize(kMetaPrefix) + serialized_origin.size());
   key.insert(key.end(), kMetaPrefix, kMetaPrefix + arraysize(kMetaPrefix));
   key.insert(key.end(), serialized_origin.begin(), serialized_origin.end());
   return key;
 }
+
+void NoOpSuccess(bool success) {}
 }
 
 LocalStorageContextMojo::LocalStorageContextMojo(
     service_manager::Connector* connector,
     const base::FilePath& subdirectory)
     : connector_(connector),
       subdirectory_(subdirectory),
       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));
+    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));
+}
+
 void LocalStorageContextMojo::SetDatabaseForTesting(
     leveldb::mojom::LevelDBDatabasePtr database) {
   DCHECK_EQ(connection_state_, NO_CONNECTION);
   connection_state_ = CONNECTION_IN_PROGRESS;
   database_ = std::move(database);
   OnDatabaseOpened(leveldb::mojom::DatabaseError::OK);
 }
 
 void LocalStorageContextMojo::RunWhenConnected(base::OnceClosure callback) {
   // If we don't have a filesystem_connection_, we'll need to establish one.
@@ skipping 57 matching lines @@
     item->type = leveldb::mojom::BatchOperationType::PUT_KEY;
     item->key = leveldb::StdStringToUint8Vector(kVersionKey);
     item->value = leveldb::StdStringToUint8Vector(
         base::Int64ToString(kCurrentSchemaVersion));
     operations.push_back(std::move(item));
     database_initialized_ = true;
   }
 
   leveldb::mojom::BatchedOperationPtr item =
       leveldb::mojom::BatchedOperation::New();
+  item->type = leveldb::mojom::BatchOperationType::PUT_KEY;
   item->key = CreateMetaDataKey(origin);
   if (wrapper.bytes_used() == 0) {
     item->type = leveldb::mojom::BatchOperationType::DELETE_KEY;
   } else {
     item->type = leveldb::mojom::BatchOperationType::PUT_KEY;
     LocalStorageOriginMetaData data;
     data.set_last_modified(base::Time::Now().ToInternalValue());
     data.set_size_bytes(wrapper.bytes_used());
     item->value = leveldb::StdStringToUint8Vector(data.SerializeAsString());
   }
@@ skipping 90 matching lines @@
   for (size_t i = 0; i < on_database_opened_callbacks_.size(); ++i)
     std::move(on_database_opened_callbacks_[i]).Run();
   on_database_opened_callbacks_.clear();
 }
 
 // The (possibly delayed) implementation of OpenLocalStorage(). Can be called
 // directly from that function, or through |on_database_open_callbacks_|.
 void LocalStorageContextMojo::BindLocalStorage(
     const url::Origin& origin,
     mojom::LevelDBWrapperRequest request) {
+  GetOrCreateDBWrapper(origin)->Bind(std::move(request));
+}
+
+LevelDBWrapperImpl* LocalStorageContextMojo::GetOrCreateDBWrapper(
+    const url::Origin& origin) {
+  DCHECK_EQ(connection_state_, CONNECTION_FINISHED);
+  auto found = level_db_wrappers_.find(origin);
+  if (found != level_db_wrappers_.end())
+    return found->second.get();
+
   // Delay for a moment after a value is set in anticipation
   // of other values being set, so changes are batched.
   const int kCommitDefaultDelaySecs = 5;
 
   // To avoid excessive IO we apply limits to the amount of data being written
   // and the frequency of writes.
   const int kMaxBytesPerHour = kPerStorageAreaQuota;
   const int kMaxCommitsPerHour = 60;
 
-  auto found = level_db_wrappers_.find(origin);
-  if (found == level_db_wrappers_.end()) {
-    level_db_wrappers_[origin] = base::MakeUnique<LevelDBWrapperImpl>(
-        database_.get(), kDataPrefix + origin.Serialize() + kOriginSeparator,
-        kPerStorageAreaQuota + kPerStorageAreaOverQuotaAllowance,
-        base::TimeDelta::FromSeconds(kCommitDefaultDelaySecs), kMaxBytesPerHour,
-        kMaxCommitsPerHour,
-        base::Bind(&LocalStorageContextMojo::OnLevelDBWrapperHasNoBindings,
-                   base::Unretained(this), origin),
-        base::Bind(&LocalStorageContextMojo::OnLevelDBWrapperPrepareToCommit,
-                   base::Unretained(this), origin));
-    found = level_db_wrappers_.find(origin);
-  }
-
-  found->second->Bind(std::move(request));
+  auto wrapper = base::MakeUnique<LevelDBWrapperImpl>(
+      database_.get(), kDataPrefix + origin.Serialize() + kOriginSeparator,
+      kPerStorageAreaQuota + kPerStorageAreaOverQuotaAllowance,
+      base::TimeDelta::FromSeconds(kCommitDefaultDelaySecs), kMaxBytesPerHour,
+      kMaxCommitsPerHour,
+      base::Bind(&LocalStorageContextMojo::OnLevelDBWrapperHasNoBindings,
+                 base::Unretained(this), origin),
+      base::Bind(&LocalStorageContextMojo::OnLevelDBWrapperPrepareToCommit,
+                 base::Unretained(this), origin));
+  LevelDBWrapperImpl* wrapper_ptr = wrapper.get();
+  level_db_wrappers_[origin] = std::move(wrapper);
+  return wrapper_ptr;
 }
 
 void LocalStorageContextMojo::RetrieveStorageUsage(
     GetStorageUsageCallback callback) {
   database_->GetPrefixed(
       std::vector<uint8_t>(kMetaPrefix, kMetaPrefix + arraysize(kMetaPrefix)),
       base::Bind(&LocalStorageContextMojo::OnGotMetaData,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&callback)));
 }
 
@@ skipping 17 matching lines @@
       // TODO(mek): Deal with database corruption.
       continue;
     }
     info.data_size = data.size_bytes();
     info.last_modified = base::Time::FromInternalValue(data.last_modified());
     result.push_back(std::move(info));
   }
   std::move(callback).Run(std::move(result));
 }
 
+void LocalStorageContextMojo::OnGotStorageUsageForDeletePhysicalOrigin(
+    const url::Origin& origin,
+    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);
+}
+
 }  // namespace content