FYI: Control Data + Per-Device Metadata

sync/internal_api/sync_manager_impl_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 778 matching lines @@
   void TearDown() {
     sync_manager_.RemoveObserver(&observer_);
     // |sync_notifier_mock_| is strict, which ensures we don't do anything but
     // unregister |sync_manager_| as a handler on shutdown.
     sync_manager_.ShutdownOnSyncThread();
     sync_notifier_mock_ = NULL;
     PumpLoop();
   }
 
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
-    (*out)[NIGORI] = GROUP_PASSIVE;
+    (*out)[NIGORI] = GROUP_CONTROL;
+    (*out)[PER_DEVICE_METADATA] = GROUP_CONTROL;
+    (*out)[PER_USER_METADATA] = GROUP_CONTROL;
     (*out)[BOOKMARKS] = GROUP_PASSIVE;
     (*out)[THEMES] = GROUP_PASSIVE;
     (*out)[SESSIONS] = GROUP_PASSIVE;
     (*out)[PASSWORDS] = GROUP_PASSIVE;
     (*out)[PREFERENCES] = GROUP_PASSIVE;
   }
 
   virtual void OnChangesApplied(
       ModelType model_type,
       const BaseTransaction* trans,
@@ skipping 124 matching lines @@
     } else {
       sync_pb::DataTypeProgressMarker marker;
       sync_manager_.directory()->SetDownloadProgress(type, marker);
     }
   }
 
   void SetInitialSyncEndedForType(ModelType type, bool value) {
     sync_manager_.directory()->set_initial_sync_ended_for_type(type, value);
   }
 
+  void RefreshEncryption() {
+    sync_manager_.RefreshEncryption();
+  }
+
+  void UpdateDeviceInformation(std::string version, std::string session_name) {
+    sync_manager_.UpdateDeviceInformation(version, session_name);
+  }
+
  private:
   // Needed by |sync_manager_|.
   MessageLoop message_loop_;
   // Needed by |sync_manager_|.
   ScopedTempDir temp_dir_;
   // Sync Id's for the roots of the enabled datatypes.
   std::map<ModelType, int64> type_roots_;
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
 
  protected:
@@ skipping 224 matching lines @@
     ListValue args;
     args.Append(Value::CreateStringValue("1"));
     SendJsMessage("getChildNodeIds",
                   JsArgList(&args), reply_handler.AsWeakHandle());
   }
 
   EXPECT_EQ(1u, return_args.Get().GetSize());
   const ListValue* nodes = NULL;
   ASSERT_TRUE(return_args.Get().GetList(0, &nodes));
   ASSERT_TRUE(nodes);
