Added Instant preference syncing and tests.

chrome/browser/extensions/extension_sync_data.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/extension_sync_data.h"
 
 #include "base/logging.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/sync/protocol/app_specifics.pb.h"
 #include "chrome/browser/sync/protocol/extension_specifics.pb.h"
 
 ExtensionSyncData::ExtensionSyncData()
     : uninstalled_(false),
       enabled_(false),
       incognito_enabled_(false),
-      type_(Extension::SYNC_TYPE_NONE) {
+      type_(Extension::SYNC_TYPE_NONE),
+      app_launch_index_(0),
+      page_index_(0) {
 }
 
 ExtensionSyncData::ExtensionSyncData(const SyncData& sync_data)
     : uninstalled_(false),
       enabled_(false),
       incognito_enabled_(false),
-      type_(Extension::SYNC_TYPE_NONE) {
+      type_(Extension::SYNC_TYPE_NONE),
+      app_launch_index_(0),
+      page_index_(0) {
   PopulateFromSyncData(sync_data);
 }
 
 ExtensionSyncData::ExtensionSyncData(const SyncChange& sync_change)
     : uninstalled_(sync_change.change_type() == SyncChange::ACTION_DELETE) {
   PopulateFromSyncData(sync_change.sync_data());
 }
 
 ExtensionSyncData::ExtensionSyncData(const Extension& extension,
                                      bool enabled,
-                                     bool incognito_enabled)
+                                     bool incognito_enabled,
+                                     int32 app_launch_index,
+                                     int32 page_index)
   : id_(extension.id()),
     uninstalled_(false),
     enabled_(enabled),
     incognito_enabled_(incognito_enabled),
     type_(extension.GetSyncType()),
     version_(*extension.version()),
     update_url_(extension.update_url()),
-    name_(extension.name()) {
+    name_(extension.name()),
+    app_launch_index_(app_launch_index),
+    page_index_(page_index) {
 }
 
 ExtensionSyncData::~ExtensionSyncData() {}
 
-void ExtensionSyncData::PopulateSyncSpecifics(
+void ExtensionSyncData::PopulateExtensionSyncSpecifics(
     sync_pb::ExtensionSpecifics* specifics) const {
   DCHECK(Extension::IdIsValid(id_));
   specifics->set_id(id_);
   specifics->set_update_url(update_url_.spec());
   specifics->set_version(version_.GetString());
   specifics->set_enabled(enabled_);
   specifics->set_incognito_enabled(incognito_enabled_);
   specifics->set_name(name_);
 }
 
+void ExtensionSyncData::PopulateAppSyncSpecifics(
+    sync_pb::AppSpecifics* specifics) const {
+  PopulateExtensionSyncSpecifics(specifics->mutable_extension());
+
+  specifics->set_app_launch_index(app_launch_index_);
+  specifics->set_page_index(page_index_);
+}
+
 SyncData ExtensionSyncData::GetSyncData() const {
   sync_pb::EntitySpecifics specifics;
-  sync_pb::ExtensionSpecifics* extension_specifics = NULL;
 
   switch (type_) {
     case Extension::SYNC_TYPE_EXTENSION:
-      extension_specifics = specifics.MutableExtension(sync_pb::extension);
+      PopulateExtensionSyncSpecifics(specifics.MutableExtension(
+          sync_pb::extension));
       break;
     case Extension::SYNC_TYPE_APP:
-      extension_specifics =
-          specifics.MutableExtension(sync_pb::app)->mutable_extension();
+      PopulateAppSyncSpecifics(specifics.MutableExtension(sync_pb::app));
       break;
     default:
       LOG(FATAL) << "Attempt to get non-syncable data.";
   }
 
-  PopulateSyncSpecifics(extension_specifics);
-
   return SyncData::CreateLocalData(id_, name_, specifics);
 }
 
 SyncChange ExtensionSyncData::GetSyncChange(
     SyncChange::SyncChangeType change_type) const {
   return SyncChange(change_type, GetSyncData());
 }
 
 void ExtensionSyncData::PopulateFromExtensionSpecifics(
     const sync_pb::ExtensionSpecifics& specifics) {
@@ skipping 12 matching lines @@
   }
 
   id_ = specifics.id();
   update_url_ = specifics_update_url;
   version_ = specifics_version;
   enabled_ = specifics.enabled();
   incognito_enabled_ = specifics.incognito_enabled();
   name_ = specifics.name();
 }
 
+void ExtensionSyncData::PopulateFromAppSpecifics(
+    const sync_pb::AppSpecifics& specifics) {
+  PopulateFromExtensionSpecifics(specifics.extension());
+
+  app_launch_index_ = specifics.app_launch_index();
+  page_index_ = specifics.page_index();
+}
+
 void ExtensionSyncData::PopulateFromSyncData(const SyncData& sync_data) {
   const sync_pb::EntitySpecifics& entity_specifics = sync_data.GetSpecifics();
   sync_pb::ExtensionSpecifics extension_expecifics;
   if (entity_specifics.HasExtension(sync_pb::extension)) {
-    extension_expecifics = entity_specifics.GetExtension(sync_pb::extension);
+    PopulateFromExtensionSpecifics(
+        entity_specifics.GetExtension(sync_pb::extension));
     type_ = Extension::SYNC_TYPE_EXTENSION;
   } else if (entity_specifics.HasExtension(sync_pb::app)) {
-    extension_expecifics =
-        entity_specifics.GetExtension(sync_pb::app).extension();
+    PopulateFromAppSpecifics(
+        entity_specifics.GetExtension(sync_pb::app));
     type_ = Extension::SYNC_TYPE_APP;
   } else {
-    LOG(FATAL) << "Attempt to sync bad EntitySpecifics.";
+    ;    LOG(FATAL) << "Attempt to sync bad EntitySpecifics.";
   }
-  PopulateFromExtensionSpecifics(extension_expecifics);
 }
-