[sync] Add backup time in synced device info so that server can flag device

chrome/browser/sync/glue/synced_device_tracker.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 "chrome/browser/sync/glue/synced_device_tracker.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/sync/glue/device_info.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/user_share.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
+#include "sync/util/time.h"
 
 namespace browser_sync {
 
 namespace {
 
 // Return the DeviceInfo UNIQUE_CLIENT_TAG value for the given sync cache_guid.
 std::string DeviceInfoLookupString(const std::string& cache_guid) {
   return base::StringPrintf("DeviceInfo_%s", cache_guid.c_str());
 }
 
@@ skipping 124 matching lines @@
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void SyncedDeviceTracker::InitLocalDeviceInfoContinuation(
     const base::Closure& callback, const DeviceInfo& local_info) {
   WriteLocalDeviceInfo(local_info);
   callback.Run();
 }
 
 void SyncedDeviceTracker::WriteLocalDeviceInfo(const DeviceInfo& info) {
+  DCHECK_EQ(cache_guid_, info.guid());
+  WriteDeviceInfo(info, local_device_info_tag_);
+}
+
+void SyncedDeviceTracker::WriteDeviceInfo(const DeviceInfo& info,
+                                          const std::string& tag) {
+  syncer::WriteTransaction trans(FROM_HERE, user_share_);
+  syncer::WriteNode node(&trans);
+
   sync_pb::DeviceInfoSpecifics specifics;
-  DCHECK_EQ(cache_guid_, info.guid());
-  specifics.set_cache_guid(cache_guid_);
+  specifics.set_cache_guid(info.guid());
   specifics.set_client_name(info.client_name());
   specifics.set_chrome_version(info.chrome_version());
   specifics.set_sync_user_agent(info.sync_user_agent());
   specifics.set_device_type(info.device_type());
 
-  WriteDeviceInfo(specifics, local_device_info_tag_);
-}
-
-void SyncedDeviceTracker::WriteDeviceInfo(
-    const sync_pb::DeviceInfoSpecifics& specifics,
-    const std::string& tag) {
-  syncer::WriteTransaction trans(FROM_HERE, user_share_);
-  syncer::WriteNode node(&trans);
-
   if (node.InitByClientTagLookup(syncer::DEVICE_INFO, tag) ==
       syncer::BaseNode::INIT_OK) {
+    const sync_pb::DeviceInfoSpecifics& sync_specifics =
+        node.GetDeviceInfoSpecifics();
+    if (sync_specifics.has_backup_timestamp())
+      specifics.set_backup_timestamp(sync_specifics.backup_timestamp());
     node.SetDeviceInfoSpecifics(specifics);
     node.SetTitle(specifics.client_name());
   } else {
     syncer::ReadNode type_root(&trans);
     syncer::BaseNode::InitByLookupResult type_root_lookup_result =
         type_root.InitTypeRoot(syncer::DEVICE_INFO);
     DCHECK_EQ(syncer::BaseNode::INIT_OK, type_root_lookup_result);
 
     syncer::WriteNode new_node(&trans);
     syncer::WriteNode::InitUniqueByCreationResult create_result =
         new_node.InitUniqueByCreation(syncer::DEVICE_INFO,
                                       type_root,
                                       tag);
     DCHECK_EQ(syncer::WriteNode::INIT_SUCCESS, create_result);
     new_node.SetDeviceInfoSpecifics(specifics);
     new_node.SetTitle(specifics.client_name());
   }
 }
 
+void SyncedDeviceTracker::UpdateLocalDeviceBackupTime(base::Time backup_time) {
+  syncer::WriteTransaction trans(FROM_HERE, user_share_);
+  syncer::WriteNode node(&trans);
+
+  if (node.InitByClientTagLookup(syncer::DEVICE_INFO, local_device_info_tag_)
+          == syncer::BaseNode::INIT_OK) {
+    sync_pb::DeviceInfoSpecifics specifics = node.GetDeviceInfoSpecifics();
+    int64 new_backup_timestamp = syncer::TimeToProtoTime(backup_time);
+    if (!specifics.has_backup_timestamp() ||
+        specifics.backup_timestamp() != new_backup_timestamp) {
+      specifics.set_backup_timestamp(new_backup_timestamp);
+      node.SetDeviceInfoSpecifics(specifics);
+    }
+  }
+}
+
+base::Time SyncedDeviceTracker::GetLocalDeviceBackupTime() const {
+  syncer::ReadTransaction trans(FROM_HERE, user_share_);
+  syncer::ReadNode node(&trans);
+  if (node.InitByClientTagLookup(syncer::DEVICE_INFO, local_device_info_tag_)
+          == syncer::BaseNode::INIT_OK &&
+      node.GetDeviceInfoSpecifics().has_backup_timestamp()) {
+    return syncer::ProtoTimeToTime(
+        node.GetDeviceInfoSpecifics().backup_timestamp());
+  } else {
+    return base::Time();
+  }
+}
+
 }  // namespace browser_sync