[WIP][tracing] Add memory dump provider for sync Directory

sync/protocol/proto_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 "sync/protocol/proto_value_conversions.h"
 
 #include <stdint.h>
 
@@ skipping 33 matching lines @@
 #include "sync/protocol/sync.pb.h"
 #include "sync/protocol/theme_specifics.pb.h"
 #include "sync/protocol/typed_url_specifics.pb.h"
 #include "sync/protocol/unique_position.pb.h"
 #include "sync/util/time.h"
 
 namespace syncer {
 
 namespace {
 
-// Basic Type -> Value functions.
+enum ResultType {

[stanisc, 2016/07/06 21:50:31]

Someone from the current Sync team should review this (I am not in the team
anymore). This file was already quite complex and now it is even harder to
understand.
The reason I didn't want the visitor pattern to start with was to avoid this
kind of complexity. 

[ssid, 2016/07/19 22:10:35]

Not sure what is the alternative here. I can't think of any other way to get
size of the object other than visiting all nodes.

+  MEMORY_USAGE,     // Visitors return only the memory usage
+  CONVERT_TO_VALUE  // Visitors return only the dictionary value.
+};
 
-std::unique_ptr<base::StringValue> MakeInt64Value(int64_t x) {
-  return base::WrapUnique(new base::StringValue(base::Int64ToString(x)));
+struct VisitorResult {
+  VisitorResult(size_t usage) : memory_usage(usage) {}
+  VisitorResult(std::unique_ptr<base::Value> value)
+      : memory_usage(0), as_value(std::move(value)) {}
+
+  base::DictionaryValue* as_dict_value() {
+    DCHECK(as_value);
+    base::DictionaryValue* value;
+    as_value->GetAsDictionary(&value);
+    return value;
+  }
+  std::unique_ptr<base::DictionaryValue> TakeDictValue() {
+    base::DictionaryValue* value;
+    bool res = as_value.release()->GetAsDictionary(&value);
+    DCHECK(res);
+    return base::WrapUnique(value);
+  }
+
+  size_t memory_usage;
+  std::unique_ptr<base::Value> as_value;
+};
+
+VisitorResult MakeInt64Value(int64_t x, const ResultType result_type) {
+  if (result_type == MEMORY_USAGE) {
+    return VisitorResult(0);
+  }
+  return VisitorResult(
+      base::WrapUnique(new base::StringValue(base::Int64ToString(x))));
 }
 
 // TODO(akalin): Perhaps make JSONWriter support BinaryValue and use
 // that instead of a StringValue.
 std::string Base64EncodeString(const std::string& bytes) {
   std::string bytes_base64;
   base::Base64Encode(bytes, &bytes_base64);
   return bytes_base64;
 }
 
-std::unique_ptr<base::StringValue> MakeStringValue(const std::string& str) {
-  return base::WrapUnique(new base::StringValue(str));
+VisitorResult MakeStringValue(const std::string& str,
+                              const ResultType result_type) {
+  if (result_type == MEMORY_USAGE)
+    return VisitorResult(str.capacity());
+  return VisitorResult(base::WrapUnique(new base::StringValue(str)));
 }
 
 // T is the field type, F is either RepeatedField or RepeatedPtrField,
 // and V is a subclass of Value.
-template <class T, class F, class V>
-std::unique_ptr<base::ListValue> MakeRepeatedValue(const F& fields,
-                                                   V (*converter_fn)(T)) {
+template <class T, class F>
+VisitorResult MakeRepeatedVisit(const F& fields,
+                                VisitorResult (*converter_fn)(T,
+                                                              const ResultType),
+                                const ResultType result_type) {
+  if (result_type == MEMORY_USAGE) {
+    size_t total = 0;
+    for (typename F::const_iterator it = fields.begin(); it != fields.end();
+         ++it) {
+      total += converter_fn(*it, result_type).memory_usage + sizeof(T);
+    }
+    return VisitorResult(total);
+  }
   std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (typename F::const_iterator it = fields.begin(); it != fields.end();
        ++it) {
-    list->Append(converter_fn(*it));
+    list->Append(converter_fn(*it, result_type).as_value);
   }
-  return list;
+  return VisitorResult(std::move(list));
 }
 
 }  // namespace
 
 // Helper macros to reduce the amount of boilerplate.
 
-#define SET_TYPE(field, set_fn, transform)           \
-  if (proto.has_##field()) {                         \
-    value->set_fn(#field, transform(proto.field())); \
+#define SET_WITH_EXPR(field, visit_expr, excess_size)             \
+  if (result_type == MEMORY_USAGE) {                              \
+    result.memory_usage += visit_expr.memory_usage + excess_size; \
+  } else {                                                        \
+    result.as_dict_value()->Set(#field, visit_expr.as_value);     \
   }
-#define SET(field, fn) SET_TYPE(field, Set, fn)
+
+#define SET_TYPE(field, set_fn, transform)                            \
+  if (result_type == CONVERT_TO_VALUE && proto.has_##field()) {       \
+    result.as_dict_value()->set_fn(#field, transform(proto.field())); \
+  }
+#define SET(field, fn)                                   \
+  if (proto.has_##field()) {                             \
+    SET_WITH_EXPR(field, fn(proto.field(), result_type), \
+                  sizeof(proto.field()));                \
+  }
 #define SET_REP(field, fn) \
-  value->Set(#field, MakeRepeatedValue(proto.field(), fn))
+  SET_WITH_EXPR(field, MakeRepeatedVisit(proto.field(), fn, result_type), 0)
 #define SET_ENUM(field, fn) SET_TYPE(field, SetString, fn)
 
 #define SET_BOOL(field) SET_TYPE(field, SetBoolean, )
 #define SET_BYTES(field) SET_TYPE(field, SetString, Base64EncodeString)
 #define SET_INT32(field) SET_TYPE(field, SetString, base::Int64ToString)
 #define SET_INT32_REP(field) SET_REP(field, MakeInt64Value)
 #define SET_INT64(field) SET_TYPE(field, SetString, base::Int64ToString)
 #define SET_INT64_REP(field) SET_REP(field, MakeInt64Value)
-#define SET_STR(field) SET_TYPE(field, SetString, )
+#define SET_STR(field)                                                \
+  if (proto.has_##field()) {                                          \
+    SET_WITH_EXPR(field, MakeStringValue(proto.field(), result_type), \
+                  sizeof(std::string));                               \
+  }
 #define SET_TIME_STR(field) SET_TYPE(field, SetString, TimestampToString)
 #define SET_STR_REP(field)                                                 \
-  value->Set(                                                              \
-      #field,                                                              \
-      MakeRepeatedValue<const std::string&,                                \
-                        google::protobuf::RepeatedPtrField<std::string>,   \
-                        std::unique_ptr<base::StringValue>>(proto.field(), \
-                                                            MakeStringValue))
-#define SET_EXPERIMENT_ENABLED_FIELD(field)          \
-  do {                                               \
-    if (proto.has_##field() &&                       \
-        proto.field().has_enabled()) {               \
-      value->Set(#field,                             \
-                 new base::FundamentalValue(         \
-                     proto.field().enabled()));      \
-    }                                                \
-  } while (0)
-
-#define SET_FIELD(field, fn)                         \
-  do {                                               \
-    if (specifics.has_##field()) {                   \
-      value->Set(#field, fn(specifics.field()));     \
-    }                                                \
-  } while (0)
+  SET_WITH_EXPR(                                                           \
+      field,                                                               \
+      (MakeRepeatedVisit<const std::string&,                               \
+                         google::protobuf::RepeatedPtrField<std::string>>( \
+          proto.field(), MakeStringValue, result_type)),                   \
+      0);
+#define SET_EXPERIMENT_ENABLED_FIELD(field)                             \
+  if (proto.has_##field()) {                                            \
+    if (result_type == MEMORY_USAGE) {                                  \
+      result.memory_usage += sizeof(proto.field());                     \
+    } else if (proto.field().has_enabled()) {                           \
+      result.as_dict_value()->Set(                                      \
+          #field, new base::FundamentalValue(proto.field().enabled())); \
+    }                                                                   \
+  }
+
+#define SET_FIELD(field, fn)                                 \
+  if (specifics.has_##field()) {                             \
+    SET_WITH_EXPR(field, fn(specifics.field(), result_type), \
+                  sizeof(specifics.field()));                \
+  }
 
 // If you add another macro, don't forget to add an #undef at the end
 // of this file, too.
 
-std::unique_ptr<base::DictionaryValue> EncryptedDataToValue(
-    const sync_pb::EncryptedData& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult EncryptedDataVisit(const sync_pb::EncryptedData& encrypted_data,
+                                 const ResultType result_type);
+
+VisitorResult AppListSpecificsVisit(const sync_pb::AppListSpecifics& proto,
+                                    const ResultType result_type);
+
+VisitorResult AppSettingsVisit(
+    const sync_pb::AppNotificationSettings& app_notification_settings,
+    const ResultType result_type);
+
+VisitorResult LinkedAppIconInfoVisit(
+    const sync_pb::LinkedAppIconInfo& linked_app_icon_info,
+    const ResultType result_type);
+
+VisitorResult SessionHeaderVisit(const sync_pb::SessionHeader& session_header,
+                                 const ResultType result_type);
+
+VisitorResult SessionTabVisit(const sync_pb::SessionTab& session_tab,
+                              const ResultType result_type);
+
+VisitorResult SessionWindowVisit(const sync_pb::SessionWindow& session_window,
+                                 const ResultType result_type);
+
+VisitorResult TabNavigationVisit(const sync_pb::TabNavigation& tab_navigation,
+                                 const ResultType result_type);
+
+VisitorResult NavigationRedirectVisit(
+    const sync_pb::NavigationRedirect& navigation_redirect,
+    const ResultType result_type);
+
+VisitorResult PasswordSpecificsDataVisit(
+    const sync_pb::PasswordSpecificsData& password_specifics_data,
+    const ResultType result_type);
+
+VisitorResult GlobalIdDirectiveVisit(
+    const sync_pb::GlobalIdDirective& global_id_directive,
+    const ResultType result_type);
+
+VisitorResult TimeRangeDirectiveVisit(
+    const sync_pb::TimeRangeDirective& time_range_directive,
+    const ResultType result_type);
+
+VisitorResult SessionSpecificsVisit(
+    const sync_pb::SessionSpecifics& session_specifics,
+    const ResultType result_type);
+
+VisitorResult ArcPackageSpecificsVisit(
+    const sync_pb::ArcPackageSpecifics& proto,
+    const ResultType result_type);
+
+VisitorResult AppNotificationVisit(
+    const sync_pb::AppNotification& app_notification_specifics,
+    const ResultType result_type);
+
+VisitorResult AppSettingSpecificsVisit(
+    const sync_pb::AppSettingSpecifics& app_setting_specifics,
+    const ResultType result_type);
+
+VisitorResult AppSpecificsVisit(const sync_pb::AppSpecifics& app_specifics,
+                                const ResultType result_type);
+
+VisitorResult ArticleSpecificsVisit(
+    const sync_pb::ArticleSpecifics& article_specifics,
+    const ResultType result_type);
+
+VisitorResult AutofillSpecificsVisit(
+    const sync_pb::AutofillSpecifics& autofill_specifics,
+    const ResultType result_type);
+
+VisitorResult AutofillProfileSpecificsVisit(
+    const sync_pb::AutofillProfileSpecifics& autofill_profile_specifics,
+    const ResultType result_type);
+
+VisitorResult WalletMetadataSpecificsVisit(
+    const sync_pb::WalletMetadataSpecifics& wallet_metadata_specifics,
+    const ResultType result_type);
+
+VisitorResult AutofillWalletSpecificsVisit(
+    const sync_pb::AutofillWalletSpecifics& autofill_wallet_specifics,
+    const ResultType result_type);
+
+VisitorResult BookmarkSpecificsVisit(
+    const sync_pb::BookmarkSpecifics& bookmark_specifics,
+    const ResultType result_type);
+
+VisitorResult DeviceInfoSpecificsVisit(
+    const sync_pb::DeviceInfoSpecifics& device_info_specifics,
+    const ResultType result_type);
+
+VisitorResult DictionarySpecificsVisit(
+    const sync_pb::DictionarySpecifics& dictionary_specifics,
+    const ResultType result_type);
+
+VisitorResult ExperimentsSpecificsVisit(
+    const sync_pb::ExperimentsSpecifics& proto,
+    const ResultType result_type);
+
+VisitorResult PriorityPreferenceSpecificsVisit(
+    const sync_pb::PriorityPreferenceSpecifics& proto,
+    const ResultType result_type);
+
+VisitorResult ExtensionSettingSpecificsVisit(
+    const sync_pb::ExtensionSettingSpecifics& extension_setting_specifics,
+    const ResultType result_type);
+
+VisitorResult ExtensionSpecificsVisit(
+    const sync_pb::ExtensionSpecifics& extension_specifics,
+    const ResultType result_type);
+
+VisitorResult FaviconImageSpecificsVisit(
+    const sync_pb::FaviconImageSpecifics& favicon_image_specifics,
+    const ResultType result_type);
+
+VisitorResult FaviconTrackingSpecificsVisit(
+    const sync_pb::FaviconTrackingSpecifics& favicon_tracking_specifics,
+    const ResultType result_type);
+
+VisitorResult HistoryDeleteDirectiveSpecificsVisit(
+    const sync_pb::HistoryDeleteDirectiveSpecifics&
+        history_delete_directive_specifics,
+    const ResultType result_type);
+
+VisitorResult ManagedUserSettingSpecificsVisit(
+    const sync_pb::ManagedUserSettingSpecifics& managed_user_setting_specifics,
+    const ResultType result_type);
+
+VisitorResult ManagedUserSpecificsVisit(
+    const sync_pb::ManagedUserSpecifics& managed_user_specifics,
+    const ResultType result_type);
+
+VisitorResult ManagedUserSharedSettingSpecificsVisit(
+    const sync_pb::ManagedUserSharedSettingSpecifics&
+        managed_user_shared_setting_specifics,
+    const ResultType result_type);
+
+VisitorResult ManagedUserWhitelistSpecificsVisit(
+    const sync_pb::ManagedUserWhitelistSpecifics&
+        managed_user_whitelist_specifics,
+    const ResultType result_type);
+
+VisitorResult NigoriSpecificsVisit(
+    const sync_pb::NigoriSpecifics& nigori_specifics,
+    const ResultType result_type);
+
+VisitorResult PasswordSpecificsVisit(
+    const sync_pb::PasswordSpecifics& password_specifics,
+    const ResultType result_type);
+
+VisitorResult PreferenceSpecificsVisit(
+    const sync_pb::PreferenceSpecifics& password_specifics,
+    const ResultType result_type);
+
+VisitorResult SyncedNotificationAppInfoSpecificsVisit(
+    const sync_pb::SyncedNotificationAppInfoSpecifics&
+        synced_notification_specifics,
+    const ResultType result_type);
+
+VisitorResult SyncedNotificationSpecificsVisit(
+    const sync_pb::SyncedNotificationSpecifics& synced_notification_specifics,
+    const ResultType result_type);
+
+VisitorResult SearchEngineSpecificsVisit(
+    const sync_pb::SearchEngineSpecifics& search_engine_specifics,
+    const ResultType result_type);
+
+VisitorResult ThemeSpecificsVisit(
+    const sync_pb::ThemeSpecifics& theme_specifics,
+    const ResultType result_type);
+
+VisitorResult TypedUrlSpecificsVisit(
+    const sync_pb::TypedUrlSpecifics& typed_url_specifics,
+    const ResultType result_type);
+
+VisitorResult WalletMaskedCreditCardVisit(
+    const sync_pb::WalletMaskedCreditCard& wallet_masked_card,
+    const ResultType result_type);
+
+VisitorResult WalletPostalAddressVisit(
+    const sync_pb::WalletPostalAddress& wallet_postal_address,
+    const ResultType result_type);
+
+VisitorResult WifiCredentialSpecificsVisit(
+    const sync_pb::WifiCredentialSpecifics& wifi_credential_specifics,
+    const ResultType result_type);
+
+VisitorResult EntitySpecificsVisit(const sync_pb::EntitySpecifics& specifics,
+                                   const ResultType result_type);
+
+VisitorResult SyncEntityVisit(const sync_pb::SyncEntity& entity,
+                              bool include_specifics,
+                              const ResultType result_type);
+
+VisitorResult ClientToServerMessageVisit(
+    const sync_pb::ClientToServerMessage& proto,
+    bool include_specifics,
+    const ResultType result_type);
+
+VisitorResult ClientToServerResponseVisit(
+    const sync_pb::ClientToServerResponse& proto,
+    bool include_specifics,
+    const ResultType result_type);
+
+VisitorResult DatatypeAssociationStatsVisit(
+    const sync_pb::DatatypeAssociationStats& proto,
+    const ResultType result_type);
+
+VisitorResult DebugEventInfoVisit(const sync_pb::DebugEventInfo& proto,
+                                  const ResultType result_type);
+
+VisitorResult DebugInfoVisit(const sync_pb::DebugInfo& proto,
+                             const ResultType result_type);
+
+VisitorResult SyncCycleCompletedEventInfoVisit(
+    const sync_pb::SyncCycleCompletedEventInfo& proto,
+    const ResultType result_type);
+
+VisitorResult ClientConfigParamsVisit(const sync_pb::ClientConfigParams& proto,
+                                      const ResultType result_type);
+
+VisitorResult AttachmentIdProtoVisit(const sync_pb::AttachmentIdProto& proto,
+                                     const ResultType result_type);
+
+VisitorResult EncryptedDataVisit(const sync_pb::EncryptedData& proto,
+                                 const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(key_name);
   // TODO(akalin): Shouldn't blob be of type bytes instead of string?
   SET_BYTES(blob);
-  return value;
-}
-
-std::unique_ptr<base::DictionaryValue> AppSettingsToValue(
-    const sync_pb::AppNotificationSettings& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  return result;
+}
+
+VisitorResult AppSettingsVisit(const sync_pb::AppNotificationSettings& proto,
+                               const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_BOOL(initial_setup_done);
   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);
+  return result;
+}
+
+VisitorResult SessionHeaderVisit(const sync_pb::SessionHeader& proto,
+                                 const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET_REP(window, SessionWindowVisit);
   SET_STR(client_name);
   SET_ENUM(device_type, GetDeviceTypeString);
-  return value;
-}
-
-std::unique_ptr<base::DictionaryValue> SessionTabToValue(
-    const sync_pb::SessionTab& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  return result;
+}
+
+VisitorResult SessionTabVisit(const sync_pb::SessionTab& proto,
+                              const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(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_REP(navigation, TabNavigationVisit);
   SET_BYTES(favicon);
   SET_ENUM(favicon_type, GetFaviconTypeString);
   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());
+  return result;
+}
+
+VisitorResult SessionWindowVisit(const sync_pb::SessionWindow& proto,
+                                 const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_INT32(window_id);
   SET_INT32(selected_tab_index);
   SET_INT32_REP(tab);
   SET_ENUM(browser_type, GetBrowserTypeString);
-  return value;
-}
-
-std::unique_ptr<base::DictionaryValue> TabNavigationToValue(
-    const sync_pb::TabNavigation& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  return result;
+}
+
+VisitorResult TabNavigationVisit(const sync_pb::TabNavigation& proto,
+                                 const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(virtual_url);
   SET_STR(referrer);
   SET_STR(title);
   SET_ENUM(page_transition, GetPageTransitionString);
   SET_ENUM(redirect_type, GetPageTransitionRedirectTypeString);
   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_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_REP(navigation_redirect, NavigationRedirectVisit);
   SET_STR(last_navigation_redirect_url);
   SET_INT32(correct_referrer_policy);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> NavigationRedirectToValue(
-    const sync_pb::NavigationRedirect& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult NavigationRedirectVisit(const sync_pb::NavigationRedirect& proto,
+                                      const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(url);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> PasswordSpecificsDataToValue(
-    const sync_pb::PasswordSpecificsData& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult PasswordSpecificsDataVisit(
+    const sync_pb::PasswordSpecificsData& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_INT32(scheme);
   SET_STR(signon_realm);
   SET_STR(origin);
   SET_STR(action);
   SET_STR(username_element);
   SET_STR(username_value);
   SET_STR(password_element);
-  value->SetString("password_value", "<redacted>");
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_dict_value()->SetString("password_value", "<redacted>");
   SET_BOOL(ssl_valid);
   SET_BOOL(preferred);
   SET_INT64(date_created);
   SET_BOOL(blacklisted);
   SET_INT32(type);
   SET_INT32(times_used);
   SET_STR(display_name);
   SET_STR(avatar_url);
   SET_STR(federation_url);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> GlobalIdDirectiveToValue(
-    const sync_pb::GlobalIdDirective& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult GlobalIdDirectiveVisit(const sync_pb::GlobalIdDirective& proto,
+                                     const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_INT64_REP(global_id);
   SET_INT64(start_time_usec);
   SET_INT64(end_time_usec);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> TimeRangeDirectiveToValue(
-    const sync_pb::TimeRangeDirective& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult TimeRangeDirectiveVisit(const sync_pb::TimeRangeDirective& proto,
+                                      const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_INT64(start_time_usec);
   SET_INT64(end_time_usec);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> AppListSpecificsToValue(
-    const sync_pb::AppListSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult AppListSpecificsVisit(const sync_pb::AppListSpecifics& proto,
+                                    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(item_id);
   SET_ENUM(item_type, GetAppListItemTypeString);
   SET_STR(item_name);
   SET_STR(parent_id);
   SET_STR(item_ordinal);
   SET_STR(item_pin_ordinal);
 
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ArcPackageSpecificsToValue(
-    const sync_pb::ArcPackageSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ArcPackageSpecificsVisit(
+    const sync_pb::ArcPackageSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(package_name);
   SET_INT32(package_version);
   SET_INT64(last_backup_android_id);
   SET_INT64(last_backup_time);
 
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> AppNotificationToValue(
-    const sync_pb::AppNotification& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult AppNotificationVisit(const sync_pb::AppNotification& proto,
+                                   const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(guid);
   SET_STR(app_id);
   SET_INT64(creation_timestamp_ms);
   SET_STR(title);
   SET_STR(body_text);
   SET_STR(link_url);
   SET_STR(link_text);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> AppSettingSpecificsToValue(
-    const sync_pb::AppSettingSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET(extension_setting, ExtensionSettingSpecificsToValue);
-  return value;
+VisitorResult AppSettingSpecificsVisit(
+    const sync_pb::AppSettingSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET(extension_setting, ExtensionSettingSpecificsVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> LinkedAppIconInfoToValue(
-    const sync_pb::LinkedAppIconInfo& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult LinkedAppIconInfoVisit(const sync_pb::LinkedAppIconInfo& proto,
+                                     const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(url);
   SET_INT32(size);
-  return value;
+  return result;
 }
 
-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);
+VisitorResult AppSpecificsVisit(const sync_pb::AppSpecifics& proto,
+                                const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET(extension, ExtensionSpecificsVisit);
+  SET(notification_settings, AppSettingsVisit);
   SET_STR(app_launch_ordinal);
   SET_STR(page_ordinal);
   SET_ENUM(launch_type, GetLaunchTypeString);
   SET_STR(bookmark_app_url);
   SET_STR(bookmark_app_description);
   SET_STR(bookmark_app_icon_color);
-  SET_REP(linked_app_icons, LinkedAppIconInfoToValue);
+  SET_REP(linked_app_icons, LinkedAppIconInfoVisit);
 
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> AutofillSpecificsToValue(
-    const sync_pb::AutofillSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult AutofillSpecificsVisit(const sync_pb::AutofillSpecifics& proto,
+                                     const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(name);
   SET_STR(value);
   SET_INT64_REP(usage_timestamp);
-  SET(profile, AutofillProfileSpecificsToValue);
-  return value;
+  SET(profile, AutofillProfileSpecificsVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> AutofillProfileSpecificsToValue(
-    const sync_pb::AutofillProfileSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult AutofillProfileSpecificsVisit(
+    const sync_pb::AutofillProfileSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(guid);
   SET_STR(origin);
   SET_INT64(use_count);
   SET_INT64(use_date);
 
   SET_STR_REP(name_first);
   SET_STR_REP(name_middle);
   SET_STR_REP(name_last);
   SET_STR_REP(name_full);
   SET_STR_REP(email_address);
   SET_STR(company_name);
 
   SET_STR(address_home_line1);
   SET_STR(address_home_line2);
   SET_STR(address_home_city);
   SET_STR(address_home_state);
   SET_STR(address_home_zip);
   SET_STR(address_home_country);
 
   SET_STR(address_home_street_address);
   SET_STR(address_home_sorting_code);
   SET_STR(address_home_dependent_locality);
   SET_STR(address_home_language_code);
 
   SET_STR_REP(phone_home_whole_number);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> WalletMetadataSpecificsToValue(
-    const sync_pb::WalletMetadataSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult WalletMetadataSpecificsVisit(
+    const sync_pb::WalletMetadataSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_ENUM(type, GetWalletMetadataTypeString);
   SET_STR(id);
   SET_INT64(use_count);
   SET_INT64(use_date);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> AutofillWalletSpecificsToValue(
-    const sync_pb::AutofillWalletSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult AutofillWalletSpecificsVisit(
+    const sync_pb::AutofillWalletSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
 
   SET_ENUM(type, GetWalletInfoTypeString);
   if (proto.type() == sync_pb::AutofillWalletSpecifics::MASKED_CREDIT_CARD) {
-    value->Set("masked_card",
-               WalletMaskedCreditCardToValue(proto.masked_card()));
+    SET_WITH_EXPR(masked_card,
+                  WalletMaskedCreditCardVisit(proto.masked_card(), result_type),
+                  sizeof(sync_pb::WalletMaskedCreditCard));
   } else if (proto.type() == sync_pb::AutofillWalletSpecifics::POSTAL_ADDRESS) {
-    value->Set("address",
-               WalletPostalAddressToValue(proto.address()));
+    SET_WITH_EXPR(address,
+                  WalletPostalAddressVisit(proto.address(), result_type),
+                  sizeof(sync_pb::WalletPostalAddress));
   }
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> MetaInfoToValue(
-    const sync_pb::MetaInfo& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult MetaInfoVisit(const sync_pb::MetaInfo& proto,
+                            const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(key);
   SET_STR(value);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> BookmarkSpecificsToValue(
-    const sync_pb::BookmarkSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult BookmarkSpecificsVisit(const sync_pb::BookmarkSpecifics& proto,
+                                     const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(url);
   SET_BYTES(favicon);
   SET_STR(title);
   SET_INT64(creation_time_us);
   SET_STR(icon_url);
-  SET_REP(meta_info, &MetaInfoToValue);
-  return value;
+  SET_REP(meta_info, &MetaInfoVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> DeviceInfoSpecificsToValue(
-    const sync_pb::DeviceInfoSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult DeviceInfoSpecificsVisit(
+    const sync_pb::DeviceInfoSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(cache_guid);
   SET_STR(client_name);
   SET_ENUM(device_type, GetDeviceTypeString);
   SET_STR(sync_user_agent);
   SET_STR(chrome_version);
   SET_STR(signin_scoped_device_id);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> DictionarySpecificsToValue(
-    const sync_pb::DictionarySpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult DictionarySpecificsVisit(
+    const sync_pb::DictionarySpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(word);
-  return value;
+  return result;
 }
 
 namespace {
 
-std::unique_ptr<base::DictionaryValue> FaviconSyncFlagsToValue(
-    const sync_pb::FaviconSyncFlags& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult FaviconSyncFlagsVisit(const sync_pb::FaviconSyncFlags& proto,
+                                    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_BOOL(enabled);
   SET_INT32(favicon_sync_limit);
-  return value;
+  return result;
 }
 
 }  // namespace
 
-std::unique_ptr<base::DictionaryValue> ExperimentsSpecificsToValue(
-    const sync_pb::ExperimentsSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ExperimentsSpecificsVisit(
+    const sync_pb::ExperimentsSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_EXPERIMENT_ENABLED_FIELD(keystore_encryption);
   SET_EXPERIMENT_ENABLED_FIELD(history_delete_directives);
   SET_EXPERIMENT_ENABLED_FIELD(autofill_culling);
   SET_EXPERIMENT_ENABLED_FIELD(pre_commit_update_avoidance);
-  SET(favicon_sync, FaviconSyncFlagsToValue);
+  SET(favicon_sync, FaviconSyncFlagsVisit);
   SET_EXPERIMENT_ENABLED_FIELD(gcm_channel);
   SET_EXPERIMENT_ENABLED_FIELD(gcm_invalidations);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ExtensionSettingSpecificsToValue(
-    const sync_pb::ExtensionSettingSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ExtensionSettingSpecificsVisit(
+    const sync_pb::ExtensionSettingSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(extension_id);
   SET_STR(key);
   SET_STR(value);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ExtensionSpecificsToValue(
-    const sync_pb::ExtensionSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ExtensionSpecificsVisit(const sync_pb::ExtensionSpecifics& proto,
+                                      const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(id);
   SET_STR(version);
   SET_STR(update_url);
   SET_BOOL(enabled);
   SET_BOOL(incognito_enabled);
   SET_STR(name);
   SET_BOOL(remote_install);
   SET_BOOL(installed_by_custodian);
   SET_BOOL(all_urls_enabled);
   SET_INT32(disable_reasons);
-  return value;
+  return result;
 }
 
 namespace {
-std::unique_ptr<base::DictionaryValue> FaviconDataToValue(
-    const sync_pb::FaviconData& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult FaviconDataVisit(const sync_pb::FaviconData& proto,
+                               const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_BYTES(favicon);
   SET_INT32(width);
   SET_INT32(height);
-  return value;
+  return result;
 }
 }  // namespace
 
-std::unique_ptr<base::DictionaryValue> FaviconImageSpecificsToValue(
-    const sync_pb::FaviconImageSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult FaviconImageSpecificsVisit(
+    const sync_pb::FaviconImageSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(favicon_url);
-  SET(favicon_web, FaviconDataToValue);
-  SET(favicon_web_32, FaviconDataToValue);
-  SET(favicon_touch_64, FaviconDataToValue);
-  SET(favicon_touch_precomposed_64, FaviconDataToValue);
-  return value;
+  SET(favicon_web, FaviconDataVisit);
+  SET(favicon_web_32, FaviconDataVisit);
+  SET(favicon_touch_64, FaviconDataVisit);
+  SET(favicon_touch_precomposed_64, FaviconDataVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> FaviconTrackingSpecificsToValue(
-    const sync_pb::FaviconTrackingSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult FaviconTrackingSpecificsVisit(
+    const sync_pb::FaviconTrackingSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(favicon_url);
   SET_INT64(last_visit_time_ms)
   SET_BOOL(is_bookmarked);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> HistoryDeleteDirectiveSpecificsToValue(
-    const sync_pb::HistoryDeleteDirectiveSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET(global_id_directive, GlobalIdDirectiveToValue);
-  SET(time_range_directive, TimeRangeDirectiveToValue);
-  return value;
+VisitorResult HistoryDeleteDirectiveSpecificsVisit(
+    const sync_pb::HistoryDeleteDirectiveSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET(global_id_directive, GlobalIdDirectiveVisit);
+  SET(time_range_directive, TimeRangeDirectiveVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ManagedUserSettingSpecificsToValue(
-    const sync_pb::ManagedUserSettingSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ManagedUserSettingSpecificsVisit(
+    const sync_pb::ManagedUserSettingSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(name);
   SET_STR(value);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ManagedUserSpecificsToValue(
-    const sync_pb::ManagedUserSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ManagedUserSpecificsVisit(
+    const sync_pb::ManagedUserSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(id);
   SET_STR(name);
   SET_BOOL(acknowledged);
   SET_STR(master_key);
   SET_STR(chrome_avatar);
   SET_STR(chromeos_avatar);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ManagedUserSharedSettingSpecificsToValue(
-    const sync_pb::ManagedUserSharedSettingSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ManagedUserSharedSettingSpecificsVisit(
+    const sync_pb::ManagedUserSharedSettingSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(mu_id);
   SET_STR(key);
   SET_STR(value);
   SET_BOOL(acknowledged);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ManagedUserWhitelistSpecificsToValue(
-    const sync_pb::ManagedUserWhitelistSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ManagedUserWhitelistSpecificsVisit(
+    const sync_pb::ManagedUserWhitelistSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(id);
   SET_STR(name);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> NigoriSpecificsToValue(
-    const sync_pb::NigoriSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET(encryption_keybag, EncryptedDataToValue);
+VisitorResult NigoriSpecificsVisit(const sync_pb::NigoriSpecifics& proto,
+                                   const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET(encryption_keybag, EncryptedDataVisit);
   SET_BOOL(keybag_is_frozen);
   SET_BOOL(encrypt_bookmarks);
   SET_BOOL(encrypt_preferences);
   SET_BOOL(encrypt_autofill_profile);
   SET_BOOL(encrypt_autofill);
   SET_BOOL(encrypt_themes);
   SET_BOOL(encrypt_typed_urls);
   SET_BOOL(encrypt_extension_settings);
   SET_BOOL(encrypt_extensions);
   SET_BOOL(encrypt_sessions);
   SET_BOOL(encrypt_app_settings);
   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_everything);
   SET_BOOL(server_only_was_missing_keystore_migration_time);
   SET_BOOL(sync_tab_favicons);
   SET_ENUM(passphrase_type, PassphraseTypeString);
-  SET(keystore_decryptor_token, EncryptedDataToValue);
+  SET(keystore_decryptor_token, EncryptedDataVisit);
   SET_INT64(keystore_migration_time);
   SET_INT64(custom_passphrase_time);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ArticlePageToValue(
-    const sync_pb::ArticlePage& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ArticlePageVisit(const sync_pb::ArticlePage& proto,
+                               const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(url);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ArticleSpecificsToValue(
-    const sync_pb::ArticleSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ArticleSpecificsVisit(const sync_pb::ArticleSpecifics& proto,
+                                    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(entry_id);
   SET_STR(title);
-  SET_REP(pages, ArticlePageToValue);
-  return value;
+  SET_REP(pages, ArticlePageVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> PasswordSpecificsToValue(
-    const sync_pb::PasswordSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET(encrypted, EncryptedDataToValue);
-  return value;
+VisitorResult PasswordSpecificsVisit(const sync_pb::PasswordSpecifics& proto,
+                                     const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET(encrypted, EncryptedDataVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> PreferenceSpecificsToValue(
-    const sync_pb::PreferenceSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult PreferenceSpecificsVisit(
+    const sync_pb::PreferenceSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(name);
   SET_STR(value);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> PriorityPreferenceSpecificsToValue(
-    const sync_pb::PriorityPreferenceSpecifics& specifics) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET_FIELD(preference, PreferenceSpecificsToValue);
-  return value;
+VisitorResult PriorityPreferenceSpecificsVisit(
+    const sync_pb::PriorityPreferenceSpecifics& specifics,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET_FIELD(preference, PreferenceSpecificsVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue>
-SyncedNotificationAppInfoSpecificsToValue(
-    const sync_pb::SyncedNotificationAppInfoSpecifics& proto) {
-  return base::WrapUnique(new base::DictionaryValue());
+VisitorResult SyncedNotificationAppInfoSpecificsVisit(
+    const sync_pb::SyncedNotificationAppInfoSpecifics& proto,
+    const ResultType result_type) {
+  if (result_type == MEMORY_USAGE)
+    return VisitorResult(sizeof(sync_pb::SyncedNotificationAppInfoSpecifics));
+  return VisitorResult(base::WrapUnique(new base::DictionaryValue()));
 }
 
-std::unique_ptr<base::DictionaryValue> SyncedNotificationSpecificsToValue(
-    const sync_pb::SyncedNotificationSpecifics& proto) {
-  return base::WrapUnique(new base::DictionaryValue());
+VisitorResult SyncedNotificationSpecificsVisit(
+    const sync_pb::SyncedNotificationSpecifics& proto,
+    const ResultType result_type) {
+  if (result_type == MEMORY_USAGE)
+    return VisitorResult(sizeof(sync_pb::SyncedNotificationSpecifics));
+  return VisitorResult(base::WrapUnique(new base::DictionaryValue()));
 }
 
-std::unique_ptr<base::DictionaryValue> SearchEngineSpecificsToValue(
-    const sync_pb::SearchEngineSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult SearchEngineSpecificsVisit(
+    const sync_pb::SearchEngineSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(short_name);
   SET_STR(keyword);
   SET_STR(favicon_url);
   SET_STR(url);
   SET_BOOL(safe_for_autoreplace);
   SET_STR(originating_url);
   SET_INT64(date_created);
   SET_STR(input_encodings);
   SET_BOOL(show_in_default_list);
   SET_STR(suggestions_url);
   SET_INT32(prepopulate_id);
   SET_BOOL(autogenerate_keyword);
   SET_STR(instant_url);
   SET_INT64(last_modified);
   SET_STR(sync_guid);
   SET_STR_REP(alternate_urls);
   SET_STR(search_terms_replacement_key);
   SET_STR(image_url);
   SET_STR(search_url_post_params);
   SET_STR(suggestions_url_post_params);
   SET_STR(instant_url_post_params);
   SET_STR(image_url_post_params);
   SET_STR(new_tab_url);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> SessionSpecificsToValue(
-    const sync_pb::SessionSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult SessionSpecificsVisit(const sync_pb::SessionSpecifics& proto,
+                                    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(session_tag);
-  SET(header, SessionHeaderToValue);
-  SET(tab, SessionTabToValue);
+  SET(header, SessionHeaderVisit);
+  SET(tab, SessionTabVisit);
   SET_INT32(tab_node_id);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ThemeSpecificsToValue(
-    const sync_pb::ThemeSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ThemeSpecificsVisit(const sync_pb::ThemeSpecifics& proto,
+                                  const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_BOOL(use_custom_theme);
   SET_BOOL(use_system_theme_by_default);
   SET_STR(custom_theme_name);
   SET_STR(custom_theme_id);
   SET_STR(custom_theme_update_url);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> TypedUrlSpecificsToValue(
-    const sync_pb::TypedUrlSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult TypedUrlSpecificsVisit(const sync_pb::TypedUrlSpecifics& proto,
+                                     const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(url);
   SET_STR(title);
   SET_BOOL(hidden);
   SET_INT64_REP(visits);
   SET_INT32_REP(visit_transitions);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> WalletMaskedCreditCardToValue(
-    const sync_pb::WalletMaskedCreditCard& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult WalletMaskedCreditCardVisit(
+    const sync_pb::WalletMaskedCreditCard& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(id);
   SET_ENUM(status, GetWalletCardStatusString);
   SET_STR(name_on_card);
   SET_ENUM(type, GetWalletCardTypeString);
   SET_STR(last_four);
   SET_INT32(exp_month);
   SET_INT32(exp_year);
   SET_STR(billing_address_id);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> WalletPostalAddressToValue(
-    const sync_pb::WalletPostalAddress& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult WalletPostalAddressVisit(
+    const sync_pb::WalletPostalAddress& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(id);
   SET_STR(recipient_name);
   SET_STR(company_name);
   SET_STR_REP(street_address);
   SET_STR(address_1);
   SET_STR(address_2);
   SET_STR(address_3);
   SET_STR(address_4);
   SET_STR(postal_code);
   SET_STR(sorting_code);
   SET_STR(country_code);
   SET_STR(phone_number);
   SET_STR(language_code);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> WifiCredentialSpecificsToValue(
-    const sync_pb::WifiCredentialSpecifics& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult WifiCredentialSpecificsVisit(
+    const sync_pb::WifiCredentialSpecifics& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_BYTES(ssid);
   SET_ENUM(security_class, GetWifiCredentialSecurityClassString);
   SET_BYTES(passphrase);
-  return value;
+  return result;
 }
 
-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);
-  SET_FIELD(app_setting, AppSettingSpecificsToValue);
-  SET_FIELD(arc_package, ArcPackageSpecificsToValue);
-  SET_FIELD(article, ArticleSpecificsToValue);
-  SET_FIELD(autofill, AutofillSpecificsToValue);
-  SET_FIELD(autofill_profile, AutofillProfileSpecificsToValue);
-  SET_FIELD(autofill_wallet, AutofillWalletSpecificsToValue);
-  SET_FIELD(wallet_metadata, WalletMetadataSpecificsToValue);
-  SET_FIELD(bookmark, BookmarkSpecificsToValue);
-  SET_FIELD(device_info, DeviceInfoSpecificsToValue);
-  SET_FIELD(dictionary, DictionarySpecificsToValue);
-  SET_FIELD(experiments, ExperimentsSpecificsToValue);
-  SET_FIELD(extension, ExtensionSpecificsToValue);
-  SET_FIELD(extension_setting, ExtensionSettingSpecificsToValue);
-  SET_FIELD(favicon_image, FaviconImageSpecificsToValue);
-  SET_FIELD(favicon_tracking, FaviconTrackingSpecificsToValue);
-  SET_FIELD(history_delete_directive, HistoryDeleteDirectiveSpecificsToValue);
-  SET_FIELD(managed_user_setting, ManagedUserSettingSpecificsToValue);
+VisitorResult EntitySpecificsVisit(const sync_pb::EntitySpecifics& specifics,
+                                   const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET_FIELD(app, AppSpecificsVisit);
+  SET_FIELD(app_list, AppListSpecificsVisit);
+  SET_FIELD(app_notification, AppNotificationVisit);
+  SET_FIELD(app_setting, AppSettingSpecificsVisit);
+  SET_FIELD(arc_package, ArcPackageSpecificsVisit);
+  SET_FIELD(article, ArticleSpecificsVisit);
+  SET_FIELD(autofill, AutofillSpecificsVisit);
+  SET_FIELD(autofill_profile, AutofillProfileSpecificsVisit);
+  SET_FIELD(autofill_wallet, AutofillWalletSpecificsVisit);
+  SET_FIELD(wallet_metadata, WalletMetadataSpecificsVisit);
+  SET_FIELD(bookmark, BookmarkSpecificsVisit);
+  SET_FIELD(device_info, DeviceInfoSpecificsVisit);
+  SET_FIELD(dictionary, DictionarySpecificsVisit);
+  SET_FIELD(experiments, ExperimentsSpecificsVisit);
+  SET_FIELD(extension, ExtensionSpecificsVisit);
+  SET_FIELD(extension_setting, ExtensionSettingSpecificsVisit);
+  SET_FIELD(favicon_image, FaviconImageSpecificsVisit);
+  SET_FIELD(favicon_tracking, FaviconTrackingSpecificsVisit);
+  SET_FIELD(history_delete_directive, HistoryDeleteDirectiveSpecificsVisit);
+  SET_FIELD(managed_user_setting, ManagedUserSettingSpecificsVisit);
   SET_FIELD(managed_user_shared_setting,
-            ManagedUserSharedSettingSpecificsToValue);
-  SET_FIELD(managed_user, ManagedUserSpecificsToValue);
-  SET_FIELD(managed_user_whitelist, ManagedUserWhitelistSpecificsToValue);
-  SET_FIELD(nigori, NigoriSpecificsToValue);
-  SET_FIELD(password, PasswordSpecificsToValue);
-  SET_FIELD(preference, PreferenceSpecificsToValue);
-  SET_FIELD(priority_preference, PriorityPreferenceSpecificsToValue);
-  SET_FIELD(search_engine, SearchEngineSpecificsToValue);
-  SET_FIELD(session, SessionSpecificsToValue);
-  SET_FIELD(synced_notification, SyncedNotificationSpecificsToValue);
+            ManagedUserSharedSettingSpecificsVisit);
+  SET_FIELD(managed_user, ManagedUserSpecificsVisit);
+  SET_FIELD(managed_user_whitelist, ManagedUserWhitelistSpecificsVisit);
+  SET_FIELD(nigori, NigoriSpecificsVisit);
+  SET_FIELD(password, PasswordSpecificsVisit);
+  SET_FIELD(preference, PreferenceSpecificsVisit);
+  SET_FIELD(priority_preference, PriorityPreferenceSpecificsVisit);
+  SET_FIELD(search_engine, SearchEngineSpecificsVisit);
+  SET_FIELD(session, SessionSpecificsVisit);
+  SET_FIELD(synced_notification, SyncedNotificationSpecificsVisit);
   SET_FIELD(synced_notification_app_info,
-            SyncedNotificationAppInfoSpecificsToValue);
-  SET_FIELD(theme, ThemeSpecificsToValue);
-  SET_FIELD(typed_url, TypedUrlSpecificsToValue);
-  SET_FIELD(wifi_credential, WifiCredentialSpecificsToValue);
-  return value;
+            SyncedNotificationAppInfoSpecificsVisit);
+  SET_FIELD(theme, ThemeSpecificsVisit);
+  SET_FIELD(typed_url, TypedUrlSpecificsVisit);
+  SET_FIELD(wifi_credential, WifiCredentialSpecificsVisit);
+  return result;
 }
 
 namespace {
 
-base::StringValue* UniquePositionToStringValue(
-    const sync_pb::UniquePosition& proto) {
+VisitorResult UniquePositionToStringValue(const sync_pb::UniquePosition& proto,
+                                          const ResultType result_type) {
+  if (result_type == MEMORY_USAGE) {
+    VisitorResult result(0);
+    SET_STR(compressed_value);
+    SET_STR(custom_compressed_v1);
+    return result;
+  }
   UniquePosition pos = UniquePosition::FromProto(proto);
-  return new base::StringValue(pos.ToDebugString());
+  return VisitorResult(
+      base::WrapUnique(new base::StringValue(pos.ToDebugString())));
 }
 
 }  // namespace
 
-std::unique_ptr<base::DictionaryValue> SyncEntityToValue(
-    const sync_pb::SyncEntity& proto,
-    bool include_specifics) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult SyncEntityVisit(const sync_pb::SyncEntity& proto,
+                              bool include_specifics,
+                              const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(id_string);
   SET_STR(parent_id_string);
   SET_STR(old_parent_id);
   SET_INT64(version);
   SET_INT64(mtime);
   SET_INT64(ctime);
   SET_STR(name);
   SET_STR(non_unique_name);
   SET_INT64(sync_timestamp);
   SET_STR(server_defined_unique_tag);
   SET_INT64(position_in_parent);
   SET(unique_position, UniquePositionToStringValue);
   SET_STR(insert_after_item_id);
   SET_BOOL(deleted);
   SET_STR(originator_cache_guid);
   SET_STR(originator_client_item_id);
   if (include_specifics)
-    SET(specifics, EntitySpecificsToValue);
+    SET(specifics, EntitySpecificsVisit);
   SET_BOOL(folder);
   SET_STR(client_defined_unique_tag);
-  SET_REP(attachment_id, AttachmentIdProtoToValue);
-  return value;
+  SET_REP(attachment_id, AttachmentIdProtoVisit);
+  return result;
 }
 
 namespace {
 
-base::ListValue* SyncEntitiesToValue(
+VisitorResult SyncEntitiesVisit(
     const ::google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>& entities,
-    bool include_specifics) {
-  base::ListValue* list = new base::ListValue();
+    bool include_specifics,
+    const ResultType result_type) {
   ::google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>::const_iterator it;
+  if (result_type == MEMORY_USAGE) {
+    size_t total = 0;
+    for (it = entities.begin(); it != entities.end(); ++it) {
+      total +=
+          SyncEntityVisit(*it, include_specifics, result_type).memory_usage +
+          sizeof(sync_pb::SyncEntity);
+    }
+    return VisitorResult(total);
+  }
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (it = entities.begin(); it != entities.end(); ++it) {
-    list->Append(SyncEntityToValue(*it, include_specifics));
+    list->Append(SyncEntityVisit(*it, include_specifics, result_type).as_value);
   }
-
-  return list;
+  return VisitorResult(std::move(list));
 }
 
-std::unique_ptr<base::DictionaryValue> ChromiumExtensionActivityToValue(
-    const sync_pb::ChromiumExtensionsActivity& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ChromiumExtensionActivityVisit(
+    const sync_pb::ChromiumExtensionsActivity& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(extension_id);
   SET_INT32(bookmark_writes_since_last_commit);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> CommitMessageToValue(
-    const sync_pb::CommitMessage& proto,
-    bool include_specifics) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->Set("entries",
-             SyncEntitiesToValue(proto.entries(), include_specifics));
+VisitorResult CommitMessageVisit(const sync_pb::CommitMessage& proto,
+                                 bool include_specifics,
+                                 const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET_WITH_EXPR(
+      entries,
+      SyncEntitiesVisit(proto.entries(), include_specifics, result_type), 0);
   SET_STR(cache_guid);
-  SET_REP(extensions_activity, ChromiumExtensionActivityToValue);
-  SET(config_params, ClientConfigParamsToValue);
-  return value;
+  SET_REP(extensions_activity, ChromiumExtensionActivityVisit);
+  SET(config_params, ClientConfigParamsVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> GetUpdateTriggersToValue(
-    const sync_pb::GetUpdateTriggers& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult GetUpdateTriggersVisit(const sync_pb::GetUpdateTriggers& proto,
+                                     const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR_REP(notification_hint);
   SET_BOOL(client_dropped_hints);
   SET_BOOL(invalidations_out_of_sync);
   SET_INT64(local_modification_nudges);
   SET_INT64(datatype_refresh_nudges);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> DataTypeProgressMarkerToValue(
-    const sync_pb::DataTypeProgressMarker& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult DataTypeProgressMarkerVisit(
+    const sync_pb::DataTypeProgressMarker& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_INT32(data_type_id);
   SET_BYTES(token);
   SET_INT64(timestamp_token_for_migration);
   SET_STR(notification_hint);
-  SET(get_update_triggers, GetUpdateTriggersToValue);
-  return value;
+  SET(get_update_triggers, GetUpdateTriggersVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> DataTypeContextToValue(
-    const sync_pb::DataTypeContext& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult DataTypeContextVisit(const sync_pb::DataTypeContext& proto,
+                                   const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_INT32(data_type_id);
   SET_STR(context);
   SET_INT64(version);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> GetUpdatesCallerInfoToValue(
-    const sync_pb::GetUpdatesCallerInfo& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult GetUpdatesCallerInfoVisit(
+    const sync_pb::GetUpdatesCallerInfo& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_ENUM(source, GetUpdatesSourceString);
   SET_BOOL(notifications_enabled);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> GetUpdatesMessageToValue(
-    const sync_pb::GetUpdatesMessage& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET(caller_info, GetUpdatesCallerInfoToValue);
+VisitorResult GetUpdatesMessageVisit(const sync_pb::GetUpdatesMessage& proto,
+                                     const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET(caller_info, GetUpdatesCallerInfoVisit);
   SET_BOOL(fetch_folders);
   SET_INT32(batch_size);
-  SET_REP(from_progress_marker, DataTypeProgressMarkerToValue);
+  SET_REP(from_progress_marker, DataTypeProgressMarkerVisit);
   SET_BOOL(streaming);
   SET_BOOL(need_encryption_key);
   SET_BOOL(create_mobile_bookmarks_folder);
   SET_ENUM(get_updates_origin, GetUpdatesOriginString);
-  SET_REP(client_contexts, DataTypeContextToValue);
-  return value;
+  SET_REP(client_contexts, DataTypeContextVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ClientStatusToValue(
-    const sync_pb::ClientStatus& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ClientStatusVisit(const sync_pb::ClientStatus& proto,
+                                const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_BOOL(hierarchy_conflict_detected);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> EntryResponseToValue(
-    const sync_pb::CommitResponse::EntryResponse& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult EntryResponseVisit(
+    const sync_pb::CommitResponse::EntryResponse& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_ENUM(response_type, GetResponseTypeString);
   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;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> CommitResponseToValue(
-    const sync_pb::CommitResponse& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET_REP(entryresponse, EntryResponseToValue);
-  return value;
+VisitorResult CommitResponseVisit(const sync_pb::CommitResponse& proto,
+                                  const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET_REP(entryresponse, EntryResponseVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> GetUpdatesResponseToValue(
-    const sync_pb::GetUpdatesResponse& proto,
-    bool include_specifics) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->Set("entries",
-             SyncEntitiesToValue(proto.entries(), include_specifics));
+VisitorResult GetUpdatesResponseVisit(const sync_pb::GetUpdatesResponse& proto,
+                                      bool include_specifics,
+                                      const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET_WITH_EXPR(
+      entries,
+      SyncEntitiesVisit(proto.entries(), include_specifics, result_type), 0);
   SET_INT64(changes_remaining);
-  SET_REP(new_progress_marker, DataTypeProgressMarkerToValue);
-  SET_REP(context_mutations, DataTypeContextToValue);
-  return value;
+  SET_REP(new_progress_marker, DataTypeProgressMarkerVisit);
+  SET_REP(context_mutations, DataTypeContextVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ClientCommandToValue(
-    const sync_pb::ClientCommand& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ClientCommandVisit(const sync_pb::ClientCommand& proto,
+                                 const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_INT32(set_sync_poll_interval);
   SET_INT32(set_sync_long_poll_interval);
   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;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ErrorToValue(
-    const sync_pb::ClientToServerResponse::Error& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult ErrorVisit(const sync_pb::ClientToServerResponse::Error& proto,
+                         const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_ENUM(error_type, GetErrorTypeString);
   SET_STR(error_description);
   SET_STR(url);
   SET_ENUM(action, GetActionString);
-  return value;
+  return result;
 }
 
 }  // namespace
 
-std::unique_ptr<base::DictionaryValue> ClientToServerResponseToValue(
+VisitorResult ClientToServerResponseVisit(
     const sync_pb::ClientToServerResponse& proto,
-    bool include_specifics) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET(commit, CommitResponseToValue);
+    bool include_specifics,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET(commit, CommitResponseVisit);
   if (proto.has_get_updates()) {
-    value->Set("get_updates", GetUpdatesResponseToValue(proto.get_updates(),
-                                                        include_specifics));
+    SET_WITH_EXPR(get_updates,
+                  GetUpdatesResponseVisit(proto.get_updates(),
+                                          include_specifics, result_type),
+                  sizeof(proto.get_updates()));
   }
 
-  SET(error, ErrorToValue);
+  SET(error, ErrorVisit);
   SET_ENUM(error_code, GetErrorTypeString);
   SET_STR(error_message);
   SET_STR(store_birthday);
-  SET(client_command, ClientCommandToValue);
+  SET(client_command, ClientCommandVisit);
   SET_INT32_REP(migrated_data_type_id);
-  return value;
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> ClientToServerMessageToValue(
+VisitorResult ClientToServerMessageVisit(
     const sync_pb::ClientToServerMessage& proto,
-    bool include_specifics) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+    bool include_specifics,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_STR(share);
   SET_INT32(protocol_version);
   if (proto.has_commit()) {
-    value->Set("commit",
-               CommitMessageToValue(proto.commit(), include_specifics));
+    SET_WITH_EXPR(commit, CommitMessageVisit(proto.commit(), include_specifics,
+                                             result_type),
+                  sizeof(proto.commit()));
   }
 
-  SET(get_updates, GetUpdatesMessageToValue);
+  SET(get_updates, GetUpdatesMessageVisit);
   SET_STR(store_birthday);
   SET_BOOL(sync_problem_detected);
-  SET(debug_info, DebugInfoToValue);
-  SET(client_status, ClientStatusToValue);
-  return value;
+  SET(debug_info, DebugInfoVisit);
+  SET(client_status, ClientStatusVisit);
+  return result;
 }
 
-std::unique_ptr<base::DictionaryValue> DatatypeAssociationStatsToValue(
-    const sync_pb::DatatypeAssociationStats& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+VisitorResult DatatypeAssociationStatsVisit(
+    const sync_pb::DatatypeAssociationStats& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_INT32(data_type_id);
   SET_INT32(num_local_items_before_association);
   SET_INT32(num_sync_items_before_association);
   SET_INT32(num_local_items_after_association);
   SET_INT32(num_sync_items_after_association);
   SET_INT32(num_local_items_added);
   SET_INT32(num_local_items_deleted);
   SET_INT32(num_local_items_modified);
   SET_INT32(num_sync_items_added);
   SET_INT32(num_sync_items_deleted);
   SET_INT32(num_sync_items_modified);
   SET_INT64(local_version_pre_association);
   SET_INT64(sync_version_pre_association)
   SET_BOOL(had_error);
   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());
+  return result;
+}
+
+VisitorResult DebugEventInfoVisit(const sync_pb::DebugEventInfo& proto,
+                                  const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_ENUM(singleton_event, SingletonDebugEventTypeString);
-  SET(sync_cycle_completed_event_info, SyncCycleCompletedEventInfoToValue);
+  SET(sync_cycle_completed_event_info, SyncCycleCompletedEventInfoVisit);
   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());
-  SET_REP(events, DebugEventInfoToValue);
+  SET(datatype_association_stats, DatatypeAssociationStatsVisit);
+  return result;
+}
+
+VisitorResult DebugInfoVisit(const sync_pb::DebugInfo& proto,
+                             const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET_REP(events, DebugEventInfoVisit);
   SET_BOOL(cryptographer_ready);
   SET_BOOL(cryptographer_has_pending_keys);
   SET_BOOL(events_dropped);
-  return value;
-}
-
-std::unique_ptr<base::DictionaryValue> SyncCycleCompletedEventInfoToValue(
-    const sync_pb::SyncCycleCompletedEventInfo& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  return result;
+}
+
+VisitorResult SyncCycleCompletedEventInfoVisit(
+    const sync_pb::SyncCycleCompletedEventInfo& proto,
+    const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_INT32(num_encryption_conflicts);
   SET_INT32(num_hierarchy_conflicts);
   SET_INT32(num_server_conflicts);
   SET_INT32(num_updates_downloaded);
   SET_INT32(num_reflected_updates_downloaded);
-  SET(caller_info, GetUpdatesCallerInfoToValue);
-  return value;
-}
-
-std::unique_ptr<base::DictionaryValue> ClientConfigParamsToValue(
-    const sync_pb::ClientConfigParams& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  SET(caller_info, GetUpdatesCallerInfoVisit);
+  return result;
+}
+
+VisitorResult ClientConfigParamsVisit(const sync_pb::ClientConfigParams& proto,
+                                      const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
   SET_INT32_REP(enabled_type_ids);
   SET_BOOL(tabs_datatype_enabled);
   SET_BOOL(cookie_jar_mismatch);
-  return value;
+  return result;
+}
+
+VisitorResult AttachmentIdProtoVisit(const sync_pb::AttachmentIdProto& proto,
+                                     const ResultType result_type) {
+  VisitorResult result(0);
+  if (result_type == CONVERT_TO_VALUE)
+    result.as_value.reset(new base::DictionaryValue());
+  SET_STR(unique_id);
+  return result;
+}
+
+std::unique_ptr<base::DictionaryValue> EncryptedDataToValue(
+    const sync_pb::EncryptedData& encrypted_data) {
+  return EncryptedDataVisit(encrypted_data, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> AppListSpecificsToValue(
+    const sync_pb::AppListSpecifics& proto) {
+  return AppListSpecificsVisit(proto, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> AppSettingsToValue(
+    const sync_pb::AppNotificationSettings& app_notification_settings) {
+  return AppSettingsVisit(app_notification_settings, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> LinkedAppIconInfoToValue(
+    const sync_pb::LinkedAppIconInfo& linked_app_icon_info) {
+  return LinkedAppIconInfoVisit(linked_app_icon_info, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> SessionHeaderToValue(
+    const sync_pb::SessionHeader& session_header) {
+  return SessionHeaderVisit(session_header, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> SessionTabToValue(
+    const sync_pb::SessionTab& session_tab) {
+  return SessionTabVisit(session_tab, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> SessionWindowToValue(
+    const sync_pb::SessionWindow& session_window) {
+  return SessionWindowVisit(session_window, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> TabNavigationToValue(
+    const sync_pb::TabNavigation& tab_navigation) {
+  return TabNavigationVisit(tab_navigation, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> NavigationRedirectToValue(
+    const sync_pb::NavigationRedirect& navigation_redirect) {
+  return NavigationRedirectVisit(navigation_redirect, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> PasswordSpecificsDataToValue(
+    const sync_pb::PasswordSpecificsData& password_specifics_data) {
+  return PasswordSpecificsDataVisit(password_specifics_data, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> GlobalIdDirectiveToValue(
+    const sync_pb::GlobalIdDirective& global_id_directive) {
+  return GlobalIdDirectiveVisit(global_id_directive, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> TimeRangeDirectiveToValue(
+    const sync_pb::TimeRangeDirective& time_range_directive) {
+  return TimeRangeDirectiveVisit(time_range_directive, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> SessionSpecificsToValue(
+    const sync_pb::SessionSpecifics& session_specifics) {
+  return SessionSpecificsVisit(session_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ArcPackageSpecificsToValue(
+    const sync_pb::ArcPackageSpecifics& proto) {
+  return ArcPackageSpecificsVisit(proto, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> AppNotificationToValue(
+    const sync_pb::AppNotification& app_notification_specifics) {
+  return AppNotificationVisit(app_notification_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> AppSettingSpecificsToValue(
+    const sync_pb::AppSettingSpecifics& app_setting_specifics) {
+  return AppSettingSpecificsVisit(app_setting_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> AppSpecificsToValue(
+    const sync_pb::AppSpecifics& app_specifics) {
+  return AppSpecificsVisit(app_specifics, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ArticleSpecificsToValue(
+    const sync_pb::ArticleSpecifics& article_specifics) {
+  return ArticleSpecificsVisit(article_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> AutofillSpecificsToValue(
+    const sync_pb::AutofillSpecifics& autofill_specifics) {
+  return AutofillSpecificsVisit(autofill_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> AutofillProfileSpecificsToValue(
+    const sync_pb::AutofillProfileSpecifics& autofill_profile_specifics) {
+  return AutofillProfileSpecificsVisit(autofill_profile_specifics,
+                                       CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> WalletMetadataSpecificsToValue(
+    const sync_pb::WalletMetadataSpecifics& wallet_metadata_specifics) {
+  return WalletMetadataSpecificsVisit(wallet_metadata_specifics,
+                                      CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> AutofillWalletSpecificsToValue(
+    const sync_pb::AutofillWalletSpecifics& autofill_wallet_specifics) {
+  return AutofillWalletSpecificsVisit(autofill_wallet_specifics,
+                                      CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> BookmarkSpecificsToValue(
+    const sync_pb::BookmarkSpecifics& bookmark_specifics) {
+  return BookmarkSpecificsVisit(bookmark_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> DeviceInfoSpecificsToValue(
+    const sync_pb::DeviceInfoSpecifics& device_info_specifics) {
+  return DeviceInfoSpecificsVisit(device_info_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> DictionarySpecificsToValue(
+    const sync_pb::DictionarySpecifics& dictionary_specifics) {
+  return DictionarySpecificsVisit(dictionary_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ExperimentsSpecificsToValue(
+    const sync_pb::ExperimentsSpecifics& proto) {
+  return ExperimentsSpecificsVisit(proto, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> PriorityPreferenceSpecificsToValue(
+    const sync_pb::PriorityPreferenceSpecifics& proto) {
+  return PriorityPreferenceSpecificsVisit(proto, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ExtensionSettingSpecificsToValue(
+    const sync_pb::ExtensionSettingSpecifics& extension_setting_specifics) {
+  return ExtensionSettingSpecificsVisit(extension_setting_specifics,
+                                        CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ExtensionSpecificsToValue(
+    const sync_pb::ExtensionSpecifics& extension_specifics) {
+  return ExtensionSpecificsVisit(extension_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> FaviconImageSpecificsToValue(
+    const sync_pb::FaviconImageSpecifics& favicon_image_specifics) {
+  return FaviconImageSpecificsVisit(favicon_image_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> FaviconTrackingSpecificsToValue(
+    const sync_pb::FaviconTrackingSpecifics& favicon_tracking_specifics) {
+  return FaviconTrackingSpecificsVisit(favicon_tracking_specifics,
+                                       CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> HistoryDeleteDirectiveSpecificsToValue(
+    const sync_pb::HistoryDeleteDirectiveSpecifics&
+        history_delete_directive_specifics) {
+  return HistoryDeleteDirectiveSpecificsVisit(
+             history_delete_directive_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ManagedUserSettingSpecificsToValue(
+    const sync_pb::ManagedUserSettingSpecifics&
+        managed_user_setting_specifics) {
+  return ManagedUserSettingSpecificsVisit(managed_user_setting_specifics,
+                                          CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ManagedUserSpecificsToValue(
+    const sync_pb::ManagedUserSpecifics& managed_user_specifics) {
+  return ManagedUserSpecificsVisit(managed_user_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ManagedUserSharedSettingSpecificsToValue(
+    const sync_pb::ManagedUserSharedSettingSpecifics&
+        managed_user_shared_setting_specifics) {
+  return ManagedUserSharedSettingSpecificsVisit(
+             managed_user_shared_setting_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ManagedUserWhitelistSpecificsToValue(
+    const sync_pb::ManagedUserWhitelistSpecifics&
+        managed_user_whitelist_specifics) {
+  return ManagedUserWhitelistSpecificsVisit(managed_user_whitelist_specifics,
+                                            CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> NigoriSpecificsToValue(
+    const sync_pb::NigoriSpecifics& nigori_specifics) {
+  return NigoriSpecificsVisit(nigori_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> PasswordSpecificsToValue(
+    const sync_pb::PasswordSpecifics& password_specifics) {
+  return PasswordSpecificsVisit(password_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> PreferenceSpecificsToValue(
+    const sync_pb::PreferenceSpecifics& password_specifics) {
+  return PreferenceSpecificsVisit(password_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue>
+SyncedNotificationAppInfoSpecificsToValue(
+    const sync_pb::SyncedNotificationAppInfoSpecifics&
+        synced_notification_specifics) {
+  return SyncedNotificationAppInfoSpecificsVisit(synced_notification_specifics,
+                                                 CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> SyncedNotificationSpecificsToValue(
+    const sync_pb::SyncedNotificationSpecifics& synced_notification_specifics) {
+  return SyncedNotificationSpecificsVisit(synced_notification_specifics,
+                                          CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> SearchEngineSpecificsToValue(
+    const sync_pb::SearchEngineSpecifics& search_engine_specifics) {
+  return SearchEngineSpecificsVisit(search_engine_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ThemeSpecificsToValue(
+    const sync_pb::ThemeSpecifics& theme_specifics) {
+  return ThemeSpecificsVisit(theme_specifics, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> TypedUrlSpecificsToValue(
+    const sync_pb::TypedUrlSpecifics& typed_url_specifics) {
+  return TypedUrlSpecificsVisit(typed_url_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> WalletMaskedCreditCardToValue(
+    const sync_pb::WalletMaskedCreditCard& wallet_masked_card) {
+  return WalletMaskedCreditCardVisit(wallet_masked_card, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> WalletPostalAddressToValue(
+    const sync_pb::WalletPostalAddress& wallet_postal_address) {
+  return WalletPostalAddressVisit(wallet_postal_address, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> WifiCredentialSpecificsToValue(
+    const sync_pb::WifiCredentialSpecifics& wifi_credential_specifics) {
+  return WifiCredentialSpecificsVisit(wifi_credential_specifics,
+                                      CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> EntitySpecificsToValue(
+    const sync_pb::EntitySpecifics& specifics) {
+  return EntitySpecificsVisit(specifics, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> SyncEntityToValue(
+    const sync_pb::SyncEntity& entity,
+    bool include_specifics) {
+  return SyncEntityVisit(entity, include_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ClientToServerMessageToValue(
+    const sync_pb::ClientToServerMessage& proto,
+    bool include_specifics) {
+  return ClientToServerMessageVisit(proto, include_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ClientToServerResponseToValue(
+    const sync_pb::ClientToServerResponse& proto,
+    bool include_specifics) {
+  return ClientToServerResponseVisit(proto, include_specifics, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> DatatypeAssociationStatsToValue(
+    const sync_pb::DatatypeAssociationStats& proto) {
+  return DatatypeAssociationStatsVisit(proto, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> DebugEventInfoToValue(
+    const sync_pb::DebugEventInfo& proto) {
+  return DebugEventInfoVisit(proto, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> DebugInfoToValue(
+    const sync_pb::DebugInfo& proto) {
+  return DebugInfoVisit(proto, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> SyncCycleCompletedEventInfoToValue(
+    const sync_pb::SyncCycleCompletedEventInfo& proto) {
+  return SyncCycleCompletedEventInfoVisit(proto, CONVERT_TO_VALUE)
+      .TakeDictValue();
+}
+
+std::unique_ptr<base::DictionaryValue> ClientConfigParamsToValue(
+    const sync_pb::ClientConfigParams& proto) {
+  return ClientConfigParamsVisit(proto, CONVERT_TO_VALUE).TakeDictValue();
 }
 
 std::unique_ptr<base::DictionaryValue> AttachmentIdProtoToValue(
     const sync_pb::AttachmentIdProto& proto) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  SET_STR(unique_id);
-  return value;
-}
-
+  return AttachmentIdProtoVisit(proto, CONVERT_TO_VALUE).TakeDictValue();
+}
+
+size_t GetEntitySpecificsSize(const sync_pb::EntitySpecifics& specifics) {
+  return EntitySpecificsVisit(specifics, MEMORY_USAGE).memory_usage +
+         sizeof(specifics);
+}
+
+#undef SET_WITH_EXPR
 #undef SET_TYPE
 #undef SET
 #undef SET_REP
+#undef SET_ENUM
 
 #undef SET_BOOL
 #undef SET_BYTES
 #undef SET_INT32
 #undef SET_INT64
 #undef SET_INT64_REP
 #undef SET_STR
+#undef SET_TIME_STR
 #undef SET_STR_REP
 
+#undef SET_EXPERIMENT_ENABLED_FIELD
 #undef SET_FIELD
 
 }  // namespace syncer