[Leveldb] Use std::{string,vector} instead of mojo::{String,Array}.

components/leveldb/leveldb_database_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 "components/leveldb/leveldb_database_impl.h"
 
 #include <map>
 #include <string>
 
+#include "base/optional.h"
 #include "base/rand_util.h"
 #include "components/leveldb/env_mojo.h"
 #include "components/leveldb/public/cpp/util.h"
-#include "mojo/common/common_type_converters.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 namespace leveldb {
 namespace {
 
 template <typename T>
 uint64_t GetSafeRandomId(const std::map<uint64_t, T>& m) {
   // Associate a random unsigned 64 bit handle to |s|, checking for the highly
   // improbable id duplication or castability to null.
@@ skipping 29 matching lines @@
       environment_(std::move(environment)),
       db_(std::move(db)) {}
 
 LevelDBDatabaseImpl::~LevelDBDatabaseImpl() {
   for (auto& p : iterator_map_)
     delete p.second;
   for (auto& p : snapshot_map_)
     db_->ReleaseSnapshot(p.second);
 }
 
-void LevelDBDatabaseImpl::Put(mojo::Array<uint8_t> key,
-                              mojo::Array<uint8_t> value,
+void LevelDBDatabaseImpl::Put(const std::vector<uint8_t>& key,
+                              const std::vector<uint8_t>& value,
                               const PutCallback& callback) {
   leveldb::Status status =
       db_->Put(leveldb::WriteOptions(), GetSliceFor(key), GetSliceFor(value));
   callback.Run(LeveldbStatusToError(status));
 }
 
-void LevelDBDatabaseImpl::Delete(mojo::Array<uint8_t> key,
+void LevelDBDatabaseImpl::Delete(const std::vector<uint8_t>& key,
                                  const DeleteCallback& callback) {
   leveldb::Status status =
       db_->Delete(leveldb::WriteOptions(), GetSliceFor(key));
   callback.Run(LeveldbStatusToError(status));
 }
 
 void LevelDBDatabaseImpl::DeletePrefixed(
-    mojo::Array<uint8_t> key_prefix,
+    const std::vector<uint8_t>& key_prefix,
     const DeletePrefixedCallback& callback) {
   leveldb::WriteBatch batch;
   leveldb::Status status = DeletePrefixedHelper(
       GetSliceFor(key_prefix), &batch);
   if (status.ok())
     status = db_->Write(leveldb::WriteOptions(), &batch);
   callback.Run(LeveldbStatusToError(status));
 }
 
 void LevelDBDatabaseImpl::Write(
-    mojo::Array<mojom::BatchedOperationPtr> operations,
+    std::vector<mojom::BatchedOperationPtr> operations,
     const WriteCallback& callback) {
   leveldb::WriteBatch batch;
 
   for (size_t i = 0; i < operations.size(); ++i) {
     switch (operations[i]->type) {
       case mojom::BatchOperationType::PUT_KEY: {
-        batch.Put(GetSliceFor(operations[i]->key),
-                  GetSliceFor(operations[i]->value));
+        if (operations[i]->value) {
+          batch.Put(GetSliceFor(operations[i]->key),
+                    GetSliceFor(*(operations[i]->value)));
+        } else {
+          batch.Put(GetSliceFor(operations[i]->key), leveldb::Slice());
+        }
         break;
       }
       case mojom::BatchOperationType::DELETE_KEY: {
         batch.Delete(GetSliceFor(operations[i]->key));
         break;
       }
       case mojom::BatchOperationType::DELETE_PREFIXED_KEY: {
         DeletePrefixedHelper(GetSliceFor(operations[i]->key), &batch);
         break;
       }
     }
   }
 
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
   callback.Run(LeveldbStatusToError(status));
 }
 
-void LevelDBDatabaseImpl::Get(mojo::Array<uint8_t> key,
+void LevelDBDatabaseImpl::Get(const std::vector<uint8_t>& key,
                               const GetCallback& callback) {
   std::string value;
   leveldb::Status status =
       db_->Get(leveldb::ReadOptions(), GetSliceFor(key), &value);
-  callback.Run(LeveldbStatusToError(status), mojo::Array<uint8_t>::From(value));
+  callback.Run(LeveldbStatusToError(status), StdStringToUint8Vector(value));
 }
 
-void LevelDBDatabaseImpl::GetPrefixed(mojo::Array<uint8_t> key_prefix,
+void LevelDBDatabaseImpl::GetPrefixed(const std::vector<uint8_t>& key_prefix,
                                       const GetPrefixedCallback& callback) {
-  mojo::Array<mojom::KeyValuePtr> data;
+  std::vector<mojom::KeyValuePtr> data;
   leveldb::Status status = ForEachWithPrefix(
       db_.get(), GetSliceFor(key_prefix),
       [&data](const leveldb::Slice& key, const leveldb::Slice& value) {
         mojom::KeyValuePtr kv = mojom::KeyValue::New();
-        kv->key = GetArrayFor(key);
-        kv->value = GetArrayFor(value);
+        kv->key = GetVectorFor(key);
+        kv->value = GetVectorFor(value);
         data.push_back(std::move(kv));
       });
   callback.Run(LeveldbStatusToError(status), std::move(data));
 }
 
 void LevelDBDatabaseImpl::GetSnapshot(const GetSnapshotCallback& callback) {
   const Snapshot* s = db_->GetSnapshot();
   uint64_t new_id = GetSafeRandomId(snapshot_map_);
   snapshot_map_.insert(std::make_pair(new_id, s));
   callback.Run(new_id);
 }
 
 void LevelDBDatabaseImpl::ReleaseSnapshot(uint64_t snapshot_id) {
   auto it = snapshot_map_.find(snapshot_id);
   if (it != snapshot_map_.end()) {
     db_->ReleaseSnapshot(it->second);
     snapshot_map_.erase(it);
   }
 }
 
 void LevelDBDatabaseImpl::GetFromSnapshot(uint64_t snapshot_id,
-                                          mojo::Array<uint8_t> key,
+                                          const std::vector<uint8_t>& key,
                                           const GetCallback& callback) {
   // If the snapshot id is invalid, send back invalid argument
   auto it = snapshot_map_.find(snapshot_id);
   if (it == snapshot_map_.end()) {
     callback.Run(mojom::DatabaseError::INVALID_ARGUMENT,
-                 mojo::Array<uint8_t>());
+                 std::vector<uint8_t>());
     return;
   }
 
   std::string value;
   leveldb::ReadOptions options;
   options.snapshot = it->second;
   leveldb::Status status = db_->Get(options, GetSliceFor(key), &value);
-  callback.Run(LeveldbStatusToError(status), mojo::Array<uint8_t>::From(value));
+  callback.Run(LeveldbStatusToError(status), StdStringToUint8Vector(value));
 }
 
 void LevelDBDatabaseImpl::NewIterator(const NewIteratorCallback& callback) {
   Iterator* iterator = db_->NewIterator(leveldb::ReadOptions());
   uint64_t new_id = GetSafeRandomId(iterator_map_);
   iterator_map_.insert(std::make_pair(new_id, iterator));
   callback.Run(new_id);
 }
 
 void LevelDBDatabaseImpl::NewIteratorFromSnapshot(
@@ skipping 21 matching lines @@
     delete it->second;
     iterator_map_.erase(it);
   }
 }
 
 void LevelDBDatabaseImpl::IteratorSeekToFirst(
     uint64_t iterator_id,
     const IteratorSeekToFirstCallback& callback) {
   auto it = iterator_map_.find(iterator_id);
   if (it == iterator_map_.end()) {
-    callback.Run(false, mojom::DatabaseError::INVALID_ARGUMENT, nullptr,
-                 nullptr);
+    callback.Run(false, mojom::DatabaseError::INVALID_ARGUMENT, base::nullopt,
+                 base::nullopt);
     return;
   }
 
   it->second->SeekToFirst();
 
   ReplyToIteratorMessage(it->second, callback);
 }
 
 void LevelDBDatabaseImpl::IteratorSeekToLast(
     uint64_t iterator_id,
     const IteratorSeekToLastCallback& callback) {
   auto it = iterator_map_.find(iterator_id);
   if (it == iterator_map_.end()) {
-    callback.Run(false, mojom::DatabaseError::INVALID_ARGUMENT, nullptr,
-                 nullptr);
+    callback.Run(false, mojom::DatabaseError::INVALID_ARGUMENT, base::nullopt,
+                 base::nullopt);
     return;
   }
 
   it->second->SeekToLast();
 
   ReplyToIteratorMessage(it->second, callback);
 }
 
 void LevelDBDatabaseImpl::IteratorSeek(
     uint64_t iterator_id,
-    mojo::Array<uint8_t> target,
+    const std::vector<uint8_t>& target,
     const IteratorSeekToLastCallback& callback) {
   auto it = iterator_map_.find(iterator_id);
   if (it == iterator_map_.end()) {
-    callback.Run(false, mojom::DatabaseError::INVALID_ARGUMENT, nullptr,
-                 nullptr);
+    callback.Run(false, mojom::DatabaseError::INVALID_ARGUMENT, base::nullopt,
+                 base::nullopt);
     return;
   }
 
   it->second->Seek(GetSliceFor(target));
 
   ReplyToIteratorMessage(it->second, callback);
 }
 
 void LevelDBDatabaseImpl::IteratorNext(uint64_t iterator_id,
                                        const IteratorNextCallback& callback) {
   auto it = iterator_map_.find(iterator_id);
   if (it == iterator_map_.end()) {
-    callback.Run(false, mojom::DatabaseError::INVALID_ARGUMENT, nullptr,
-                 nullptr);
+    callback.Run(false, mojom::DatabaseError::INVALID_ARGUMENT, base::nullopt,
+                 base::nullopt);
     return;
   }
 
   it->second->Next();
 
   ReplyToIteratorMessage(it->second, callback);
 }
 
 void LevelDBDatabaseImpl::IteratorPrev(uint64_t iterator_id,
                                        const IteratorPrevCallback& callback) {
   auto it = iterator_map_.find(iterator_id);
   if (it == iterator_map_.end()) {
-    callback.Run(false, mojom::DatabaseError::INVALID_ARGUMENT, nullptr,
-                 nullptr);
+    callback.Run(false, mojom::DatabaseError::INVALID_ARGUMENT, base::nullopt,
+                 base::nullopt);
     return;
   }
 
   it->second->Prev();
 
   ReplyToIteratorMessage(it->second, callback);
 }
 
 void LevelDBDatabaseImpl::ReplyToIteratorMessage(
     leveldb::Iterator* it,
     const IteratorSeekToFirstCallback& callback) {
   if (!it->Valid()) {
-    callback.Run(false, LeveldbStatusToError(it->status()), nullptr, nullptr);
+    callback.Run(false, LeveldbStatusToError(it->status()), base::nullopt,
+                 base::nullopt);
     return;
   }
 
-  callback.Run(true, LeveldbStatusToError(it->status()), GetArrayFor(it->key()),
-               GetArrayFor(it->value()));
+  callback.Run(true, LeveldbStatusToError(it->status()),
+               GetVectorFor(it->key()), GetVectorFor(it->value()));
 }
 
 leveldb::Status LevelDBDatabaseImpl::DeletePrefixedHelper(
     const leveldb::Slice& key_prefix,
     leveldb::WriteBatch* batch) {
   leveldb::Status status = ForEachWithPrefix(db_.get(), key_prefix,
       [batch](const leveldb::Slice& key, const leveldb::Slice& value) {
         batch->Delete(key);
       });
   return status;
 }
 
 }  // namespace leveldb