[Sync] Reimplement proto value conversions on top of field visitors.

components/sync/protocol/proto_value_conversions_unittest.cc

 // Copyright (c) 2012 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/sync/protocol/proto_value_conversions.h"
 
 #include <string>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/sync/base/model_type.h"
+#include "components/sync/base/unique_position.h"
 #include "components/sync/protocol/app_notification_specifics.pb.h"
 #include "components/sync/protocol/app_setting_specifics.pb.h"
 #include "components/sync/protocol/app_specifics.pb.h"
 #include "components/sync/protocol/autofill_specifics.pb.h"
 #include "components/sync/protocol/bookmark_specifics.pb.h"
 #include "components/sync/protocol/device_info_specifics.pb.h"
 #include "components/sync/protocol/encryption.pb.h"
 #include "components/sync/protocol/experiments_specifics.pb.h"
 #include "components/sync/protocol/extension_setting_specifics.pb.h"
 #include "components/sync/protocol/extension_specifics.pb.h"
@@ skipping 84 matching lines @@
 }
 
 TEST_F(ProtoValueConversionsTest, AppNotificationToValue) {
   TestSpecificsToValue(AppNotificationToValue);
 }
 
 TEST_F(ProtoValueConversionsTest, AppSettingSpecificsToValue) {
   sync_pb::AppNotificationSettings specifics;
   specifics.set_disabled(true);
   specifics.set_oauth_client_id("some_id_value");
-  std::unique_ptr<base::DictionaryValue> value(AppSettingsToValue(specifics));
+  std::unique_ptr<base::DictionaryValue>
+      value(AppNotificationSettingsToValue(specifics));
   EXPECT_FALSE(value->empty());
   bool disabled_value = false;
   std::string oauth_client_id_value;
   EXPECT_TRUE(value->GetBoolean("disabled", &disabled_value));
   EXPECT_EQ(true, disabled_value);
   EXPECT_TRUE(value->GetString("oauth_client_id", &oauth_client_id_value));
   EXPECT_EQ("some_id_value", oauth_client_id_value);
 }
 
 TEST_F(ProtoValueConversionsTest, AppSpecificsToValue) {
   TestSpecificsToValue(AppSpecificsToValue);
 }
 
 TEST_F(ProtoValueConversionsTest, ArcPackageSpecificsToValue) {
   TestSpecificsToValue(ArcPackageSpecificsToValue);
 }
 
 TEST_F(ProtoValueConversionsTest, AutofillSpecificsToValue) {
   TestSpecificsToValue(AutofillSpecificsToValue);
 }
 
 TEST_F(ProtoValueConversionsTest, AutofillProfileSpecificsToValue) {
   TestSpecificsToValue(AutofillProfileSpecificsToValue);
 }
 
 TEST_F(ProtoValueConversionsTest, AutofillWalletSpecificsToValue) {
-  TestSpecificsToValue(AutofillWalletSpecificsToValue);
+  sync_pb::AutofillWalletSpecifics specifics;
+  specifics.mutable_masked_card()->set_name_on_card("Igloo");
+  specifics.mutable_address()->set_recipient_name("John");
+
+  specifics.set_type(sync_pb::AutofillWalletSpecifics::UNKNOWN);
+  auto value = AutofillWalletSpecificsToValue(specifics);
+  EXPECT_FALSE(value->Get("masked_card", nullptr));
+  EXPECT_FALSE(value->Get("address", nullptr));
+
+  specifics.set_type(sync_pb::AutofillWalletSpecifics::MASKED_CREDIT_CARD);
+  value = AutofillWalletSpecificsToValue(specifics);
+  EXPECT_TRUE(value->Get("masked_card", nullptr));
+  EXPECT_FALSE(value->Get("address", nullptr));
+
+  specifics.set_type(sync_pb::AutofillWalletSpecifics::POSTAL_ADDRESS);
+  value = AutofillWalletSpecificsToValue(specifics);
+  EXPECT_FALSE(value->Get("masked_card", nullptr));
+  EXPECT_TRUE(value->Get("address", nullptr));
 }
 
 TEST_F(ProtoValueConversionsTest, WalletMetadataSpecificsToValue) {
   TestSpecificsToValue(WalletMetadataSpecificsToValue);
 }
 
 TEST_F(ProtoValueConversionsTest, BookmarkSpecificsToValue) {
   TestSpecificsToValue(BookmarkSpecificsToValue);
 }
 
