Migrate data from old localstorage format to new format.

content/browser/leveldb_wrapper_impl.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/bind.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/leveldb/public/cpp/util.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 
+void LevelDBWrapperImpl::Delegate::MigrateData(
+    base::OnceCallback<void(std::unique_ptr<ValueMap>)> callback) {
+  std::move(callback).Run(nullptr);
+}
+
 bool LevelDBWrapperImpl::s_aggressive_flushing_enabled_ = false;
 
 LevelDBWrapperImpl::RateLimiter::RateLimiter(size_t desired_rate,
                                             base::TimeDelta time_quantum)
     : rate_(desired_rate), samples_(0), time_quantum_(time_quantum) {
   DCHECK_GT(desired_rate, 0ul);
 }
 
 base::TimeDelta LevelDBWrapperImpl::RateLimiter::ComputeTimeNeeded() const {
   return time_quantum_ * (samples_ / rate_);
@@ skipping 10 matching lines @@
 LevelDBWrapperImpl::CommitBatch::CommitBatch() : clear_all_first(false) {}
 LevelDBWrapperImpl::CommitBatch::~CommitBatch() {}
 
 LevelDBWrapperImpl::LevelDBWrapperImpl(
     leveldb::mojom::LevelDBDatabase* database,
     const std::string& prefix,
     size_t max_size,
     base::TimeDelta default_commit_delay,
     int max_bytes_per_hour,
     int max_commits_per_hour,
-    const base::Closure& no_bindings_callback,
-    const PrepareToCommitCallback& prepare_to_commit_callback)
+    Delegate* delegate)
     : prefix_(leveldb::StdStringToUint8Vector(prefix)),
-      no_bindings_callback_(no_bindings_callback),
-      prepare_to_commit_callback_(prepare_to_commit_callback),
+      delegate_(delegate),
       database_(database),
       bytes_used_(0),
       max_size_(max_size),
       start_time_(base::TimeTicks::Now()),
       default_commit_delay_(default_commit_delay),
       data_rate_limiter_(max_bytes_per_hour, base::TimeDelta::FromHours(1)),
       commit_rate_limiter_(max_commits_per_hour, base::TimeDelta::FromHours(1)),
       weak_ptr_factory_(this) {
   bindings_.set_connection_error_handler(base::Bind(
       &LevelDBWrapperImpl::OnConnectionError, base::Unretained(this)));
@@ skipping 185 matching lines @@
   }
 }
 
 void LevelDBWrapperImpl::OnConnectionError() {
   if (!bindings_.empty())
     return;
   // If any tasks are waiting for load to complete, delay calling the
   // no_bindings_callback_ until all those tasks have completed.
   if (!on_load_complete_tasks_.empty())
     return;
-  no_bindings_callback_.Run();
+  delegate_->OnNoBindings();
 }
 
 void LevelDBWrapperImpl::LoadMap(const base::Closure& completion_callback) {
   DCHECK(!map_);
   on_load_complete_tasks_.push_back(completion_callback);
   if (on_load_complete_tasks_.size() > 1)
     return;
 
   if (!database_) {
-    OnLoadComplete(leveldb::mojom::DatabaseError::IO_ERROR,
-                   std::vector<leveldb::mojom::KeyValuePtr>());
+    OnMapLoaded(leveldb::mojom::DatabaseError::IO_ERROR,
+                std::vector<leveldb::mojom::KeyValuePtr>());
     return;
   }
 
   // TODO(michaeln): Import from sqlite localstorage db.
-  database_->GetPrefixed(prefix_,
-                         base::Bind(&LevelDBWrapperImpl::OnLoadComplete,
-                                    weak_ptr_factory_.GetWeakPtr()));
+  database_->GetPrefixed(prefix_, base::Bind(&LevelDBWrapperImpl::OnMapLoaded,
+                                             weak_ptr_factory_.GetWeakPtr()));
 }
 
