Add method to delete storage for origins to LocalStorageContextMojo.

content/browser/leveldb_wrapper_impl_unittest.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/leveldb_wrapper_impl.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "components/leveldb/public/cpp/util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
@@ skipping 57 matching lines @@
   callback.Run();
 }
 
 void SuccessCallback(const base::Closure& callback,
                      bool* success_out,
                      bool success) {
   *success_out = success;
   callback.Run();
 }
 
+void NoOpSuccessCallback(bool success) {}
+
 }  // namespace
 
 class LevelDBWrapperImplTest : public testing::Test,
                                public mojom::LevelDBObserver {
  public:
   struct Observation {
     enum { kAdd, kChange, kDelete, kDeleteAll } type;
     std::string key;
     std::string old_value;
     std::string new_value;
@@ skipping 79 matching lines @@
   bool DeleteAllSync() {
     base::RunLoop run_loop;
     bool success = false;
     wrapper()->DeleteAll(
         kTestSource,
         base::Bind(&SuccessCallback, run_loop.QuitClosure(), &success));
     run_loop.Run();
     return success;
   }
 
-  void CommitChanges() {
-    ASSERT_TRUE(level_db_wrapper_.commit_batch_);
-    level_db_wrapper_.CommitChanges();
-  }
+  void CommitChanges() { level_db_wrapper_.ScheduleImmediateCommit(); }
 
   const std::vector<Observation>& observations() { return observations_; }
 
  private:
   // LevelDBObserver:
   void KeyAdded(const std::vector<uint8_t>& key,
                 const std::vector<uint8_t>& value,
                 const std::string& source) override {
     observations_.push_back({Observation::kAdd, Uint8VectorToStdString(key), "",
                              Uint8VectorToStdString(value), source});
@@ skipping 134 matching lines @@
   EXPECT_EQ(key, observations()[0].key);
   EXPECT_EQ(value, observations()[0].old_value);
   EXPECT_EQ(kTestSource, observations()[0].source);
 
   EXPECT_TRUE(has_mock_data(kTestPrefix + key));
 
   CommitChanges();
   EXPECT_FALSE(has_mock_data(kTestPrefix + key));
 }
 
-TEST_F(LevelDBWrapperImplTest, DeleteAll) {
+TEST_F(LevelDBWrapperImplTest, DeleteAllWithoutLoadedMap) {
   std::string key = "newkey";
   std::string value = "foo";
   std::string dummy_key = "foobar";
   set_mock_data(dummy_key, value);
   set_mock_data(kTestPrefix + key, value);
 
   EXPECT_TRUE(DeleteAllSync());
   ASSERT_EQ(1u, observations().size());
   EXPECT_EQ(Observation::kDeleteAll, observations()[0].type);
   EXPECT_EQ(kTestSource, observations()[0].source);
 
   EXPECT_TRUE(has_mock_data(kTestPrefix + key));
   EXPECT_TRUE(has_mock_data(dummy_key));
 
   CommitChanges();
   EXPECT_FALSE(has_mock_data(kTestPrefix + key));
   EXPECT_TRUE(has_mock_data(dummy_key));
 
   // Deleting all again should still work, an cause an observation.
   EXPECT_TRUE(DeleteAllSync());
   ASSERT_EQ(2u, observations().size());
   EXPECT_EQ(Observation::kDeleteAll, observations()[1].type);
   EXPECT_EQ(kTestSource, observations()[1].source);
 
   // And now we've deleted all, writing something the quota size should work.
   EXPECT_TRUE(PutSync(std::vector<uint8_t>(kTestSizeLimit, 'b'),
                       std::vector<uint8_t>()));
 }
 
+TEST_F(LevelDBWrapperImplTest, DeleteAllWithLoadedMap) {
+  std::string key = "newkey";
+  std::string value = "foo";
+  std::string dummy_key = "foobar";
+  set_mock_data(dummy_key, value);
+
+  EXPECT_TRUE(
+      PutSync(StdStringToUint8Vector(key), StdStringToUint8Vector(value)));
+
+  EXPECT_TRUE(DeleteAllSync());
+  ASSERT_EQ(2u, observations().size());
+  EXPECT_EQ(Observation::kDeleteAll, observations()[1].type);
+  EXPECT_EQ(kTestSource, observations()[1].source);
+
+  EXPECT_TRUE(has_mock_data(dummy_key));
+
+  CommitChanges();
+  EXPECT_FALSE(has_mock_data(kTestPrefix + key));
+  EXPECT_TRUE(has_mock_data(dummy_key));
+}
+
+TEST_F(LevelDBWrapperImplTest, DeleteAllWithPendingMapLoad) {
+  std::string key = "newkey";
+  std::string value = "foo";
+  std::string dummy_key = "foobar";
+  set_mock_data(dummy_key, value);
+
+  wrapper()->Put(StdStringToUint8Vector(key), StdStringToUint8Vector(value),
+                 kTestSource, base::Bind(&NoOpSuccessCallback));
+
+  EXPECT_TRUE(DeleteAllSync());
+  ASSERT_EQ(2u, observations().size());
+  EXPECT_EQ(Observation::kDeleteAll, observations()[1].type);
+  EXPECT_EQ(kTestSource, observations()[1].source);
+
+  EXPECT_TRUE(has_mock_data(dummy_key));
+
+  CommitChanges();
+  EXPECT_FALSE(has_mock_data(kTestPrefix + key));
+  EXPECT_TRUE(has_mock_data(dummy_key));
+}
+
 TEST_F(LevelDBWrapperImplTest, PutOverQuotaLargeValue) {
   std::vector<uint8_t> key = StdStringToUint8Vector("newkey");
   std::vector<uint8_t> value(kTestSizeLimit, 4);
 
   EXPECT_FALSE(PutSync(key, value));
 
   value.resize(kTestSizeLimit / 2);
   EXPECT_TRUE(PutSync(key, value));
 }
 
@@ skipping 50 matching lines @@
   // Reducing size should also succeed.
   value.clear();
   EXPECT_TRUE(PutSync(key, value));
 
   // Increasing size should fail.
   value.resize(1, 'a');
   EXPECT_FALSE(PutSync(key, value));
 }
 
 }  // namespace content