Purge new localstorage memory cache when under memory pressure.

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 38 matching lines @@
   base::Closure m_callback;
 };
 
 class MockDelegate : public LevelDBWrapperImpl::Delegate {
  public:
   void OnNoBindings() override {}
   std::vector<leveldb::mojom::BatchedOperationPtr> PrepareToCommit() override {
     return std::vector<leveldb::mojom::BatchedOperationPtr>();
   }
   void DidCommit(leveldb::mojom::DatabaseError error) override {}
+  void OnMapLoaded(leveldb::mojom::DatabaseError error) override {
+    map_load_count_++;
+  }
+
+  int map_load_count() const { return map_load_count_; }
+
+ private:
+  int map_load_count_ = 0;
 };
 
 void GetCallback(const base::Closure& callback,
                  bool* success_out,
                  std::vector<uint8_t>* value_out,
                  bool success,
                  const std::vector<uint8_t>& value) {
   *success_out = success;
   *value_out = value;
   callback.Run();
@@ skipping 56 matching lines @@
 
   std::string get_mock_data(const std::string& key) {
     return has_mock_data(key)
                ? Uint8VectorToStdString(mock_data_[StdStringToUint8Vector(key)])
                : "";
   }
 
   void clear_mock_data() { mock_data_.clear(); }
 
   mojom::LevelDBWrapper* wrapper() { return level_db_wrapper_ptr_.get(); }
+  LevelDBWrapperImpl* wrapper_impl() { return &level_db_wrapper_; }
 
   bool GetSync(const std::vector<uint8_t>& key, std::vector<uint8_t>* result) {
     base::RunLoop run_loop;
     bool success = false;
     wrapper()->Get(key, base::Bind(&GetCallback, run_loop.QuitClosure(),
                                    &success, result));
     run_loop.Run();
     return success;
   }
 
@@ skipping 26 matching lines @@
         kTestSource,
         base::Bind(&SuccessCallback, run_loop.QuitClosure(), &success));
     run_loop.Run();
     return success;
   }
 
   void CommitChanges() { level_db_wrapper_.ScheduleImmediateCommit(); }
 
   const std::vector<Observation>& observations() { return observations_; }
 
+  MockDelegate* delegate() { return &delegate_; }
+
  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});
   }
   void KeyChanged(const std::vector<uint8_t>& key,
                   const std::vector<uint8_t>& new_value,
@@ skipping 282 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));
 }
 
+TEST_F(LevelDBWrapperImplTest, GetAfterPurgeMemory) {
+  std::vector<uint8_t> result;
+  EXPECT_TRUE(GetSync(StdStringToUint8Vector("123"), &result));
+  EXPECT_EQ(StdStringToUint8Vector("123data"), result);
+  EXPECT_EQ(delegate()->map_load_count(), 1);
+
+  // Reading again doesn't load map again.
+  EXPECT_TRUE(GetSync(StdStringToUint8Vector("123"), &result));
+  EXPECT_EQ(delegate()->map_load_count(), 1);
+
+  wrapper_impl()->PurgeMemory();
+
+  // Now reading should still work, and load map again.
+  result.clear();
+  EXPECT_TRUE(GetSync(StdStringToUint8Vector("123"), &result));
+  EXPECT_EQ(StdStringToUint8Vector("123data"), result);
+  EXPECT_EQ(delegate()->map_load_count(), 2);
+}
+
+TEST_F(LevelDBWrapperImplTest, PurgeMemoryWithPendingChanges) {
+  std::vector<uint8_t> key = StdStringToUint8Vector("123");
+  std::vector<uint8_t> value = StdStringToUint8Vector("foo");
+  EXPECT_TRUE(PutSync(key, value));
+  EXPECT_EQ(delegate()->map_load_count(), 1);
+
+  // Purge memory, and read. Should not actually have purged, so should not have
+  // triggered a load.
+  wrapper_impl()->PurgeMemory();
+
+  std::vector<uint8_t> result;
+  EXPECT_TRUE(GetSync(key, &result));
+  EXPECT_EQ(value, result);
+  EXPECT_EQ(delegate()->map_load_count(), 1);
+}
+
 }  // namespace content