-void LevelDBWrapperImpl::OnLoadComplete(
+void LevelDBWrapperImpl::OnMapLoaded(
     leveldb::mojom::DatabaseError status,
     std::vector<leveldb::mojom::KeyValuePtr> data) {
   DCHECK(!map_);
+
+  if (data.empty() && status == leveldb::mojom::DatabaseError::OK) {
+    delegate_->MigrateData(
+        base::BindOnce(&LevelDBWrapperImpl::OnGotMigrationData,
+                       weak_ptr_factory_.GetWeakPtr()));
+    return;
+  }
+
   map_.reset(new ValueMap);
   bytes_used_ = 0;
   for (auto& it : data) {
     DCHECK_GE(it->key.size(), prefix_.size());
     (*map_)[std::vector<uint8_t>(it->key.begin() + prefix_.size(),
                                  it->key.end())] = it->value;
     bytes_used_ += it->key.size() - prefix_.size() + it->value.size();
   }
 
   // We proceed without using a backing store, nothing will be persisted but the
   // class is functional for the lifetime of the object.
   // TODO(michaeln): Uma here or in the DB file?
   if (status != leveldb::mojom::DatabaseError::OK)
     database_ = nullptr;
 
+  OnLoadComplete();
+}
+
+void LevelDBWrapperImpl::OnGotMigrationData(std::unique_ptr<ValueMap> data) {
+  map_ = data ? std::move(data) : base::MakeUnique<ValueMap>();
+  bytes_used_ = 0;
+  for (const auto& it : *map_)
+    bytes_used_ += it.first.size() + it.second.size();
+
+  if (database_ && !empty()) {
+    CreateCommitBatchIfNeeded();
+    for (const auto& it : *map_)
+      commit_batch_->changed_keys.insert(it.first);
+    CommitChanges();
+  }
+
+  OnLoadComplete();
+}
+
+void LevelDBWrapperImpl::OnLoadComplete() {
   std::vector<base::Closure> tasks;
   on_load_complete_tasks_.swap(tasks);
   for (auto& task : tasks)
     task.Run();
 
   // We might need to call the no_bindings_callback_ here if bindings became
   // empty while waiting for load to complete.
   if (bindings_.empty())
-    no_bindings_callback_.Run();
+    delegate_->OnNoBindings();
 }
 
 void LevelDBWrapperImpl::CreateCommitBatchIfNeeded() {
   if (commit_batch_)
     return;
 
   commit_batch_.reset(new CommitBatch());
   BrowserThread::PostAfterStartupTask(
       FROM_HERE, base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&LevelDBWrapperImpl::StartCommitTimer,
@@ skipping 32 matching lines @@
 void LevelDBWrapperImpl::CommitChanges() {
   DCHECK(database_);
   DCHECK(map_);
   if (!commit_batch_)
     return;
 
   commit_rate_limiter_.add_samples(1);
 
   // Commit all our changes in a single batch.
   std::vector<leveldb::mojom::BatchedOperationPtr> operations =
-      prepare_to_commit_callback_.Run(*this);
+      delegate_->PrepareToCommit();
   if (commit_batch_->clear_all_first) {
     leveldb::mojom::BatchedOperationPtr item =
         leveldb::mojom::BatchedOperation::New();
     item->type = leveldb::mojom::BatchOperationType::DELETE_PREFIXED_KEY;
     item->key = prefix_;
     operations.push_back(std::move(item));
   }
   size_t data_size = 0;
   for (const auto& key: commit_batch_->changed_keys) {
     data_size += key.size();
@@ skipping 22 matching lines @@
   // will run during a clean shutdown. We need that to avoid dataloss.
   database_->Write(std::move(operations),
                    base::Bind(&LevelDBWrapperImpl::OnCommitComplete,
                               weak_ptr_factory_.GetWeakPtr()));
 }
 
 void LevelDBWrapperImpl::OnCommitComplete(leveldb::mojom::DatabaseError error) {
   // TODO(michaeln): What if it fails, uma here or in the DB class?
   --commit_batches_in_flight_;
   StartCommitTimer();
+  delegate_->DidCommit(error);
 }
 
 }  // namespace content