[USS] Implement GetAllData and GetStorageKey.

components/history/core/browser/typed_url_sync_metadata_database.cc

 // Copyright 2017 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/history/core/browser/typed_url_sync_metadata_database.h"
 
+#include "base/big_endian.h"
 #include "base/logging.h"
-#include "base/strings/string_number_conversions.h"
+#include "components/history/core/browser/url_row.h"
 #include "sql/statement.h"
 
 namespace history {
 
 namespace {
 
 // Key in sql::MetaTable, the value will be Serialization of sync
 // ModelTypeState, which is for tracking sync state of typed url datatype.
 const char kTypedURLModelTypeStateKey[] = "typed_url_model_type_state";
 
@@ skipping 29 matching lines @@
 }
 
 bool TypedURLSyncMetadataDatabase::UpdateSyncMetadata(
     syncer::ModelType model_type,
     const std::string& storage_key,
     const sync_pb::EntityMetadata& metadata) {
   DCHECK_EQ(model_type, syncer::TYPED_URLS)
       << "Only the TYPED_URLS model type is supported";
 
   int64_t storage_key_int = 0;
-  if (!base::StringToInt64(storage_key, &storage_key_int)) {
-    return false;
-  }
+  DCHECK_EQ(storage_key.size(), sizeof(storage_key_int));
+  base::ReadBigEndian(storage_key.data(), &storage_key_int);

[brettw, 2017/06/05 17:31:15]

The commit message says you changed this to big endian but doesn't motivate this
change. Can the commit message explain why this change is necessary/desirable?

[Gang Wu, 2017/06/05 20:04:14]

Changing to big endian is from a comment from first iteration of this CL "It has
a benefit of costing slightly less CPU for serializing/parsing."
And I think it is better to unify our storage key, if a storage key is number,
then using big endian, since another datatype is using big
endian(https://cs.chromium.org/chromium/src/components/sync/user_events/user_event_sync_bridge.cc?l=38),
so typed urls just following that style.

+  // Make sure storage_key_int is set.
+  DCHECK_NE(storage_key_int, 0);
+
   sql::Statement s(GetDB().GetUniqueStatement(
       "INSERT OR REPLACE INTO typed_url_sync_metadata "
       "(storage_key, value) VALUES(?, ?)"));
   s.BindInt64(0, storage_key_int);
   s.BindString(1, metadata.SerializeAsString());
 
   return s.Run();
 }
 
 bool TypedURLSyncMetadataDatabase::ClearSyncMetadata(
     syncer::ModelType model_type,
     const std::string& storage_key) {
   DCHECK_EQ(model_type, syncer::TYPED_URLS)
       << "Only the TYPED_URLS model type is supported";
 
   int64_t storage_key_int = 0;
-  if (!base::StringToInt64(storage_key, &storage_key_int)) {
-    return false;
-  }
+  DCHECK_EQ(storage_key.size(), sizeof(storage_key_int));
+  base::ReadBigEndian(storage_key.data(), &storage_key_int);
+  // Make sure storage_key_int is set.
+  DCHECK_NE(storage_key_int, 0);
+
   sql::Statement s(GetDB().GetUniqueStatement(
       "DELETE FROM typed_url_sync_metadata WHERE storage_key=?"));
   s.BindInt64(0, storage_key_int);
 
   return s.Run();
 }
 
 bool TypedURLSyncMetadataDatabase::UpdateModelTypeState(
     syncer::ModelType model_type,
     const sync_pb::ModelTypeState& model_type_state) {
@@ skipping 25 matching lines @@
   return true;
 }
 
 bool TypedURLSyncMetadataDatabase::GetAllSyncEntityMetadata(
     syncer::MetadataBatch* metadata_batch) {
   DCHECK(metadata_batch);
   sql::Statement s(GetDB().GetUniqueStatement(
       "SELECT storage_key, value FROM typed_url_sync_metadata"));
 
   while (s.Step()) {
-    std::string storage_key = base::Int64ToString(s.ColumnInt64(0));
+    std::string storage_key(sizeof(URLID), 0);
+    base::WriteBigEndian<URLID>(&storage_key[0], s.ColumnInt64(0));
     std::string serialized_metadata = s.ColumnString(1);
     sync_pb::EntityMetadata entity_metadata;
     if (entity_metadata.ParseFromString(serialized_metadata)) {
       metadata_batch->AddMetadata(storage_key, entity_metadata);
     } else {
       DLOG(WARNING) << "Failed to deserialize TYPED_URLS model type "
                        "sync_pb::EntityMetadata.";
       return false;
     }
   }
   return true;
 }
 
 bool TypedURLSyncMetadataDatabase::GetModelTypeState(
     sync_pb::ModelTypeState* state) {
   DCHECK_GT(GetMetaTable().GetVersionNumber(), 0);
   std::string serialized_state;
   if (!GetMetaTable().GetValue(kTypedURLModelTypeStateKey, &serialized_state)) {
     return true;
   }
 
   return state->ParseFromString(serialized_state);
 }
 
 }  // namespace history