FYI: Control Data + Per-Device Metadata

sync/internal_api/sync_manager_impl.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.
 
 #include "sync/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 481 matching lines @@
   trans.GetCryptographer()->BootstrapKeystoreKey(
       restored_keystore_key_for_bootstrapping);
   trans.GetCryptographer()->AddObserver(this);
 
   FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                     OnInitializationComplete(
                         MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()),
                         true, InitialSyncEndedTypes()));
 }
 
-void SyncManagerImpl::RefreshNigori(const std::string& chrome_version,
-                                    const base::Closure& done_callback) {
+void SyncManagerImpl::InitialProcessMetadata(
+    const std::string& chrome_version,
+    const base::Closure& done_callback) {
   DCHECK(initialized_);
   DCHECK(thread_checker_.CalledOnValidThread());
-  GetSessionName(
-      blocking_task_runner_,
-      base::Bind(
-          &SyncManagerImpl::UpdateCryptographerAndNigoriCallback,
-          weak_ptr_factory_.GetWeakPtr(),
-          chrome_version,
-          done_callback));
+  GetSessionName(blocking_task_runner_,
+                 base::Bind(
+                     &SyncManagerImpl::InitialProcessMetadataContinuation,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     chrome_version,
+                     done_callback));
+}
+
+void SyncManagerImpl::InitialProcessMetadataContinuation(

[rlarocque, 2012/08/11 01:31:52]

This would be a great place to put the code that checks and sets account-global
flags.

+    const std::string& chrome_version,
+    const base::Closure& done_callback,
+    const std::string& session_name) {
+  UpdateCryptographerAndNigori();
+  UpdateDeviceInformation(chrome_version, session_name);
+  done_callback.Run();
 }
 
 void SyncManagerImpl::UpdateNigoriEncryptionState(
     Cryptographer* cryptographer,
     WriteNode* nigori_node) {
   DCHECK(nigori_node);
   sync_pb::NigoriSpecifics nigori = nigori_node->GetNigoriSpecifics();
 
   if (cryptographer->is_ready() &&
       nigori_overwrite_count_ < kNigoriOverwriteLimit) {
@@ skipping 16 matching lines @@
     // Note: we don't try to set using_explicit_passphrase here since if that
     // is lost the user can always set it again. The main point is to preserve
     // the encryption keys so all data remains decryptable.
   }
   cryptographer->UpdateNigoriFromEncryptedTypes(&nigori);
 
   // If nothing has changed, this is a no-op.
   nigori_node->SetNigoriSpecifics(nigori);
 }
 
-void SyncManagerImpl::UpdateCryptographerAndNigoriCallback(
-    const std::string& chrome_version,
-    const base::Closure& done_callback,
-    const std::string& session_name) {
-  if (!directory()->initial_sync_ended_for_type(NIGORI)) {
-    done_callback.Run();  // Should only happen during first time sync.
-    return;
-  }
+void SyncManagerImpl::UpdateCryptographerAndNigori() {
+  DCHECK(directory()->initial_sync_ended_for_type(NIGORI));
 
   bool success = false;
   {
     WriteTransaction trans(FROM_HERE, GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     WriteNode node(&trans);
 
     if (node.InitByTagLookup(kNigoriTag) == BaseNode::INIT_OK) {
       sync_pb::NigoriSpecifics nigori(node.GetNigoriSpecifics());
       Cryptographer::UpdateResult result = cryptographer->Update(nigori);
       if (result == Cryptographer::NEEDS_PASSPHRASE) {
         sync_pb::EncryptedData pending_keys;
         if (cryptographer->has_pending_keys())
           pending_keys = cryptographer->GetPendingKeys();
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                           OnPassphraseRequired(REASON_DECRYPTION,
                                                pending_keys));
       }
 
-      // Add or update device information.
-      bool contains_this_device = false;
-      for (int i = 0; i < nigori.device_information_size(); ++i) {
-        const sync_pb::DeviceInformation& device_information =
-            nigori.device_information(i);
-        if (device_information.cache_guid() == directory()->cache_guid()) {
-          // Update the version number in case it changed due to an update.
-          if (device_information.chrome_version() != chrome_version) {
-            sync_pb::DeviceInformation* mutable_device_information =
-                nigori.mutable_device_information(i);
-            mutable_device_information->set_chrome_version(
-                chrome_version);
-          }
-          contains_this_device = true;
-        }
-      }
-
-      if (!contains_this_device) {
-        sync_pb::DeviceInformation* device_information =
-            nigori.add_device_information();
-        device_information->set_cache_guid(directory()->cache_guid());
-#if defined(OS_CHROMEOS)
-        device_information->set_platform("ChromeOS");
-#elif defined(OS_LINUX)
-        device_information->set_platform("Linux");
-#elif defined(OS_MACOSX)
-        device_information->set_platform("Mac");
-#elif defined(OS_WIN)
-        device_information->set_platform("Windows");
-#endif
-        device_information->set_name(session_name);
-        device_information->set_chrome_version(chrome_version);
-      }
-      // Disabled to avoid nigori races. TODO(zea): re-enable. crbug.com/122837
-      // node.SetNigoriSpecifics(nigori);
 
       // Make sure the nigori node has the up to date encryption info.
       UpdateNigoriEncryptionState(cryptographer, &node);
 
       NotifyCryptographerState(cryptographer);
       allstatus_.SetEncryptedTypes(cryptographer->GetEncryptedTypes());
 
       success = cryptographer->is_ready();
     } else {
       NOTREACHED();
     }
   }
 
   if (success)
     RefreshEncryption();
-  done_callback.Run();
+}
+
+void SyncManagerImpl::UpdateDeviceInformation(const std::string& chrome_version,
+                                              const std::string& session_name) {
+  DCHECK(!directory()->cache_guid().empty());
+
+  WriteTransaction trans(FROM_HERE, GetUserShare());
+
+  WriteNode node(&trans);
+  BaseNode::InitByLookupResult lookup_result =
+      node.InitByClientTagLookup(PER_DEVICE_METADATA,
+                                 directory()->cache_guid());
+  if (lookup_result == BaseNode::INIT_OK) {
+    // Found an existing node.  Update its version, if necessary.
+    sync_pb::PerDeviceSpecifics specifics = node.GetPerDeviceSpecifics();
+    if (specifics.device_information().chrome_version() != chrome_version) {
+      specifics.mutable_device_information()->set_chrome_version(
+          chrome_version);
+      node.SetPerDeviceSpecifics(specifics);
+    }
+  } else {
+    ReadNode type_root(&trans);
+    BaseNode::InitByLookupResult type_root_lookup_result =
+        type_root.InitByTagLookup(ModelTypeToRootTag(PER_DEVICE_METADATA));
+    DCHECK(type_root_lookup_result == BaseNode::INIT_OK);
+
+    WriteNode new_node(&trans);
+    WriteNode::InitUniqueByCreationResult create_result =
+        new_node.InitUniqueByCreation(PER_DEVICE_METADATA,
+                                      type_root,
+                                      directory()->cache_guid());
+    DCHECK(create_result == WriteNode::INIT_SUCCESS);
+    sync_pb::PerDeviceSpecifics per_device_specifics =
+      new_node.GetPerDeviceSpecifics();
+    sync_pb::DeviceInformation* device_information =
+        per_device_specifics.mutable_device_information();
+
+    device_information->set_cache_guid(directory()->cache_guid());
+    device_information->set_name(session_name);
+    device_information->set_chrome_version(chrome_version);
+
+#if defined(OS_CHROMEOS)
+    device_information->set_platform("ChromeOS");
+#elif defined(OS_LINUX)
+    device_information->set_platform("Linux");
+#elif defined(OS_MACOSX)
+    device_information->set_platform("Mac");
+#elif defined(OS_WIN)
+    device_information->set_platform("Windows");
+#endif
+    new_node.SetPerDeviceSpecifics(per_device_specifics);
+  }
 }
 
 void SyncManagerImpl::NotifyCryptographerState(Cryptographer * cryptographer) {
   // TODO(lipalani): Explore the possibility of hooking this up to
   // SyncManager::Observer and making |AllStatus| a listener for that.
   allstatus_.SetCryptographerReady(cryptographer->is_ready());
   allstatus_.SetCryptoHasPendingKeys(cryptographer->has_pending_keys());
   debug_info_event_listener_.SetCryptographerReady(cryptographer->is_ready());
   debug_info_event_listener_.SetCrytographerHasPendingKeys(
       cryptographer->has_pending_keys());
@@ skipping 499 matching lines @@
 // the lookup of the root node will fail and we will skip encryption for that
 // type.
 void SyncManagerImpl::ReEncryptEverything(
       WriteTransaction* trans) {
   Cryptographer* cryptographer = trans->GetCryptographer();
   if (!cryptographer || !cryptographer->is_ready())
     return;
   ModelTypeSet encrypted_types = GetEncryptedTypes(trans);
   for (ModelTypeSet::Iterator iter = encrypted_types.First();
        iter.Good(); iter.Inc()) {
-    if (iter.Get() == PASSWORDS || iter.Get() == NIGORI)
+    if (iter.Get() == PASSWORDS || IsControlType(iter.Get()))
       continue; // These types handle encryption differently.
 
     ReadNode type_root(trans);
     std::string tag = ModelTypeToRootTag(iter.Get());
     if (type_root.InitByTagLookup(tag) != BaseNode::INIT_OK)
       continue; // Don't try to reencrypt if the type's data is unavailable.
 
     // Iterate through all children of this datatype.
     std::queue<int64> to_visit;
     int64 child_id = type_root.GetFirstChildId();
@@ skipping 760 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer