Start adding tests for LevelDBWrapper, and fix a bunch of bugs.

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"
@@ skipping 37 matching lines @@
 }
 
 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)
-    : prefix_(prefix),
+    : prefix_(leveldb::StdStringToUint8Vector(prefix)),
       no_bindings_callback_(no_bindings_callback),
       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(
@@ skipping 173 matching lines @@
   no_bindings_callback_.Run();
 }
 
 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;
 
   // TODO(michaeln): Import from sqlite localstorage db.
-  database_->GetPrefixed(leveldb::StdStringToUint8Vector(prefix_),
+  database_->GetPrefixed(prefix_,
                          base::Bind(&LevelDBWrapperImpl::OnLoadComplete,
                                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void LevelDBWrapperImpl::OnLoadComplete(
     leveldb::mojom::DatabaseError status,
     std::vector<leveldb::mojom::KeyValuePtr> data) {
   DCHECK(!map_);
   map_.reset(new ValueMap);
-  for (auto& it : data)
-    (*map_)[it->key] = it->value;
+  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;
+  }
 
   // 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;
 
   std::vector<base::Closure> tasks;
   on_load_complete_tasks_.swap(tasks);
   for (auto& task : tasks)
@@ skipping 35 matching lines @@
   base::TimeDelta delay = std::max(
       default_commit_delay_,
       std::max(commit_rate_limiter_.ComputeDelayNeeded(elapsed_time),
                data_rate_limiter_.ComputeDelayNeeded(elapsed_time)));
   // TODO(michaeln): UMA_HISTOGRAM_LONG_TIMES("LevelDBWrapper.CommitDelay", d);
   return delay;
 }
 
 void LevelDBWrapperImpl::CommitChanges() {
   DCHECK(database_);
-  if (commit_batch_)
+  if (!commit_batch_)
     return;
 
   commit_rate_limiter_.add_samples(1);
   data_rate_limiter_.add_samples(commit_batch_->GetDataSize());
 
   // Commit all our changes in a single batch.
   std::vector<leveldb::mojom::BatchedOperationPtr> operations;
   if (commit_batch_->clear_all_first) {
     leveldb::mojom::BatchedOperationPtr item =
         leveldb::mojom::BatchedOperation::New();
     item->type = leveldb::mojom::BatchOperationType::DELETE_PREFIXED_KEY;
-    item->key = leveldb::StdStringToUint8Vector(prefix_);
+    item->key = prefix_;
     operations.push_back(std::move(item));
   }
   for (auto& it : commit_batch_->changed_values) {
     leveldb::mojom::BatchedOperationPtr item =
         leveldb::mojom::BatchedOperation::New();
-    item->key = std::move(it.first);
+    item->key.reserve(prefix_.size() + it.first.size());
+    item->key.insert(item->key.end(), prefix_.begin(), prefix_.end());
+    item->key.insert(item->key.end(), it.first.begin(), it.first.end());
     if (!it.second) {
       item->type = leveldb::mojom::BatchOperationType::DELETE_KEY;
     } else {
       item->type = leveldb::mojom::BatchOperationType::PUT_KEY;
       item->value = std::move(*(it.second));
     }
     operations.push_back(std::move(item));
   }
   commit_batch_.reset();
 
   ++commit_batches_in_flight_;
 
   // TODO(michaeln): Currently there is no guarantee LevelDBDatabaseImp::Write
   // 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();
 }
 
 }  // namespace content