@@ skipping 43 matching lines @@
 
 TEST_F(ProtoValueConversionsTest, PriorityPreferenceSpecificsToValue) {
   TestSpecificsToValue(PriorityPreferenceSpecificsToValue);
 }
 
 TEST_F(ProtoValueConversionsTest, DeviceInfoSpecificsToValue) {
   TestSpecificsToValue(DeviceInfoSpecificsToValue);
 }
 
 TEST_F(ProtoValueConversionsTest, ExperimentsSpecificsToValue) {
-  TestSpecificsToValue(ExperimentsSpecificsToValue);
+#define TEST_EXPERIMENT_ENABLED_FIELD(field) \
+  { \
+    sync_pb::ExperimentsSpecifics specifics; \
+    specifics.mutable_##field(); \
+    auto value = ExperimentsSpecificsToValue(specifics); \
+    EXPECT_TRUE(value->empty()); \
+  } \
+  { \
+    sync_pb::ExperimentsSpecifics specifics; \
+    specifics.mutable_##field()->set_enabled(false); \
+    auto value = ExperimentsSpecificsToValue(specifics); \
+    bool field_enabled = true; \
+    EXPECT_EQ(1u, value->size()); \
+    EXPECT_TRUE(value->GetBoolean(#field, &field_enabled)); \
+    EXPECT_FALSE(field_enabled); \
+  }
+
+  TEST_EXPERIMENT_ENABLED_FIELD(keystore_encryption)
+  TEST_EXPERIMENT_ENABLED_FIELD(history_delete_directives)
+  TEST_EXPERIMENT_ENABLED_FIELD(autofill_culling)
+  TEST_EXPERIMENT_ENABLED_FIELD(pre_commit_update_avoidance)
+  TEST_EXPERIMENT_ENABLED_FIELD(gcm_channel)
+  TEST_EXPERIMENT_ENABLED_FIELD(gcm_invalidations)
+
+#undef TEST_EXPERIMENT_ENABLED_FIELD
 }
 
 TEST_F(ProtoValueConversionsTest, ExtensionSettingSpecificsToValue) {
   TestSpecificsToValue(ExtensionSettingSpecificsToValue);
 }
 
 TEST_F(ProtoValueConversionsTest, ExtensionSpecificsToValue) {
   TestSpecificsToValue(ExtensionSpecificsToValue);
 }
 
@@ skipping 128 matching lines @@
 
 #undef SET_FIELD
 
   std::unique_ptr<base::DictionaryValue> value(
       EntitySpecificsToValue(specifics));
   EXPECT_EQ(MODEL_TYPE_COUNT - FIRST_REAL_MODEL_TYPE -
                 (LAST_PROXY_TYPE - FIRST_PROXY_TYPE + 1),
             static_cast<int>(value->size()));
 }
 
+TEST_F(ProtoValueConversionsTest, UniquePositionToValue) {
+  sync_pb::SyncEntity entity;
+  entity.mutable_unique_position()->set_custom_compressed_v1("test");
+
+  auto value = SyncEntityToValue(entity, false);
+  std::string unique_position;
+  EXPECT_TRUE(value->GetString("unique_position", &unique_position));
+
+  std::string expected_unique_position =
+      UniquePosition::FromProto(entity.unique_position()).ToDebugString();
+  EXPECT_EQ(expected_unique_position, unique_position);
+}
+
+TEST_F(ProtoValueConversionsTest, SyncEntityToValueIncludeSpecifics) {
+  sync_pb::SyncEntity entity;
+  entity.mutable_specifics();
+
+  auto value = SyncEntityToValue(entity, true /* include_specifics */);
+  EXPECT_TRUE(value->GetDictionary("specifics", nullptr));
+
+  value = SyncEntityToValue(entity, false /* include_specifics */);
+  EXPECT_FALSE(value->GetDictionary("specifics", nullptr));
+}
+
 namespace {
 // Returns whether the given value has specifics under the entries in the given
 // path.
 bool ValueHasSpecifics(const base::DictionaryValue& value,
                        const std::string& path) {
   const base::ListValue* entities_list = nullptr;
   const base::DictionaryValue* entry_dictionary = nullptr;
   const base::DictionaryValue* specifics_dictionary = nullptr;
 
   if (!value.GetList(path, &entities_list))
@@ skipping 47 matching lines @@
   EXPECT_FALSE(ValueHasSpecifics(*(value_without_specifics.get()),
                                  "get_updates.entries"));
 }
 
 TEST_F(ProtoValueConversionsTest, AttachmentIdProtoToValue) {
   TestSpecificsToValue(AttachmentIdProtoToValue);
 }
 
 }  // namespace
 }  // namespace syncer