sync/protocol/proto_value_conversions.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Keep this file in sync with the .proto files in this directory.
   6
   7 #include "sync/protocol/proto_value_conversions.h"
   8
   9 #include <string>
  10
  11 #include "base/base64.h"
  12 #include "base/basictypes.h"
  13 #include "base/logging.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/values.h"
  16 #include "sync/internal_api/public/base/unique_position.h"
  17 #include "sync/protocol/app_list_specifics.pb.h"
  18 #include "sync/protocol/app_notification_specifics.pb.h"
  19 #include "sync/protocol/app_setting_specifics.pb.h"
  20 #include "sync/protocol/app_specifics.pb.h"
  21 #include "sync/protocol/autofill_specifics.pb.h"
  22 #include "sync/protocol/bookmark_specifics.pb.h"
  23 #include "sync/protocol/dictionary_specifics.pb.h"
  24 #include "sync/protocol/encryption.pb.h"
  25 #include "sync/protocol/experiments_specifics.pb.h"
  26 #include "sync/protocol/extension_setting_specifics.pb.h"
  27 #include "sync/protocol/extension_specifics.pb.h"
  28 #include "sync/protocol/favicon_image_specifics.pb.h"
  29 #include "sync/protocol/favicon_tracking_specifics.pb.h"
  30 #include "sync/protocol/history_delete_directive_specifics.pb.h"
  31 #include "sync/protocol/nigori_specifics.pb.h"
  32 #include "sync/protocol/password_specifics.pb.h"
  33 #include "sync/protocol/preference_specifics.pb.h"
  34 #include "sync/protocol/priority_preference_specifics.pb.h"
  35 #include "sync/protocol/proto_enum_conversions.h"
  36 #include "sync/protocol/search_engine_specifics.pb.h"
  37 #include "sync/protocol/session_specifics.pb.h"
  38 #include "sync/protocol/sync.pb.h"
  39 #include "sync/protocol/synced_notification_app_info_specifics.pb.h"
  40 #include "sync/protocol/synced_notification_specifics.pb.h"
  41 #include "sync/protocol/theme_specifics.pb.h"
  42 #include "sync/protocol/typed_url_specifics.pb.h"
  43 #include "sync/protocol/unique_position.pb.h"
  44
  45 namespace syncer {
  46
  47 namespace {
  48
  49 // Basic Type -> Value functions.
  50
  51 base::StringValue* MakeInt64Value(int64 x) {
  52   return new base::StringValue(base::Int64ToString(x));
  53 }
  54
  55 // TODO(akalin): Perhaps make JSONWriter support BinaryValue and use
  56 // that instead of a StringValue.
  57 base::StringValue* MakeBytesValue(const std::string& bytes) {
  58   std::string bytes_base64;
  59   base::Base64Encode(bytes, &bytes_base64);
  60   return new base::StringValue(bytes_base64);
  61 }
  62
  63 base::StringValue* MakeStringValue(const std::string& str) {
  64   return new base::StringValue(str);
  65 }
  66
  67 // T is the enum type.
  68 template <class T>
  69 base::StringValue* MakeEnumValue(T t, const char* (*converter_fn)(T)) {
  70   return new base::StringValue(converter_fn(t));
  71 }
  72
  73 // T is the field type, F is either RepeatedField or RepeatedPtrField,
  74 // and V is a subclass of Value.
  75 template <class T, class F, class V>
  76 base::ListValue* MakeRepeatedValue(const F& fields, V* (*converter_fn)(T)) {
  77   base::ListValue* list = new base::ListValue();
  78   for (typename F::const_iterator it = fields.begin(); it != fields.end();
  79        ++it) {
  80     list->Append(converter_fn(*it));
  81   }
  82   return list;
  83 }
  84
  85 }  // namespace
  86
  87 // Helper macros to reduce the amount of boilerplate.
  88
  89 #define SET(field, fn) \
  90   if (proto.has_##field()) { \
  91     value->Set(#field, fn(proto.field())); \
  92   }
  93 #define SET_REP(field, fn) \
  94   value->Set(#field, MakeRepeatedValue(proto.field(), fn))
  95 #define SET_ENUM(field, fn) \
  96   value->Set(#field, MakeEnumValue(proto.field(), fn))
  97
  98 #define SET_BOOL(field) SET(field, new base::FundamentalValue)
  99 #define SET_BYTES(field) SET(field, MakeBytesValue)
 100 #define SET_INT32(field) SET(field, MakeInt64Value)
 101 #define SET_INT32_REP(field) SET_REP(field, MakeInt64Value)
 102 #define SET_INT64(field) SET(field, MakeInt64Value)
 103 #define SET_INT64_REP(field) SET_REP(field, MakeInt64Value)
 104 #define SET_STR(field) SET(field, new base::StringValue)
 105 #define SET_STR_REP(field) \
 106   value->Set(#field, \
 107              MakeRepeatedValue<const std::string&, \
 108                                google::protobuf::RepeatedPtrField< \
 109                                    std::string >, \
 110                                base::StringValue>(proto.field(), \
 111                                             MakeStringValue))
 112 #define SET_EXPERIMENT_ENABLED_FIELD(field)          \
 113   do {                                               \
 114     if (proto.has_##field() &&                       \
 115         proto.field().has_enabled()) {               \
 116       value->Set(#field,                             \
 117                  new base::FundamentalValue(         \
 118                      proto.field().enabled()));      \
 119     }                                                \
 120   } while (0)
 121
 122 #define SET_FIELD(field, fn)                         \
 123   do {                                               \
 124     if (specifics.has_##field()) {                   \
 125       value->Set(#field, fn(specifics.field()));     \
 126     }                                                \
 127   } while (0)
 128
 129 // If you add another macro, don't forget to add an #undef at the end
 130 // of this file, too.
 131
 132 base::DictionaryValue* EncryptedDataToValue(
 133     const sync_pb::EncryptedData& proto) {
 134   base::DictionaryValue* value = new base::DictionaryValue();
 135   SET_STR(key_name);
 136   // TODO(akalin): Shouldn't blob be of type bytes instead of string?
 137   SET_BYTES(blob);
 138   return value;
 139 }
 140
 141 base::DictionaryValue* AppSettingsToValue(
 142     const sync_pb::AppNotificationSettings& proto) {
 143   base::DictionaryValue* value = new base::DictionaryValue();
 144   SET_BOOL(initial_setup_done);
 145   SET_BOOL(disabled);
 146   SET_STR(oauth_client_id);
 147   return value;
 148 }
 149
 150 base::DictionaryValue* SessionHeaderToValue(
 151     const sync_pb::SessionHeader& proto) {
 152   base::DictionaryValue* value = new base::DictionaryValue();
 153   SET_REP(window, SessionWindowToValue);
 154   SET_STR(client_name);
 155   SET_ENUM(device_type, GetDeviceTypeString);
 156   return value;
 157 }
 158
 159 base::DictionaryValue* SessionTabToValue(const sync_pb::SessionTab& proto) {
 160   base::DictionaryValue* value = new base::DictionaryValue();
 161   SET_INT32(tab_id);
 162   SET_INT32(window_id);
 163   SET_INT32(tab_visual_index);
 164   SET_INT32(current_navigation_index);
 165   SET_BOOL(pinned);
 166   SET_STR(extension_app_id);
 167   SET_REP(navigation, TabNavigationToValue);
 168   SET_BYTES(favicon);
 169   SET_ENUM(favicon_type, GetFaviconTypeString);
 170   SET_STR(favicon_source);
 171   return value;
 172 }
 173
 174 base::DictionaryValue* SessionWindowToValue(
 175     const sync_pb::SessionWindow& proto) {
 176   base::DictionaryValue* value = new base::DictionaryValue();
 177   SET_INT32(window_id);
 178   SET_INT32(selected_tab_index);
 179   SET_INT32_REP(tab);
 180   SET_ENUM(browser_type, GetBrowserTypeString);
 181   return value;
 182 }
 183
 184 base::DictionaryValue* TabNavigationToValue(
 185     const sync_pb::TabNavigation& proto) {
 186   base::DictionaryValue* value = new base::DictionaryValue();
 187   SET_STR(virtual_url);
 188   SET_STR(referrer);
 189   SET_STR(title);
 190   SET_STR(state);
 191   SET_ENUM(page_transition, GetPageTransitionString);
 192   SET_ENUM(redirect_type, GetPageTransitionRedirectTypeString);
 193   SET_INT32(unique_id);
 194   SET_INT64(timestamp_msec);
 195   SET_BOOL(navigation_forward_back);
 196   SET_BOOL(navigation_from_address_bar);
 197   SET_BOOL(navigation_home_page);
 198   SET_BOOL(navigation_chain_start);
 199   SET_BOOL(navigation_chain_end);
 200   SET_INT64(global_id);
 201   SET_STR(search_terms);
 202   SET_STR(favicon_url);
 203   SET_ENUM(blocked_state, GetBlockedStateString);
 204   SET_STR_REP(content_pack_categories);
 205   SET_INT32(http_status_code);
 206   SET_INT32(referrer_policy);
 207   SET_BOOL(is_restored);
 208   return value;
 209 }
 210
 211 base::DictionaryValue* PasswordSpecificsDataToValue(
 212     const sync_pb::PasswordSpecificsData& proto) {
 213   base::DictionaryValue* value = new base::DictionaryValue();
 214   SET_INT32(scheme);
 215   SET_STR(signon_realm);
 216   SET_STR(origin);
 217   SET_STR(action);
 218   SET_STR(username_element);
 219   SET_STR(username_value);
 220   SET_STR(password_element);
 221   value->SetString("password_value", "<redacted>");
 222   SET_BOOL(ssl_valid);
 223   SET_BOOL(preferred);
 224   SET_INT64(date_created);
 225   SET_BOOL(blacklisted);
 226   return value;
 227 }
 228
 229 base::DictionaryValue* GlobalIdDirectiveToValue(
 230     const sync_pb::GlobalIdDirective& proto) {
 231   base::DictionaryValue* value = new base::DictionaryValue();
 232   SET_INT64_REP(global_id);
 233   SET_INT64(start_time_usec);
 234   SET_INT64(end_time_usec);
 235   return value;
 236 }
 237
 238 base::DictionaryValue* TimeRangeDirectiveToValue(
 239     const sync_pb::TimeRangeDirective& proto) {
 240   base::DictionaryValue* value = new base::DictionaryValue();
 241   SET_INT64(start_time_usec);
 242   SET_INT64(end_time_usec);
 243   return value;
 244 }
 245
 246 base::DictionaryValue* SyncedNotificationAppInfoToValue(
 247     const sync_pb::SyncedNotificationAppInfo& proto) {
 248   base::DictionaryValue* value = new base::DictionaryValue();
 249   SET_STR_REP(app_id);
 250   SET_STR(settings_display_name);
 251   SET(icon, SyncedNotificationImageToValue);
 252   // TODO(petewil): Add fields for the monochrome icon when it is available.
 253   return value;
 254 }
 255
 256 base::DictionaryValue* SyncedNotificationImageToValue(
 257     const sync_pb::SyncedNotificationImage& proto) {
 258   base::DictionaryValue* value = new base::DictionaryValue();
 259   SET_STR(url);
 260   SET_STR(alt_text);
 261   SET_INT32(preferred_width);
 262   SET_INT32(preferred_height);
 263   return value;
 264 }
 265
 266 base::DictionaryValue* SyncedNotificationProfileImageToValue(
 267     const sync_pb::SyncedNotificationProfileImage& proto) {
 268   base::DictionaryValue* value = new base::DictionaryValue();
 269   SET_STR(image_url);
 270   SET_STR(oid);
 271   SET_STR(display_name);
 272   return value;
 273 }
 274
 275 base::DictionaryValue* MediaToValue(
 276     const sync_pb::Media& proto) {
 277   base::DictionaryValue* value = new base::DictionaryValue();
 278   SET(image, SyncedNotificationImageToValue);
 279   return value;
 280 }
 281
 282 base::DictionaryValue* SyncedNotificationActionToValue(
 283     const sync_pb::SyncedNotificationAction& proto) {
 284   base::DictionaryValue* value = new base::DictionaryValue();
 285   SET_STR(text);
 286   SET(icon, SyncedNotificationImageToValue);
 287   SET_STR(url);
 288   SET_STR(request_data);
 289   SET_STR(accessibility_label);
 290   return value;
 291 }
 292
 293 base::DictionaryValue* SyncedNotificationDestiationToValue(
 294     const sync_pb::SyncedNotificationDestination& proto) {
 295   base::DictionaryValue* value = new base::DictionaryValue();
 296   SET_STR(text);
 297   SET(icon, SyncedNotificationImageToValue);
 298   SET_STR(url);
 299   SET_STR(accessibility_label);
 300   return value;
 301 }
 302
 303 base::DictionaryValue* TargetToValue(
 304     const sync_pb::Target& proto) {
 305   base::DictionaryValue* value = new base::DictionaryValue();
 306   SET(destination, SyncedNotificationDestiationToValue);
 307   SET(action, SyncedNotificationActionToValue);
 308   SET_STR(target_key);
 309   return value;
 310 }
 311
 312 base::DictionaryValue* SimpleCollapsedLayoutToValue(
 313     const sync_pb::SimpleCollapsedLayout& proto) {
 314   base::DictionaryValue* value = new base::DictionaryValue();
 315   SET(app_icon, SyncedNotificationImageToValue);
 316   SET_REP(profile_image, SyncedNotificationProfileImageToValue);
 317   SET_STR(heading);
 318   SET_STR(description);
 319   SET_STR(annotation);
 320   SET_REP(media, MediaToValue);
 321   return value;
 322 }
 323
 324 base::DictionaryValue* CollapsedInfoToValue(
 325     const sync_pb::CollapsedInfo& proto) {
 326   base::DictionaryValue* value = new base::DictionaryValue();
 327   SET(simple_collapsed_layout, SimpleCollapsedLayoutToValue);
 328   SET_INT64(creation_timestamp_usec);
 329   SET(default_destination, SyncedNotificationDestiationToValue);
 330   SET_REP(target, TargetToValue);
 331   return value;
 332 }
 333
 334 base::DictionaryValue* SyncedNotificationToValue(
 335     const sync_pb::SyncedNotification& proto) {
 336   base::DictionaryValue* value = new base::DictionaryValue();
 337   SET_STR(type);
 338   SET_STR(external_id);
 339   // TODO(petewil) Add SyncedNotificationCreator here if we ever need it.
 340   return value;
 341 }
 342
 343 base::DictionaryValue* RenderInfoToValue(
 344     const sync_pb::SyncedNotificationRenderInfo& proto) {
 345   base::DictionaryValue* value = new base::DictionaryValue();
 346   // TODO(petewil): Add the expanded info values once we start using them.
 347   SET(collapsed_info, CollapsedInfoToValue);
 348   return value;
 349 }
 350
 351 base::DictionaryValue* CoalescedNotificationToValue(
 352     const sync_pb::CoalescedSyncedNotification& proto) {
 353   base::DictionaryValue* value = new base::DictionaryValue();
 354   SET_STR(key);
 355   SET_STR(app_id);
 356   SET_REP(notification, SyncedNotificationToValue);
 357   SET(render_info, RenderInfoToValue);
 358   SET_INT32(read_state);
 359   SET_INT64(creation_time_msec);
 360   SET_INT32(priority);
 361   return value;
 362 }
 363
 364 base::DictionaryValue* AppListSpecificsToValue(
 365     const sync_pb::AppListSpecifics& proto) {
 366   base::DictionaryValue* value = new base::DictionaryValue();
 367   SET_STR(item_id);
 368   SET_ENUM(item_type, GetAppListItemTypeString);
 369   SET_STR(item_name);
 370   SET_STR(parent_id);
 371   SET_STR(page_ordinal);
 372   SET_STR(item_ordinal);
 373
 374   return value;
 375 }
 376
 377 base::DictionaryValue* AppNotificationToValue(
 378     const sync_pb::AppNotification& proto) {
 379   base::DictionaryValue* value = new base::DictionaryValue();
 380   SET_STR(guid);
 381   SET_STR(app_id);
 382   SET_INT64(creation_timestamp_ms);
 383   SET_STR(title);
 384   SET_STR(body_text);
 385   SET_STR(link_url);
 386   SET_STR(link_text);
 387   return value;
 388 }
 389
 390 base::DictionaryValue* AppSettingSpecificsToValue(
 391     const sync_pb::AppSettingSpecifics& proto) {
 392   base::DictionaryValue* value = new base::DictionaryValue();
 393   SET(extension_setting, ExtensionSettingSpecificsToValue);
 394   return value;
 395 }
 396
 397 base::DictionaryValue* AppSpecificsToValue(
 398     const sync_pb::AppSpecifics& proto) {
 399   base::DictionaryValue* value = new base::DictionaryValue();
 400   SET(extension, ExtensionSpecificsToValue);
 401   SET(notification_settings, AppSettingsToValue);
 402   SET_STR(app_launch_ordinal);
 403   SET_STR(page_ordinal);
 404   SET_ENUM(launch_type, GetLaunchTypeString);
 405
 406   return value;
 407 }
 408
 409 base::DictionaryValue* AutofillSpecificsToValue(
 410     const sync_pb::AutofillSpecifics& proto) {
 411   base::DictionaryValue* value = new base::DictionaryValue();
 412   SET_STR(name);
 413   SET_STR(value);
 414   SET_INT64_REP(usage_timestamp);
 415   SET(profile, AutofillProfileSpecificsToValue);
 416   return value;
 417 }
 418
 419 base::DictionaryValue* AutofillProfileSpecificsToValue(
 420     const sync_pb::AutofillProfileSpecifics& proto) {
 421   base::DictionaryValue* value = new base::DictionaryValue();
 422   SET_STR(guid);
 423   SET_STR(origin);
 424
 425   SET_STR_REP(name_first);
 426   SET_STR_REP(name_middle);
 427   SET_STR_REP(name_last);
 428   SET_STR_REP(email_address);
 429   SET_STR(company_name);
 430
 431   SET_STR(address_home_line1);
 432   SET_STR(address_home_line2);
 433   SET_STR(address_home_city);
 434   SET_STR(address_home_state);
 435   SET_STR(address_home_zip);
 436   SET_STR(address_home_country);
 437
 438   SET_STR(address_home_street_address);
 439   SET_STR(address_home_sorting_code);
 440   SET_STR(address_home_dependent_locality);
 441
 442   SET_STR_REP(phone_home_whole_number);
 443   return value;
 444 }
 445
 446 base::DictionaryValue* MetaInfoToValue(
 447     const sync_pb::MetaInfo& proto) {
 448   base::DictionaryValue* value = new base::DictionaryValue();
 449   SET_STR(key);
 450   SET_STR(value);
 451   return value;
 452 }
 453
 454 base::DictionaryValue* BookmarkSpecificsToValue(
 455     const sync_pb::BookmarkSpecifics& proto) {
 456   base::DictionaryValue* value = new base::DictionaryValue();
 457   SET_STR(url);
 458   SET_BYTES(favicon);
 459   SET_STR(title);
 460   SET_INT64(creation_time_us);
 461   SET_STR(icon_url);
 462   SET_REP(meta_info, &MetaInfoToValue);
 463   return value;
 464 }
 465
 466 base::DictionaryValue* DeviceInfoSpecificsToValue(
 467     const sync_pb::DeviceInfoSpecifics& proto) {
 468   base::DictionaryValue* value = new base::DictionaryValue();
 469   SET_STR(cache_guid);
 470   SET_STR(client_name);
 471   SET_ENUM(device_type, GetDeviceTypeString);
 472   SET_STR(sync_user_agent);
 473   SET_STR(chrome_version);
 474   return value;
 475 }
 476
 477 base::DictionaryValue* DictionarySpecificsToValue(
 478     const sync_pb::DictionarySpecifics& proto) {
 479   base::DictionaryValue* value = new base::DictionaryValue();
 480   SET_STR(word);
 481   return value;
 482 }
 483
 484 namespace {
 485
 486 base::DictionaryValue* FaviconSyncFlagsToValue(
 487     const sync_pb::FaviconSyncFlags& proto) {
 488   base::DictionaryValue* value = new base::DictionaryValue();
 489   SET_BOOL(enabled);
 490   SET_INT32(favicon_sync_limit);
 491   return value;
 492 }
 493
 494 }  // namespace
 495
 496 base::DictionaryValue* ExperimentsSpecificsToValue(
 497     const sync_pb::ExperimentsSpecifics& proto) {
 498   base::DictionaryValue* value = new base::DictionaryValue();
 499   SET_EXPERIMENT_ENABLED_FIELD(keystore_encryption);
 500   SET_EXPERIMENT_ENABLED_FIELD(history_delete_directives);
 501   SET_EXPERIMENT_ENABLED_FIELD(autofill_culling);
 502   SET_EXPERIMENT_ENABLED_FIELD(pre_commit_update_avoidance);
 503   SET(favicon_sync, FaviconSyncFlagsToValue);
 504   SET_EXPERIMENT_ENABLED_FIELD(gcm_channel);
 505   SET_EXPERIMENT_ENABLED_FIELD(enhanced_bookmarks);
 506   return value;
 507 }
 508
 509 base::DictionaryValue* ExtensionSettingSpecificsToValue(
 510     const sync_pb::ExtensionSettingSpecifics& proto) {
 511   base::DictionaryValue* value = new base::DictionaryValue();
 512   SET_STR(extension_id);
 513   SET_STR(key);
 514   SET_STR(value);
 515   return value;
 516 }
 517
 518 base::DictionaryValue* ExtensionSpecificsToValue(
 519     const sync_pb::ExtensionSpecifics& proto) {
 520   base::DictionaryValue* value = new base::DictionaryValue();
 521   SET_STR(id);
 522   SET_STR(version);
 523   SET_STR(update_url);
 524   SET_BOOL(enabled);
 525   SET_BOOL(incognito_enabled);
 526   SET_STR(name);
 527   return value;
 528 }
 529
 530 namespace {
 531 base::DictionaryValue* FaviconDataToValue(
 532     const sync_pb::FaviconData& proto) {
 533   base::DictionaryValue* value = new base::DictionaryValue();
 534   SET_BYTES(favicon);
 535   SET_INT32(width);
 536   SET_INT32(height);
 537   return value;
 538 }
 539 }  // namespace
 540
 541 base::DictionaryValue* FaviconImageSpecificsToValue(
 542     const sync_pb::FaviconImageSpecifics& proto) {
 543   base::DictionaryValue* value = new base::DictionaryValue();
 544   SET_STR(favicon_url);
 545   SET(favicon_web, FaviconDataToValue);
 546   SET(favicon_web_32, FaviconDataToValue);
 547   SET(favicon_touch_64, FaviconDataToValue);
 548   SET(favicon_touch_precomposed_64, FaviconDataToValue);
 549   return value;
 550 }
 551
 552 base::DictionaryValue* FaviconTrackingSpecificsToValue(
 553     const sync_pb::FaviconTrackingSpecifics& proto) {
 554   base::DictionaryValue* value = new base::DictionaryValue();
 555   SET_STR(favicon_url);
 556   SET_INT64(last_visit_time_ms)
 557   SET_BOOL(is_bookmarked);
 558   return value;
 559 }
 560
 561 base::DictionaryValue* HistoryDeleteDirectiveSpecificsToValue(
 562     const sync_pb::HistoryDeleteDirectiveSpecifics& proto) {
 563   base::DictionaryValue* value = new base::DictionaryValue();
 564   SET(global_id_directive, GlobalIdDirectiveToValue);
 565   SET(time_range_directive, TimeRangeDirectiveToValue);
 566   return value;
 567 }
 568
 569 base::DictionaryValue* ManagedUserSettingSpecificsToValue(
 570     const sync_pb::ManagedUserSettingSpecifics& proto) {
 571   base::DictionaryValue* value = new base::DictionaryValue();
 572   SET_STR(name);
 573   SET_STR(value);
 574   return value;
 575 }
 576
 577 base::DictionaryValue* ManagedUserSpecificsToValue(
 578     const sync_pb::ManagedUserSpecifics& proto) {
 579   base::DictionaryValue* value = new base::DictionaryValue();
 580   SET_STR(id);
 581   SET_STR(name);
 582   SET_BOOL(acknowledged);
 583   SET_STR(master_key);
 584   SET_STR(chrome_avatar);
 585   SET_STR(chromeos_avatar);
 586   return value;
 587 }
 588
 589 base::DictionaryValue* ManagedUserSharedSettingSpecificsToValue(
 590     const sync_pb::ManagedUserSharedSettingSpecifics& proto) {
 591   base::DictionaryValue* value = new base::DictionaryValue();
 592   SET_STR(mu_id);
 593   SET_STR(key);
 594   SET_STR(value);
 595   SET_BOOL(acknowledged);
 596   return value;
 597 }
 598
 599 base::DictionaryValue* NigoriSpecificsToValue(
 600     const sync_pb::NigoriSpecifics& proto) {
 601   base::DictionaryValue* value = new base::DictionaryValue();
 602   SET(encryption_keybag, EncryptedDataToValue);
 603   SET_BOOL(keybag_is_frozen);
 604   SET_BOOL(encrypt_bookmarks);
 605   SET_BOOL(encrypt_preferences);
 606   SET_BOOL(encrypt_autofill_profile);
 607   SET_BOOL(encrypt_autofill);
 608   SET_BOOL(encrypt_themes);
 609   SET_BOOL(encrypt_typed_urls);
 610   SET_BOOL(encrypt_extension_settings);
 611   SET_BOOL(encrypt_extensions);
 612   SET_BOOL(encrypt_sessions);
 613   SET_BOOL(encrypt_app_settings);
 614   SET_BOOL(encrypt_apps);
 615   SET_BOOL(encrypt_search_engines);
 616   SET_BOOL(encrypt_dictionary);
 617   SET_BOOL(encrypt_articles);
 618   SET_BOOL(encrypt_app_list);
 619   SET_BOOL(encrypt_everything);
 620   SET_BOOL(sync_tab_favicons);
 621   SET_ENUM(passphrase_type, PassphraseTypeString);
 622   SET(keystore_decryptor_token, EncryptedDataToValue);
 623   SET_INT64(keystore_migration_time);
 624   SET_INT64(custom_passphrase_time);
 625   return value;
 626 }
 627
 628 base::DictionaryValue* ArticlePageToValue(
 629     const sync_pb::ArticlePage& proto) {
 630   base::DictionaryValue* value = new base::DictionaryValue();
 631   SET_STR(url);
 632   return value;
 633 }
 634
 635 base::DictionaryValue* ArticleSpecificsToValue(
 636     const sync_pb::ArticleSpecifics& proto) {
 637   base::DictionaryValue* value = new base::DictionaryValue();
 638   SET_STR(entry_id);
 639   SET_STR(title);
 640   SET_REP(pages, ArticlePageToValue);
 641   return value;
 642 }
 643
 644 base::DictionaryValue* PasswordSpecificsToValue(
 645     const sync_pb::PasswordSpecifics& proto) {
 646   base::DictionaryValue* value = new base::DictionaryValue();
 647   SET(encrypted, EncryptedDataToValue);
 648   return value;
 649 }
 650
 651 base::DictionaryValue* PreferenceSpecificsToValue(
 652     const sync_pb::PreferenceSpecifics& proto) {
 653   base::DictionaryValue* value = new base::DictionaryValue();
 654   SET_STR(name);
 655   SET_STR(value);
 656   return value;
 657 }
 658
 659 base::DictionaryValue* PriorityPreferenceSpecificsToValue(
 660     const sync_pb::PriorityPreferenceSpecifics& specifics) {
 661   base::DictionaryValue* value = new base::DictionaryValue();
 662   SET_FIELD(preference, PreferenceSpecificsToValue);
 663   return value;
 664 }
 665
 666 base::DictionaryValue* SyncedNotificationAppInfoSpecificsToValue(
 667     const sync_pb::SyncedNotificationAppInfoSpecifics& proto) {
 668   base::DictionaryValue* value = new base::DictionaryValue();
 669   SET_REP(synced_notification_app_info, SyncedNotificationAppInfoToValue);
 670   return value;
 671 }
 672
 673 base::DictionaryValue* SyncedNotificationSpecificsToValue(
 674     const sync_pb::SyncedNotificationSpecifics& proto) {
 675   // There is a lot of data, for now just use heading, description, key, and
 676   // the read state.
 677   // TODO(petewil): Eventually add more data here.
 678   base::DictionaryValue* value = new base::DictionaryValue();
 679   SET(coalesced_notification, CoalescedNotificationToValue);
 680   return value;
 681 }
 682
 683 base::DictionaryValue* SearchEngineSpecificsToValue(
 684     const sync_pb::SearchEngineSpecifics& proto) {
 685   base::DictionaryValue* value = new base::DictionaryValue();
 686   SET_STR(short_name);
 687   SET_STR(keyword);
 688   SET_STR(favicon_url);
 689   SET_STR(url);
 690   SET_BOOL(safe_for_autoreplace);
 691   SET_STR(originating_url);
 692   SET_INT64(date_created);
 693   SET_STR(input_encodings);
 694   SET_BOOL(show_in_default_list);
 695   SET_STR(suggestions_url);
 696   SET_INT32(prepopulate_id);
 697   SET_BOOL(autogenerate_keyword);
 698   SET_STR(instant_url);
 699   SET_INT64(last_modified);
 700   SET_STR(sync_guid);
 701   SET_STR_REP(alternate_urls);
 702   SET_STR(search_terms_replacement_key);
 703   SET_STR(image_url);
 704   SET_STR(search_url_post_params);
 705   SET_STR(suggestions_url_post_params);
 706   SET_STR(instant_url_post_params);
 707   SET_STR(image_url_post_params);
 708   SET_STR(new_tab_url);
 709   return value;
 710 }
 711
 712 base::DictionaryValue* SessionSpecificsToValue(
 713     const sync_pb::SessionSpecifics& proto) {
 714   base::DictionaryValue* value = new base::DictionaryValue();
 715   SET_STR(session_tag);
 716   SET(header, SessionHeaderToValue);
 717   SET(tab, SessionTabToValue);
 718   SET_INT32(tab_node_id);
 719   return value;
 720 }
 721
 722 base::DictionaryValue* ThemeSpecificsToValue(
 723     const sync_pb::ThemeSpecifics& proto) {
 724   base::DictionaryValue* value = new base::DictionaryValue();
 725   SET_BOOL(use_custom_theme);
 726   SET_BOOL(use_system_theme_by_default);
 727   SET_STR(custom_theme_name);
 728   SET_STR(custom_theme_id);
 729   SET_STR(custom_theme_update_url);
 730   return value;
 731 }
 732
 733 base::DictionaryValue* TypedUrlSpecificsToValue(
 734     const sync_pb::TypedUrlSpecifics& proto) {
 735   base::DictionaryValue* value = new base::DictionaryValue();
 736   SET_STR(url);
 737   SET_STR(title);
 738   SET_BOOL(hidden);
 739   SET_INT64_REP(visits);
 740   SET_INT32_REP(visit_transitions);
 741   return value;
 742 }
 743
 744 base::DictionaryValue* EntitySpecificsToValue(
 745     const sync_pb::EntitySpecifics& specifics) {
 746   base::DictionaryValue* value = new base::DictionaryValue();
 747   SET_FIELD(app, AppSpecificsToValue);
 748   SET_FIELD(app_list, AppListSpecificsToValue);
 749   SET_FIELD(app_notification, AppNotificationToValue);
 750   SET_FIELD(app_setting, AppSettingSpecificsToValue);
 751   SET_FIELD(article, ArticleSpecificsToValue);
 752   SET_FIELD(autofill, AutofillSpecificsToValue);
 753   SET_FIELD(autofill_profile, AutofillProfileSpecificsToValue);
 754   SET_FIELD(bookmark, BookmarkSpecificsToValue);
 755   SET_FIELD(device_info, DeviceInfoSpecificsToValue);
 756   SET_FIELD(dictionary, DictionarySpecificsToValue);
 757   SET_FIELD(experiments, ExperimentsSpecificsToValue);
 758   SET_FIELD(extension, ExtensionSpecificsToValue);
 759   SET_FIELD(extension_setting, ExtensionSettingSpecificsToValue);
 760   SET_FIELD(favicon_image, FaviconImageSpecificsToValue);
 761   SET_FIELD(favicon_tracking, FaviconTrackingSpecificsToValue);
 762   SET_FIELD(history_delete_directive, HistoryDeleteDirectiveSpecificsToValue);
 763   SET_FIELD(managed_user_setting, ManagedUserSettingSpecificsToValue);
 764   SET_FIELD(managed_user_shared_setting,
 765             ManagedUserSharedSettingSpecificsToValue);
 766   SET_FIELD(managed_user, ManagedUserSpecificsToValue);
 767   SET_FIELD(nigori, NigoriSpecificsToValue);
 768   SET_FIELD(password, PasswordSpecificsToValue);
 769   SET_FIELD(preference, PreferenceSpecificsToValue);
 770   SET_FIELD(priority_preference, PriorityPreferenceSpecificsToValue);
 771   SET_FIELD(search_engine, SearchEngineSpecificsToValue);
 772   SET_FIELD(session, SessionSpecificsToValue);
 773   SET_FIELD(synced_notification, SyncedNotificationSpecificsToValue);
 774   SET_FIELD(synced_notification_app_info,
 775             SyncedNotificationAppInfoSpecificsToValue);
 776   SET_FIELD(theme, ThemeSpecificsToValue);
 777   SET_FIELD(typed_url, TypedUrlSpecificsToValue);
 778   return value;
 779 }
 780
 781 namespace {
 782
 783 base::StringValue* UniquePositionToStringValue(
 784     const sync_pb::UniquePosition& proto) {
 785   UniquePosition pos = UniquePosition::FromProto(proto);
 786   return new base::StringValue(pos.ToDebugString());
 787 }
 788
 789 base::DictionaryValue* SyncEntityToValue(const sync_pb::SyncEntity& proto,
 790                                          bool include_specifics) {
 791   base::DictionaryValue* value = new base::DictionaryValue();
 792   SET_STR(id_string);
 793   SET_STR(parent_id_string);
 794   SET_STR(old_parent_id);
 795   SET_INT64(version);
 796   SET_INT64(mtime);
 797   SET_INT64(ctime);
 798   SET_STR(name);
 799   SET_STR(non_unique_name);
 800   SET_INT64(sync_timestamp);
 801   SET_STR(server_defined_unique_tag);
 802   SET_INT64(position_in_parent);
 803   SET(unique_position, UniquePositionToStringValue);
 804   SET_STR(insert_after_item_id);
 805   SET_BOOL(deleted);
 806   SET_STR(originator_cache_guid);
 807   SET_STR(originator_client_item_id);
 808   if (include_specifics)
 809     SET(specifics, EntitySpecificsToValue);
 810   SET_BOOL(folder);
 811   SET_STR(client_defined_unique_tag);
 812   return value;
 813 }
 814
 815 base::ListValue* SyncEntitiesToValue(
 816     const ::google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>& entities,
 817     bool include_specifics) {
 818   base::ListValue* list = new base::ListValue();
 819   ::google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>::const_iterator it;
 820   for (it = entities.begin(); it != entities.end(); ++it) {
 821     list->Append(SyncEntityToValue(*it, include_specifics));
 822   }
 823
 824   return list;
 825 }
 826
 827 base::DictionaryValue* ChromiumExtensionActivityToValue(
 828     const sync_pb::ChromiumExtensionsActivity& proto) {
 829   base::DictionaryValue* value = new base::DictionaryValue();
 830   SET_STR(extension_id);
 831   SET_INT32(bookmark_writes_since_last_commit);
 832   return value;
 833 }
 834
 835 base::DictionaryValue* CommitMessageToValue(
 836     const sync_pb::CommitMessage& proto,
 837     bool include_specifics) {
 838   base::DictionaryValue* value = new base::DictionaryValue();
 839   value->Set("entries",
 840              SyncEntitiesToValue(proto.entries(), include_specifics));
 841   SET_STR(cache_guid);
 842   SET_REP(extensions_activity, ChromiumExtensionActivityToValue);
 843   SET(config_params, ClientConfigParamsToValue);
 844   return value;
 845 }
 846
 847 base::DictionaryValue* GetUpdateTriggersToValue(
 848     const sync_pb::GetUpdateTriggers& proto) {
 849   base::DictionaryValue* value = new base::DictionaryValue();
 850   SET_STR_REP(notification_hint);
 851   SET_BOOL(client_dropped_hints);
 852   SET_BOOL(invalidations_out_of_sync);
 853   SET_INT64(local_modification_nudges);
 854   SET_INT64(datatype_refresh_nudges);
 855   return value;
 856 }
 857
 858 base::DictionaryValue* DataTypeProgressMarkerToValue(
 859     const sync_pb::DataTypeProgressMarker& proto) {
 860   base::DictionaryValue* value = new base::DictionaryValue();
 861   SET_INT32(data_type_id);
 862   SET_BYTES(token);
 863   SET_INT64(timestamp_token_for_migration);
 864   SET_STR(notification_hint);
 865   SET(get_update_triggers, GetUpdateTriggersToValue);
 866   return value;
 867 }
 868
 869 base::DictionaryValue* GetUpdatesCallerInfoToValue(
 870     const sync_pb::GetUpdatesCallerInfo& proto) {
 871   base::DictionaryValue* value = new base::DictionaryValue();
 872   SET_ENUM(source, GetUpdatesSourceString);
 873   SET_BOOL(notifications_enabled);
 874   return value;
 875 }
 876
 877 base::DictionaryValue* GetUpdatesMessageToValue(
 878     const sync_pb::GetUpdatesMessage& proto) {
 879   base::DictionaryValue* value = new base::DictionaryValue();
 880   SET(caller_info, GetUpdatesCallerInfoToValue);
 881   SET_BOOL(fetch_folders);
 882   SET_INT32(batch_size);
 883   SET_REP(from_progress_marker, DataTypeProgressMarkerToValue);
 884   SET_BOOL(streaming);
 885   SET_BOOL(need_encryption_key);
 886   SET_BOOL(create_mobile_bookmarks_folder);
 887   SET_ENUM(get_updates_origin, GetUpdatesOriginString);
 888   return value;
 889 }
 890
 891 base::DictionaryValue* ClientStatusToValue(const sync_pb::ClientStatus& proto) {
 892   base::DictionaryValue* value = new base::DictionaryValue();
 893   SET_BOOL(hierarchy_conflict_detected);
 894   return value;
 895 }
 896
 897 base::DictionaryValue* EntryResponseToValue(
 898     const sync_pb::CommitResponse::EntryResponse& proto) {
 899   base::DictionaryValue* value = new base::DictionaryValue();
 900   SET_ENUM(response_type, GetResponseTypeString);
 901   SET_STR(id_string);
 902   SET_STR(parent_id_string);
 903   SET_INT64(position_in_parent);
 904   SET_INT64(version);
 905   SET_STR(name);
 906   SET_STR(error_message);
 907   SET_INT64(mtime);
 908   return value;
 909 }
 910
 911 base::DictionaryValue* CommitResponseToValue(
 912     const sync_pb::CommitResponse& proto) {
 913   base::DictionaryValue* value = new base::DictionaryValue();
 914   SET_REP(entryresponse, EntryResponseToValue);
 915   return value;
 916 }
 917
 918 base::DictionaryValue* GetUpdatesResponseToValue(
 919     const sync_pb::GetUpdatesResponse& proto,
 920     bool include_specifics) {
 921   base::DictionaryValue* value = new base::DictionaryValue();
 922   value->Set("entries",
 923              SyncEntitiesToValue(proto.entries(), include_specifics));
 924   SET_INT64(changes_remaining);
 925   SET_REP(new_progress_marker, DataTypeProgressMarkerToValue);
 926   return value;
 927 }
 928
 929 base::DictionaryValue* ClientCommandToValue(
 930     const sync_pb::ClientCommand& proto) {
 931   base::DictionaryValue* value = new base::DictionaryValue();
 932   SET_INT32(set_sync_poll_interval);
 933   SET_INT32(set_sync_long_poll_interval);
 934   SET_INT32(max_commit_batch_size);
 935   SET_INT32(sessions_commit_delay_seconds);
 936   SET_INT32(throttle_delay_seconds);
 937   SET_INT32(client_invalidation_hint_buffer_size);
 938   return value;
 939 }
 940
 941 base::DictionaryValue* ErrorToValue(
 942     const sync_pb::ClientToServerResponse::Error& proto) {
 943   base::DictionaryValue* value = new base::DictionaryValue();
 944   SET_ENUM(error_type, GetErrorTypeString);
 945   SET_STR(error_description);
 946   SET_STR(url);
 947   SET_ENUM(action, GetActionString);
 948   return value;
 949 }
 950
 951 }  // namespace
 952
 953 base::DictionaryValue* ClientToServerResponseToValue(
 954     const sync_pb::ClientToServerResponse& proto,
 955     bool include_specifics) {
 956   base::DictionaryValue* value = new base::DictionaryValue();
 957   SET(commit, CommitResponseToValue);
 958   if (proto.has_get_updates()) {
 959     value->Set("get_updates", GetUpdatesResponseToValue(proto.get_updates(),
 960                                                         include_specifics));
 961   }
 962
 963   SET(error, ErrorToValue);
 964   SET_ENUM(error_code, GetErrorTypeString);
 965   SET_STR(error_message);
 966   SET_STR(store_birthday);
 967   SET(client_command, ClientCommandToValue);
 968   SET_INT32_REP(migrated_data_type_id);
 969   return value;
 970 }
 971
 972 base::DictionaryValue* ClientToServerMessageToValue(
 973     const sync_pb::ClientToServerMessage& proto,
 974     bool include_specifics) {
 975   base::DictionaryValue* value = new base::DictionaryValue();
 976   SET_STR(share);
 977   SET_INT32(protocol_version);
 978   if (proto.has_commit()) {
 979     value->Set("commit",
 980                CommitMessageToValue(proto.commit(), include_specifics));
 981   }
 982
 983   SET(get_updates, GetUpdatesMessageToValue);
 984   SET_STR(store_birthday);
 985   SET_BOOL(sync_problem_detected);
 986   SET(debug_info, DebugInfoToValue);
 987   SET(client_status, ClientStatusToValue);
 988   return value;
 989 }
 990
 991 base::DictionaryValue* DatatypeAssociationStatsToValue(
 992     const sync_pb::DatatypeAssociationStats& proto) {
 993   base::DictionaryValue* value = new base::DictionaryValue();
 994   SET_INT32(data_type_id);
 995   SET_INT32(num_local_items_before_association);
 996   SET_INT32(num_sync_items_before_association);
 997   SET_INT32(num_local_items_after_association);
 998   SET_INT32(num_sync_items_after_association);
 999   SET_INT32(num_local_items_added);
1000   SET_INT32(num_local_items_deleted);
1001   SET_INT32(num_local_items_modified);
1002   SET_INT32(num_sync_items_added);
1003   SET_INT32(num_sync_items_deleted);
1004   SET_INT32(num_sync_items_modified);
1005   SET_INT64(local_version_pre_association);
1006   SET_INT64(sync_version_pre_association)
1007   SET_BOOL(had_error);
1008   SET_INT64(download_wait_time_us);
1009   SET_INT64(download_time_us);
1010   SET_INT64(association_wait_time_for_high_priority_us);
1011   SET_INT64(association_wait_time_for_same_priority_us);
1012   return value;
1013 }
1014
1015 base::DictionaryValue* DebugEventInfoToValue(
1016     const sync_pb::DebugEventInfo& proto) {
1017   base::DictionaryValue* value = new base::DictionaryValue();
1018   SET_ENUM(singleton_event, SingletonDebugEventTypeString);
1019   SET(sync_cycle_completed_event_info, SyncCycleCompletedEventInfoToValue);
1020   SET_INT32(nudging_datatype);
1021   SET_INT32_REP(datatypes_notified_from_server);
1022   SET(datatype_association_stats, DatatypeAssociationStatsToValue);
1023   return value;
1024 }
1025
1026 base::DictionaryValue* DebugInfoToValue(const sync_pb::DebugInfo& proto) {
1027   base::DictionaryValue* value = new base::DictionaryValue();
1028   SET_REP(events, DebugEventInfoToValue);
1029   SET_BOOL(cryptographer_ready);
1030   SET_BOOL(cryptographer_has_pending_keys);
1031   SET_BOOL(events_dropped);
1032   return value;
1033 }
1034
1035 base::DictionaryValue* SyncCycleCompletedEventInfoToValue(
1036     const sync_pb::SyncCycleCompletedEventInfo& proto) {
1037   base::DictionaryValue* value = new base::DictionaryValue();
1038   SET_INT32(num_encryption_conflicts);
1039   SET_INT32(num_hierarchy_conflicts);
1040   SET_INT32(num_server_conflicts);
1041   SET_INT32(num_updates_downloaded);
1042   SET_INT32(num_reflected_updates_downloaded);
1043   SET(caller_info, GetUpdatesCallerInfoToValue);
1044   return value;
1045 }
1046
1047 base::DictionaryValue* ClientConfigParamsToValue(
1048     const sync_pb::ClientConfigParams& proto) {
1049   base::DictionaryValue* value = new base::DictionaryValue();
1050   SET_INT32_REP(enabled_type_ids);
1051   SET_BOOL(tabs_datatype_enabled);
1052   return value;
1053 }
1054
1055 base::DictionaryValue* AttachmentIdToValue(const sync_pb::AttachmentId& proto) {
1056   base::DictionaryValue* value = new base::DictionaryValue();
1057   SET_STR(unique_id);
1058   return value;
1059 }
1060
1061 #undef SET
1062 #undef SET_REP
1063
1064 #undef SET_BOOL
1065 #undef SET_BYTES
1066 #undef SET_INT32
1067 #undef SET_INT64
1068 #undef SET_INT64_REP
1069 #undef SET_STR
1070 #undef SET_STR_REP
1071
1072 #undef SET_FIELD
1073
1074 }  // namespace syncer