Wipe out offline page data on clearing cookie and site data

components/leveldb_proto/proto_database_impl.h

 // Copyright 2014 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.
 
 #ifndef COMPONENTS_LEVELDB_PROTO_PROTO_DATABASE_IMPL_H_
 #define COMPONENTS_LEVELDB_PROTO_PROTO_DATABASE_IMPL_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 31 matching lines @@
   //     part of the constructor
   void Init(const char* client_name,
             const base::FilePath& database_dir,
             const typename ProtoDatabase<T>::InitCallback& callback) override;
   void UpdateEntries(
       scoped_ptr<typename ProtoDatabase<T>::KeyEntryVector> entries_to_save,
       scoped_ptr<KeyVector> keys_to_remove,
       const typename ProtoDatabase<T>::UpdateCallback& callback) override;
   void LoadEntries(
       const typename ProtoDatabase<T>::LoadCallback& callback) override;
+  void Destroy(
+      const typename ProtoDatabase<T>::DestroyCallback& callback) override;
 
   // Allow callers to provide their own Database implementation.
   void InitWithDatabase(
       scoped_ptr<LevelDB> database,
       const base::FilePath& database_dir,
       const typename ProtoDatabase<T>::InitCallback& callback);
 
  private:
   base::ThreadChecker thread_checker_;
 
   // Used to run blocking tasks in-order.
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   scoped_ptr<LevelDB> db_;
+  base::FilePath database_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(ProtoDatabaseImpl);
 };
 
 namespace {
 
 template <typename T>
 void RunInitCallback(const typename ProtoDatabase<T>::InitCallback& callback,
                      const bool* success) {
   callback.Run(*success);
 }
 
 template <typename T>
 void RunUpdateCallback(
     const typename ProtoDatabase<T>::UpdateCallback& callback,
     const bool* success) {
   callback.Run(*success);
 }
 
 template <typename T>
 void RunLoadCallback(const typename ProtoDatabase<T>::LoadCallback& callback,
                      const bool* success,
                      scoped_ptr<std::vector<T>> entries) {
   callback.Run(*success, entries.Pass());
 }
 
+template <typename T>
+void RunDestroyCallback(
+    const typename ProtoDatabase<T>::DestroyCallback& callback,
+    const bool* success) {
+  callback.Run(*success);
+}
+
 void InitFromTaskRunner(LevelDB* database, const base::FilePath& database_dir,
                         bool* success) {
   DCHECK(success);
 
   // TODO(cjhopman): Histogram for database size.
   *success = database->Init(database_dir);
 }
 
+void DestroyFromTaskRunner(const base::FilePath& database_dir, bool* success) {
+  CHECK(success);
+
+  *success = LevelDB::Destroy(database_dir);
+}
+
 template <typename T>
 void UpdateEntriesFromTaskRunner(
     LevelDB* database,
     scoped_ptr<typename ProtoDatabase<T>::KeyEntryVector> entries_to_save,
     scoped_ptr<KeyVector> keys_to_remove,
     bool* success) {
   DCHECK(success);
 
   // Serialize the values from Proto to string before passing on to database.
   KeyValueVector pairs_to_save;
@@ skipping 41 matching lines @@
   if (!task_runner_->DeleteSoon(FROM_HERE, db_.release()))
     DLOG(WARNING) << "Proto database will not be deleted.";
 }
 
 template <typename T>
 void ProtoDatabaseImpl<T>::Init(
     const char* client_name,
     const base::FilePath& database_dir,
     const typename ProtoDatabase<T>::InitCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  database_dir_ = database_dir;
   InitWithDatabase(make_scoped_ptr(new LevelDB(client_name)), database_dir,
                    callback);
 }
 
 template <typename T>
+void ProtoDatabaseImpl<T>::Destroy(
+    const typename ProtoDatabase<T>::DestroyCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(db_);
+  DCHECK(!database_dir_.empty());
+  db_.reset();
+  bool* success = new bool(false);
+  task_runner_->PostTaskAndReply(
+      FROM_HERE, base::Bind(DestroyFromTaskRunner, database_dir_, success),
+      base::Bind(RunDestroyCallback<T>, callback, base::Owned(success)));
+}
+
+template <typename T>
 void ProtoDatabaseImpl<T>::InitWithDatabase(
     scoped_ptr<LevelDB> database,
     const base::FilePath& database_dir,
     const typename ProtoDatabase<T>::InitCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!db_);
   DCHECK(database);
   db_.reset(database.release());
   bool* success = new bool(false);
   task_runner_->PostTaskAndReply(
@@ skipping 30 matching lines @@
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(LoadEntriesFromTaskRunner<T>,
                             base::Unretained(db_.get()), entries_ptr, success),
       base::Bind(RunLoadCallback<T>, callback, base::Owned(success),
                  base::Passed(&entries)));
 }
 
 }  // namespace leveldb_proto
 
 #endif  // COMPONENTS_LEVELDB_PROTO_PROTO_DATABASE_IMPL_H_