Sync MDP: reimplement value conversions ontop of visitors

components/sync/protocol/proto_old_value_conversions.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.
 
 // Keep this file in sync with the .proto files in this directory.
 
-#include "components/sync/protocol/proto_value_conversions.h"
+#include "components/sync/protocol/proto_old_value_conversions.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/base64.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 26 matching lines @@
 #include "components/sync/protocol/proto_enum_conversions.h"
 #include "components/sync/protocol/reading_list_specifics.pb.h"
 #include "components/sync/protocol/search_engine_specifics.pb.h"
 #include "components/sync/protocol/session_specifics.pb.h"
 #include "components/sync/protocol/sync.pb.h"
 #include "components/sync/protocol/theme_specifics.pb.h"
 #include "components/sync/protocol/typed_url_specifics.pb.h"
 #include "components/sync/protocol/unique_position.pb.h"
 
 namespace syncer {
+namespace old {
 
 namespace {
 
 // Basic Type -> Value functions.
 
 std::unique_ptr<base::StringValue> MakeInt64Value(int64_t x) {
   return base::MakeUnique<base::StringValue>(base::Int64ToString(x));
 }
 
 // TODO(akalin): Perhaps make JSONWriter support BinaryValue and use
@@ skipping 89 matching lines @@
   SET_BOOL(disabled);
   SET_STR(oauth_client_id);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> SessionHeaderToValue(
     const sync_pb::SessionHeader& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_REP(window, SessionWindowToValue);
   SET_STR(client_name);
-  SET_ENUM(device_type, GetDeviceTypeString);
+  SET_ENUM(device_type, ProtoEnumToString);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> SessionTabToValue(
     const sync_pb::SessionTab& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_INT32(tab_id);
   SET_INT32(window_id);
   SET_INT32(tab_visual_index);
   SET_INT32(current_navigation_index);
   SET_BOOL(pinned);
   SET_STR(extension_app_id);
   SET_REP(navigation, TabNavigationToValue);
   SET_BYTES(favicon);
-  SET_ENUM(favicon_type, GetFaviconTypeString);
+  SET_ENUM(favicon_type, ProtoEnumToString);
   SET_STR(favicon_source);
   SET_REP(variation_id, MakeInt64Value);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> SessionWindowToValue(
     const sync_pb::SessionWindow& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_INT32(window_id);
   SET_INT32(selected_tab_index);
   SET_INT32_REP(tab);
-  SET_ENUM(browser_type, GetBrowserTypeString);
+  SET_ENUM(browser_type, ProtoEnumToString);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> TabNavigationToValue(
     const sync_pb::TabNavigation& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_STR(virtual_url);
   SET_STR(referrer);
   SET_STR(title);
-  SET_ENUM(page_transition, GetPageTransitionString);
-  SET_ENUM(redirect_type, GetPageTransitionRedirectTypeString);
+  SET_ENUM(page_transition, ProtoEnumToString);
+  SET_ENUM(redirect_type, ProtoEnumToString);
   SET_INT32(unique_id);
   SET_INT64(timestamp_msec);
   SET_BOOL(navigation_forward_back);
   SET_BOOL(navigation_from_address_bar);
   SET_BOOL(navigation_home_page);
   SET_BOOL(navigation_chain_start);
   SET_BOOL(navigation_chain_end);
   SET_INT64(global_id);
   SET_STR(search_terms);
   SET_STR(favicon_url);
-  SET_ENUM(blocked_state, GetBlockedStateString);
+  SET_ENUM(blocked_state, ProtoEnumToString);
   SET_STR_REP(content_pack_categories);
   SET_INT32(http_status_code);
   SET_INT32(obsolete_referrer_policy);
   SET_BOOL(is_restored);
   SET_REP(navigation_redirect, NavigationRedirectToValue);
   SET_STR(last_navigation_redirect_url);
   SET_INT32(correct_referrer_policy);
-  SET_ENUM(password_state, GetPasswordStateString);
+  SET_ENUM(password_state, ProtoEnumToString);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> NavigationRedirectToValue(
     const sync_pb::NavigationRedirect& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_STR(url);
   return value;
 }
 
@@ skipping 33 matching lines @@
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_INT64(start_time_usec);
   SET_INT64(end_time_usec);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> AppListSpecificsToValue(
     const sync_pb::AppListSpecifics& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_STR(item_id);
-  SET_ENUM(item_type, GetAppListItemTypeString);
+  SET_ENUM(item_type, ProtoEnumToString);
   SET_STR(item_name);
   SET_STR(parent_id);
   SET_STR(item_ordinal);
   SET_STR(item_pin_ordinal);
 
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> ArcPackageSpecificsToValue(
     const sync_pb::ArcPackageSpecifics& proto) {
@@ skipping 18 matching lines @@
 }
 
 std::unique_ptr<base::DictionaryValue> ReadingListSpecificsToValue(
     const sync_pb::ReadingListSpecifics& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_STR(entry_id);
   SET_STR(title);
   SET_STR(url);
   SET_INT64(creation_time_us);
   SET_INT64(update_time_us);
-  SET_ENUM(status, GetReadingListEntryStatusString);
+  SET_ENUM(status, ProtoEnumToString);
 
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> AppNotificationToValue(
     const sync_pb::AppNotification& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_STR(guid);
   SET_STR(app_id);
   SET_INT64(creation_timestamp_ms);
@@ skipping 19 matching lines @@
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> AppSpecificsToValue(
     const sync_pb::AppSpecifics& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET(extension, ExtensionSpecificsToValue);
   SET(notification_settings, AppSettingsToValue);
   SET_STR(app_launch_ordinal);
   SET_STR(page_ordinal);
-  SET_ENUM(launch_type, GetLaunchTypeString);
+  SET_ENUM(launch_type, ProtoEnumToString);
   SET_STR(bookmark_app_url);
   SET_STR(bookmark_app_description);
   SET_STR(bookmark_app_icon_color);
   SET_REP(linked_app_icons, LinkedAppIconInfoToValue);
 
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> AutofillSpecificsToValue(
     const sync_pb::AutofillSpecifics& proto) {
@@ skipping 32 matching lines @@
   SET_STR(address_home_dependent_locality);
   SET_STR(address_home_language_code);
 
   SET_STR_REP(phone_home_whole_number);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> WalletMetadataSpecificsToValue(
     const sync_pb::WalletMetadataSpecifics& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET_ENUM(type, GetWalletMetadataTypeString);
+  SET_ENUM(type, ProtoEnumToString);
   SET_STR(id);
   SET_INT64(use_count);
   SET_INT64(use_date);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> AutofillWalletSpecificsToValue(
     const sync_pb::AutofillWalletSpecifics& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 
-  SET_ENUM(type, GetWalletInfoTypeString);
+  SET_ENUM(type, ProtoEnumToString);
   if (proto.type() == sync_pb::AutofillWalletSpecifics::MASKED_CREDIT_CARD) {
     value->Set("masked_card",
                WalletMaskedCreditCardToValue(proto.masked_card()));
   } else if (proto.type() == sync_pb::AutofillWalletSpecifics::POSTAL_ADDRESS) {
     value->Set("address", WalletPostalAddressToValue(proto.address()));
   }
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> MetaInfoToValue(
@@ skipping 14 matching lines @@
   SET_STR(icon_url);
   SET_REP(meta_info, &MetaInfoToValue);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> DeviceInfoSpecificsToValue(
     const sync_pb::DeviceInfoSpecifics& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_STR(cache_guid);
   SET_STR(client_name);
-  SET_ENUM(device_type, GetDeviceTypeString);
+  SET_ENUM(device_type, ProtoEnumToString);
   SET_STR(sync_user_agent);
   SET_STR(chrome_version);
   SET_STR(signin_scoped_device_id);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> DictionarySpecificsToValue(
     const sync_pb::DictionarySpecifics& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_STR(word);
@@ skipping 145 matching lines @@
   SET_BOOL(encrypt_apps);
   SET_BOOL(encrypt_search_engines);
   SET_BOOL(encrypt_dictionary);
   SET_BOOL(encrypt_articles);
   SET_BOOL(encrypt_app_list);
   SET_BOOL(encrypt_arc_package);
   SET_BOOL(encrypt_reading_list);
   SET_BOOL(encrypt_everything);
   SET_BOOL(server_only_was_missing_keystore_migration_time);
   SET_BOOL(sync_tab_favicons);
-  SET_ENUM(passphrase_type, PassphraseTypeString);
+  SET_ENUM(passphrase_type, ProtoEnumToString);
   SET(keystore_decryptor_token, EncryptedDataToValue);
   SET_INT64(keystore_migration_time);
   SET_INT64(custom_passphrase_time);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> ArticlePageToValue(
     const sync_pb::ArticlePage& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_STR(url);
@@ skipping 116 matching lines @@
   SET_BOOL(hidden);
   SET_INT64_REP(visits);
   SET_INT32_REP(visit_transitions);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> WalletMaskedCreditCardToValue(
     const sync_pb::WalletMaskedCreditCard& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_STR(id);
-  SET_ENUM(status, GetWalletCardStatusString);
+  SET_ENUM(status, ProtoEnumToString);
   SET_STR(name_on_card);
-  SET_ENUM(type, GetWalletCardTypeString);
+  SET_ENUM(type, ProtoEnumToString);
   SET_STR(last_four);
   SET_INT32(exp_month);
   SET_INT32(exp_year);
   SET_STR(billing_address_id);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> WalletPostalAddressToValue(
     const sync_pb::WalletPostalAddress& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
@@ skipping 10 matching lines @@
   SET_STR(country_code);
   SET_STR(phone_number);
   SET_STR(language_code);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> WifiCredentialSpecificsToValue(
     const sync_pb::WifiCredentialSpecifics& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_BYTES(ssid);
-  SET_ENUM(security_class, GetWifiCredentialSecurityClassString);
+  SET_ENUM(security_class, ProtoEnumToString);
   SET_BYTES(passphrase);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> EntitySpecificsToValue(
     const sync_pb::EntitySpecifics& specifics) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_FIELD(app, AppSpecificsToValue);
   SET_FIELD(app_list, AppListSpecificsToValue);
   SET_FIELD(app_notification, AppNotificationToValue);
@@ skipping 134 matching lines @@
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_INT32(data_type_id);
   SET_STR(context);
   SET_INT64(version);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> GetUpdatesCallerInfoToValue(
     const sync_pb::GetUpdatesCallerInfo& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET_ENUM(source, GetUpdatesSourceString);
+  SET_ENUM(source, ProtoEnumToString);
   SET_BOOL(notifications_enabled);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> GetUpdatesMessageToValue(
     const sync_pb::GetUpdatesMessage& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET(caller_info, GetUpdatesCallerInfoToValue);
   SET_BOOL(fetch_folders);
   SET_INT32(batch_size);
   SET_REP(from_progress_marker, DataTypeProgressMarkerToValue);
   SET_BOOL(streaming);
   SET_BOOL(need_encryption_key);
   SET_BOOL(create_mobile_bookmarks_folder);
-  SET_ENUM(get_updates_origin, GetUpdatesOriginString);
+  SET_ENUM(get_updates_origin, ProtoEnumToString);
   SET_REP(client_contexts, DataTypeContextToValue);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> ClientStatusToValue(
     const sync_pb::ClientStatus& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET_BOOL(hierarchy_conflict_detected);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> EntryResponseToValue(
     const sync_pb::CommitResponse::EntryResponse& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET_ENUM(response_type, GetResponseTypeString);
+  SET_ENUM(response_type, ProtoEnumToString);
   SET_STR(id_string);
   SET_STR(parent_id_string);
   SET_INT64(position_in_parent);
   SET_INT64(version);
   SET_STR(name);
   SET_STR(error_message);
   SET_INT64(mtime);
   return value;
 }
 
@@ skipping 24 matching lines @@
   SET_INT32(max_commit_batch_size);
   SET_INT32(sessions_commit_delay_seconds);
   SET_INT32(throttle_delay_seconds);
   SET_INT32(client_invalidation_hint_buffer_size);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> ErrorToValue(
     const sync_pb::ClientToServerResponse::Error& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET_ENUM(error_type, GetErrorTypeString);
+  SET_ENUM(error_type, ProtoEnumToString);
   SET_STR(error_description);
   SET_STR(url);
-  SET_ENUM(action, GetActionString);
+  SET_ENUM(action, ProtoEnumToString);
   return value;
 }
 
 }  // namespace
 
 std::unique_ptr<base::DictionaryValue> ClientToServerResponseToValue(
     const sync_pb::ClientToServerResponse& proto,
     bool include_specifics) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   SET(commit, CommitResponseToValue);
   if (proto.has_get_updates()) {
     value->Set("get_updates", GetUpdatesResponseToValue(proto.get_updates(),
                                                         include_specifics));
   }
 
   SET(error, ErrorToValue);
-  SET_ENUM(error_code, GetErrorTypeString);
+  SET_ENUM(error_code, ProtoEnumToString);
   SET_STR(error_message);
   SET_STR(store_birthday);
   SET(client_command, ClientCommandToValue);
   SET_INT32_REP(migrated_data_type_id);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> ClientToServerMessageToValue(
     const sync_pb::ClientToServerMessage& proto,
     bool include_specifics) {
@@ skipping 33 matching lines @@
   SET_INT64(download_wait_time_us);
   SET_INT64(download_time_us);
   SET_INT64(association_wait_time_for_high_priority_us);
   SET_INT64(association_wait_time_for_same_priority_us);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> DebugEventInfoToValue(
     const sync_pb::DebugEventInfo& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET_ENUM(singleton_event, SingletonDebugEventTypeString);
+  SET_ENUM(singleton_event, ProtoEnumToString);
   SET(sync_cycle_completed_event_info, SyncCycleCompletedEventInfoToValue);
   SET_INT32(nudging_datatype);
   SET_INT32_REP(datatypes_notified_from_server);
   SET(datatype_association_stats, DatatypeAssociationStatsToValue);
   return value;
 }
 
 std::unique_ptr<base::DictionaryValue> DebugInfoToValue(
     const sync_pb::DebugInfo& proto) {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
@@ skipping 55 matching lines @@
 #undef SET_BOOL
 #undef SET_BYTES
 #undef SET_INT32
 #undef SET_INT64
 #undef SET_INT64_REP
 #undef SET_STR
 #undef SET_STR_REP
 
 #undef SET_FIELD
 
+}  // namespace old
 }  // namespace syncer