[sync] Add typed url sync metadata to the history db

components/history/core/browser/typed_url_sync_metadata_database.cc

Index: components/history/core/browser/typed_url_sync_metadata_database.cc
diff --git a/components/history/core/browser/typed_url_sync_metadata_database.cc b/components/history/core/browser/typed_url_sync_metadata_database.cc
new file mode 100644
index 0000000000000000000000000000000000000000..dbeb548f59c695eeb1cf67e1fbdc72282dade592
--- /dev/null
+++ b/components/history/core/browser/typed_url_sync_metadata_database.cc
@@ -0,0 +1,148 @@
+// 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 "sql/statement.h"
+
+namespace history {
+
+// Description of database table:
+//
+// typed_url_sync_metadata
+//   storage_key      the rowid of an entry in urls table, used by service to
+//                    look up native data with sync metadata records.
+//   value            Serialize sync EntityMetadata, which is for tracking sync
+//                    state of each typed url.
+//
+// typed_url_model_type_state
+//   id               should only one record in the table and record's id should
+//                    always be 1.
+//   value            Serialization of sync ModelTypeState, which is for
+//                    tracking sync state of typed url datatype.
+
+TypedURLSyncMetadataDatabase::TypedURLSyncMetadataDatabase() {}
+
+TypedURLSyncMetadataDatabase::~TypedURLSyncMetadataDatabase() {}
+
+bool TypedURLSyncMetadataDatabase::GetAllSyncMetadata(
+    syncer::MetadataBatch* metadata_batch) {
+  syncer::EntityMetadataMap metadata_records_map;
+  if (GetAllSyncEntityMetadata(&metadata_records_map)) {
+    for (const auto& storayge_key_to_metadata : metadata_records_map)

[brettw, 2017/03/14 19:24:43]

It's a little bit hard for me to give good suggestions here since this code
isn't hooked up to sync yet (I think) so I can't see final usage.

But we need to change something here. GetAllSyncMetadata calls
GetAllSyncEntityMetadata which makes a map from a database query. Then this
iterates through the map (not using the map-ness of it) and calls
MetadataBatch::AddMetadata which is the same kind of map created above. This is
a LOT of wasted effort!

We should make it so there's not an intermediate structure in between the
database and the MetadataBatch.

I think it would be nice also to make sure there's no extra copies of
EntityMetadata (currently there are 3 for each item). This seems like a common
pattern. How about a new function
  bool MetadataBatch:::AddSerializedMetadata(const std::string& key, const
std::string& serialized_metadata)
that deserializes it in place into the map with no extra copies?

If we end up keeping this:
 - Needs {} since the inside is > 1 (Chrome style).
 - Also spelling "storayge"

[Gang Wu, 2017/03/15 08:02:43]

This is really a good suggestion! 
But since add this new function will touch several files, I will do it in
another CL, add a todo here for now.

[brettw, 2017/03/20 17:27:06]

Following up with another patch for this is OK to me, partially because I feel
guilty about sitting on this CL for so long :)  But I don't think we should keep
this code here for very long. Will you be able to follow up in the next week or
so?

[Gang Wu, 2017/03/20 21:34:47]

yes, I talked with team, I think I will fix this in 2 weeks after this CL
checked in.

+      metadata_batch->AddMetadata(storayge_key_to_metadata.first,
+                                  storayge_key_to_metadata.second);
+  } else {
+    return false;
+  }
+
+  sync_pb::ModelTypeState model_type_state;
+  if (GetModelTypeState(&model_type_state)) {
+    metadata_batch->SetModelTypeState(model_type_state);
+  } else {
+    return false;
+  }
+
+  return true;
+}
+
+bool TypedURLSyncMetadataDatabase::UpdateSyncMetadata(
+    const std::string& storage_key,
+    const sync_pb::EntityMetadata& metadata) {
+  sql::Statement s(GetDB().GetUniqueStatement(
+      "INSERT OR REPLACE INTO typed_url_sync_metadata "
+      "(storage_key, value) VALUES(?, ?)"));
+  s.BindString(0, storage_key);
+  s.BindString(1, metadata.SerializeAsString());
+
+  return s.Run();
+}
+
+bool TypedURLSyncMetadataDatabase::ClearSyncMetadata(
+    const std::string& storage_key) {
+  sql::Statement s(GetDB().GetUniqueStatement(
+      "DELETE FROM typed_url_sync_metadata WHERE storage_key=?"));
+  s.BindString(0, storage_key);
+
+  return s.Run();
+}
+
+bool TypedURLSyncMetadataDatabase::UpdateModelTypeState(
+    const sync_pb::ModelTypeState& model_type_state) {
+  // Hardcode the id to force a collision, ensuring that there remains only a
+  // single entry.
+  sql::Statement s(GetDB().GetUniqueStatement(
+      "INSERT OR REPLACE INTO typed_url_model_type_state (id, value) "
+      "VALUES(1,?)"));
+  s.BindString(0, model_type_state.SerializeAsString());
+
+  return s.Run();
+}
+
+bool TypedURLSyncMetadataDatabase::ClearModelTypeState() {
+  sql::Statement s(GetDB().GetUniqueStatement(
+      "DELETE FROM typed_url_model_type_state WHERE id=1"));
+
+  return s.Run();
+}
+
+bool TypedURLSyncMetadataDatabase::InitSyncTable() {
+  return InitTypedURLSyncMetadataTable() && InitModelTypeStateTable();
+}
+
+bool TypedURLSyncMetadataDatabase::InitTypedURLSyncMetadataTable() {
+  if (!GetDB().DoesTableExist("typed_url_sync_metadata")) {
+    if (!GetDB().Execute("CREATE TABLE typed_url_sync_metadata ("
+                         "storage_key VARCHAR PRIMARY KEY NOT NULL,"
+                         "value BLOB)")) {
+      NOTREACHED();
+      return false;
+    }
+  }
+  return true;
+}
+
+bool TypedURLSyncMetadataDatabase::InitModelTypeStateTable() {
+  if (!GetDB().DoesTableExist("typed_url_model_type_state")) {
+    if (!GetDB().Execute("CREATE TABLE typed_url_model_type_state (id INTEGER "
+                         "PRIMARY KEY, value BLOB)")) {
+      NOTREACHED();
+      return false;
+    }
+  }
+  return true;
+}
+
+bool TypedURLSyncMetadataDatabase::GetAllSyncEntityMetadata(
+    syncer::EntityMetadataMap* metadata_records) {
+  sql::Statement s(GetDB().GetUniqueStatement(
+      "SELECT storage_key, value FROM typed_url_sync_metadata"));
+
+  while (s.Step()) {
+    std::string storage_key = s.ColumnString(0);
+    std::string serialized_metadata = s.ColumnString(1);
+    sync_pb::EntityMetadata metadata_record;
+    if (metadata_record.ParseFromString(serialized_metadata)) {
+      metadata_records->insert(std::make_pair(storage_key, metadata_record));
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool TypedURLSyncMetadataDatabase::GetModelTypeState(
+    sync_pb::ModelTypeState* state) {
+  sql::Statement s(GetDB().GetUniqueStatement(
+      "SELECT value FROM typed_url_model_type_state WHERE id=1"));
+
+  if (!s.Step()) {
+    return true;
+  }
+
+  std::string serialized_state = s.ColumnString(0);
+  return state->ParseFromString(serialized_state);
+}
+
+}  // namespace history