-  EXPECT_EQ(6u, nodes->GetSize());
+  EXPECT_EQ(8u, nodes->GetSize());
 }
 
 TEST_F(SyncManagerTest, GetChildNodeIdsFailure) {
   StrictMock<MockJsReplyHandler> reply_handler;
 
   ListValue empty_list_args;
   empty_list_args.Append(new ListValue());
 
   EXPECT_CALL(reply_handler,
               HandleJsReply("getChildNodeIds",
@@ skipping 139 matching lines @@
   TriggerOnIncomingNotificationForTest(model_types);
   SetJsEventHandler(WeakHandle<JsEventHandler>());
 
   TriggerOnIncomingNotificationForTest(empty_model_types);
   TriggerOnIncomingNotificationForTest(model_types);
 
   // Should trigger the replies.
   PumpLoop();
 }
 
+TEST_F(SyncManagerTest, CreateNewDeviceInformation) {
+  const std::string version("v1");
+  const std::string session_name("session");
+  const std::string cache_guid =
+      sync_manager_.GetUserShare()->directory->cache_guid();
+
+  {
+    ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
+    ReadNode node(&trans);
+    ASSERT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD,
+              node.InitByClientTagLookup(PER_DEVICE_METADATA, cache_guid));
+  }
+
+  UpdateDeviceInformation("v1", "session");
+
+  {
+    ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
+    ReadNode node(&trans);
+    ASSERT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(PER_DEVICE_METADATA, cache_guid));
+    sync_pb::PerDeviceSpecifics specifics = node.GetPerDeviceSpecifics();
+    ASSERT_TRUE(specifics.has_device_information());
+    const sync_pb::DeviceInformation& device_info =
+        specifics.device_information();
+
+    EXPECT_EQ(version, device_info.chrome_version());
+    EXPECT_EQ(session_name, device_info.name());
+    EXPECT_EQ(cache_guid, device_info.cache_guid());
+  }
+}
+
+TEST_F(SyncManagerTest, DontModifyExistingDeviceInformation) {
+  const std::string version("v1");
+  const std::string session_name("session");
+  const std::string cache_guid =
+      sync_manager_.GetUserShare()->directory->cache_guid();
+  sync_pb::DeviceInformation old_device_info;
+  sync_pb::DeviceInformation new_device_info;
+
+  UpdateDeviceInformation(version, session_name);
+
+  {
+    ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
+    ReadNode node(&trans);
+    ASSERT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(PER_DEVICE_METADATA, cache_guid));
+    sync_pb::PerDeviceSpecifics old_specifics = node.GetPerDeviceSpecifics();
+  }
+
+  UpdateDeviceInformation(version, session_name);
+
+  {
+    ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
+    ReadNode node(&trans);
+    ASSERT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(PER_DEVICE_METADATA, cache_guid));
+    sync_pb::PerDeviceSpecifics new_specifics = node.GetPerDeviceSpecifics();
+  }
+
+  EXPECT_EQ(old_device_info.chrome_version(), new_device_info.chrome_version());
+  EXPECT_EQ(old_device_info.name(), new_device_info.name());
+  EXPECT_EQ(old_device_info.cache_guid(), new_device_info.cache_guid());
+}
+
+TEST_F(SyncManagerTest, UpdateExistingDeviceInformation) {
+  const std::string old_version("v1");
+  const std::string new_version("v2");
+  const std::string session_name("session");
+  const std::string cache_guid =
+      sync_manager_.GetUserShare()->directory->cache_guid();
+
+  UpdateDeviceInformation(old_version, session_name);
+  UpdateDeviceInformation(new_version, session_name);
+
+  {
+    WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
+    WriteNode node(&trans);
+    ASSERT_EQ(BaseNode::INIT_OK,
+              node.InitByClientTagLookup(PER_DEVICE_METADATA, cache_guid));
+    sync_pb::PerDeviceSpecifics specifics = node.GetPerDeviceSpecifics();
+    ASSERT_TRUE(specifics.has_device_information());
+    const sync_pb::DeviceInformation& device_info =
+        specifics.device_information();
+
+    EXPECT_EQ(new_version, device_info.chrome_version());
+  }
+}
+
 TEST_F(SyncManagerTest, RefreshEncryptionReady) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   EXPECT_CALL(observer_, OnEncryptionComplete());
 
-  sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
-  PumpLoop();
+  RefreshEncryption();
 
   const ModelTypeSet encrypted_types = GetEncryptedDataTypesForTest();
   EXPECT_TRUE(encrypted_types.Has(PASSWORDS));
   EXPECT_FALSE(EncryptEverythingEnabledForTest());
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByIdLookup(GetIdForDataType(NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encrypted());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encrypted()));
   }
 }
 
-// Attempt to refresh encryption when nigori not downloaded.
-TEST_F(SyncManagerTest, RefreshEncryptionNotReady) {
-  // Don't set up encryption (no nigori node created).
-
-  // Should fail.
-  sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
-  PumpLoop();
-
-  const ModelTypeSet encrypted_types = GetEncryptedDataTypesForTest();
-  EXPECT_TRUE(encrypted_types.Has(PASSWORDS));  // Hardcoded.
-  EXPECT_FALSE(EncryptEverythingEnabledForTest());
-}
-
 // Attempt to refresh encryption when nigori is empty.
 TEST_F(SyncManagerTest, RefreshEncryptionEmptyNigori) {
   EXPECT_TRUE(SetUpEncryption(DONT_WRITE_NIGORI, DEFAULT_ENCRYPTION));
   EXPECT_CALL(observer_, OnEncryptionComplete());
 
   // Should write to nigori.
-  sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
-  PumpLoop();
+  RefreshEncryption();
 
   const ModelTypeSet encrypted_types = GetEncryptedDataTypesForTest();
   EXPECT_TRUE(encrypted_types.Has(PASSWORDS));  // Hardcoded.
   EXPECT_FALSE(EncryptEverythingEnabledForTest());
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByIdLookup(GetIdForDataType(NIGORI)));
     sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
     EXPECT_TRUE(nigori.has_encrypted());
     Cryptographer* cryptographer = trans.GetCryptographer();
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encrypted()));
   }
 }
 
 TEST_F(SyncManagerTest, EncryptDataTypesWithNoData) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::EncryptableTypes()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.EnableEncryptEverything();
   EXPECT_TRUE(EncryptEverythingEnabledForTest());
 }
 
 TEST_F(SyncManagerTest, EncryptDataTypesWithData) {
   size_t batch_size = 5;
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
 
   // Create some unencrypted unsynced data.
@@ skipping 36 matching lines @@
         false /* not encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         THEMES,
         false /* not encrypted */));
   }
 
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::EncryptableTypes()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.EnableEncryptEverything();
   EXPECT_TRUE(EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(
-        ModelTypeSet::All()));
+        syncer::EncryptableTypes()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         BOOKMARKS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         SESSIONS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         THEMES,
         true /* is encrypted */));
   }
 
   // Trigger's a ReEncryptEverything with new passphrase.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnBootstrapTokenUpdated(_));
   EXPECT_CALL(observer_, OnPassphraseAccepted());
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.SetEncryptionPassphrase("new_passphrase", true);
   EXPECT_TRUE(EncryptEverythingEnabledForTest());
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
-    EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(ModelTypeSet::All()));
+    EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(syncer::EncryptableTypes()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         BOOKMARKS,
         true /* is encrypted */));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         SESSIONS,
         true /* is encrypted */));
@@ skipping 420 matching lines @@
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         BOOKMARKS,
         false /* not encrypted */));
   }
 
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::EncryptableTypes()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   sync_manager_.EnableEncryptEverything();
   EXPECT_TRUE(EncryptEverythingEnabledForTest());
 
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
-    EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(ModelTypeSet::All()));
+    EXPECT_TRUE(GetEncryptedTypes(&trans).Equals(syncer::EncryptableTypes()));
     EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
         trans.GetWrappedTrans(),
         trans.GetCryptographer(),
         BOOKMARKS,
         true /* is encrypted */));
 
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
     EXPECT_EQ(BOOKMARKS, node.GetModelType());
     EXPECT_EQ(title, node.GetTitle());
@@ skipping 60 matching lines @@
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetEntitySpecifics(entity_specifics);
   }
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::EncryptableTypes()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
 
-  sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
-  PumpLoop();
+  RefreshEncryption();
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
@@ skipping 22 matching lines @@
     EXPECT_TRUE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
         specifics.encrypted()));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Force a re-encrypt everything. Should not set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnEncryptionComplete());
 
-  sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
-  PumpLoop();
-
+  RefreshEncryption();
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->Get(SPECIFICS);
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->Get(NON_UNIQUE_NAME));
     Cryptographer* cryptographer = trans.GetCryptographer();
@@ skipping 176 matching lines @@
   MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
                  BaseNode::GenerateSyncableHash(PASSWORDS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 
   // Force a re-encrypt everything. Should not set is_unsynced.
   testing::Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_CALL(observer_, OnEncryptionComplete());
-  sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
-  PumpLoop();
+  RefreshEncryption();
   EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for bookmarks
 // when we write the same data, but does set it when we write new data.
 TEST_F(SyncManagerTest, SetBookmarkTitle) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_bookmark()->set_url("url");
   entity_specifics.mutable_bookmark()->set_title("title");
@@ skipping 36 matching lines @@
   MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
                  BaseNode::GenerateSyncableHash(BOOKMARKS,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::EncryptableTypes()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
-  sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
-  PumpLoop();
+  RefreshEncryption();
   EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
@@ skipping 70 matching lines @@
                  client_tag,
                  BaseNode::GenerateSyncableHash(PREFERENCES,
                                                 client_tag),
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Encrypt the datatatype, should set is_unsynced.
   EXPECT_CALL(observer_,
               OnEncryptedTypesChanged(
-                  HasModelTypes(ModelTypeSet::All()), true));
+                  HasModelTypes(syncer::EncryptableTypes()), true));
   EXPECT_CALL(observer_, OnEncryptionComplete());
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
-  sync_manager_.RefreshNigori(kTestChromeVersion, base::Bind(&DoNothing));
-  PumpLoop();
+  RefreshEncryption();
   EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PREFERENCES, client_tag));
     node.SetTitle(UTF8ToWide(client_tag));
@@ skipping 350 matching lines @@
 
   // Verify only the non-disabled types remain after cleanup.
   sync_manager_.PurgeDisabledTypes(enabled_types, new_enabled_types);
   EXPECT_TRUE(new_enabled_types.Equals(
       Union(sync_manager_.InitialSyncEndedTypes(), partial_enabled_types)));
   EXPECT_TRUE(disabled_types.Equals(
       sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All())));
 }
 
 }  // namespace