[SendTabToSelf] Add last_updated_timestamp field to DeviceInfo.

Adds the last_updated_timestamp field to DeviceInfo and populate it with
the already existing field of the same name in the sync proto.

Use that value instead of using the change processor in the
SendTabToSelfBridge.

Bug: 959487
Change-Id: If84605055988c2d5deb4f5f0be373cc7d4368f0f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1598550
Commit-Queue: sebsg <sebsg@chromium.org>
Reviewed-by: Marc Treib <treib@chromium.org>
Reviewed-by: Mikel Astiz <mastiz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#658298}

chrome/browser/extensions/api/signed_in_devices/id_mapping_helper_unittest.cc

@@ -8,6 +8,7 @@
 #include <string>
 
 #include "base/guid.h"
+#include "base/time/time.h"
 #include "base/values.h"
 #include "components/sync_device_info/device_info.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -32,12 +33,12 @@ TEST(IdMappingHelperTest, SetIdsForDevices) {
 
   devices.push_back(std::make_unique<DeviceInfo>(
       base::GenerateGUID(), "abc Device", "XYZ v1", "XYZ SyncAgent v1",
-      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id1",
+      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id1", base::Time(),
       /*send_tab_to_self_receiving_enabled=*/true));
 
   devices.push_back(std::make_unique<DeviceInfo>(
       base::GenerateGUID(), "def Device", "XYZ v1", "XYZ SyncAgent v1",
-      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id2",
+      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id2", base::Time(),
       /*send_tab_to_self_receiving_enabled=*/true));
 
   base::DictionaryValue dictionary;
@@ -55,7 +56,7 @@ TEST(IdMappingHelperTest, SetIdsForDevices) {
   // Now add a third device.
   devices.push_back(std::make_unique<DeviceInfo>(
       base::GenerateGUID(), "ghi Device", "XYZ v1", "XYZ SyncAgent v1",
-      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id3",
+      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id3", base::Time(),
       /*send_tab_to_self_receiving_enabled=*/true));
 
   CreateMappingForUnmappedDevices(devices, &dictionary);

chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api_unittest.cc

@@ -11,6 +11,7 @@
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_api_unittest.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
@@ -48,6 +49,7 @@ class MockDeviceInfoTracker : public DeviceInfoTracker {
         device_info.guid(), device_info.client_name(),
         device_info.chrome_version(), device_info.sync_user_agent(),
         device_info.device_type(), device_info.signin_scoped_device_id(),
+        device_info.last_updated_timestamp(),
         device_info.send_tab_to_self_receiving_enabled());
   }
 
@@ -89,13 +91,15 @@ TEST(SignedInDevicesAPITest, GetSignedInDevices) {
   scoped_refptr<Extension> extension_test =
       extension_prefs.AddExtension(extension_name);
 
-  DeviceInfo device_info1(
-      base::GenerateGUID(), "abc Device", "XYZ v1", "XYZ SyncAgent v1",
-      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id", true);
+  DeviceInfo device_info1(base::GenerateGUID(), "abc Device", "XYZ v1",
+                          "XYZ SyncAgent v1",
+                          sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id",
+                          base::Time(), true);
 
-  DeviceInfo device_info2(
-      base::GenerateGUID(), "def Device", "XYZ v2", "XYZ SyncAgent v2",
-      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id", true);
+  DeviceInfo device_info2(base::GenerateGUID(), "def Device", "XYZ v2",
+                          "XYZ SyncAgent v2",
+                          sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id",
+                          base::Time(), true);
 
   device_tracker.Add(&device_info1);
   device_tracker.Add(&device_info2);
@@ -112,9 +116,10 @@ TEST(SignedInDevicesAPITest, GetSignedInDevices) {
 
   // Add a third device and make sure the first 2 ids are retained and a new
   // id is generated for the third device.
-  DeviceInfo device_info3(
-      base::GenerateGUID(), "def Device", "jkl v2", "XYZ SyncAgent v2",
-      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id", true);
+  DeviceInfo device_info3(base::GenerateGUID(), "def Device", "jkl v2",
+                          "XYZ SyncAgent v2",
+                          sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id",
+                          base::Time(), true);
 
   device_tracker.Add(&device_info3);
 
@@ -200,13 +205,15 @@ TEST_F(ExtensionSignedInDevicesTest, GetAll) {
           DeviceInfoSyncServiceFactory::GetForProfile(profile()))
           ->mock_tracker();
 
-  DeviceInfo device_info1(
-      base::GenerateGUID(), "abc Device", "XYZ v1", "XYZ SyncAgent v1",
-      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id", true);
+  DeviceInfo device_info1(base::GenerateGUID(), "abc Device", "XYZ v1",
+                          "XYZ SyncAgent v1",
+                          sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id",
+                          base::Time(), true);
 
-  DeviceInfo device_info2(
-      base::GenerateGUID(), "def Device", "XYZ v2", "XYZ SyncAgent v2",
-      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id", true);
+  DeviceInfo device_info2(base::GenerateGUID(), "def Device", "XYZ v2",
+                          "XYZ SyncAgent v2",
+                          sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id",
+                          base::Time(), true);
 
   device_tracker->Add(&device_info1);
   device_tracker->Add(&device_info2);

chrome/browser/sync/test/integration/two_client_send_tab_to_self_sync_test.cc

@@ -14,6 +14,7 @@
 #include "components/send_tab_to_self/features.h"
 #include "components/send_tab_to_self/send_tab_to_self_model.h"
 #include "components/send_tab_to_self/send_tab_to_self_sync_service.h"
+#include "components/send_tab_to_self/target_device_info.h"
 #include "components/sync/driver/sync_driver_switches.h"
 #include "components/sync_device_info/device_info.h"
 #include "components/sync_device_info/device_info_sync_service.h"
@@ -188,3 +189,34 @@ IN_PROC_BROWSER_TEST_F(TwoClientSendTabToSelfSyncTest,
   EXPECT_NE(device_infos[0]->send_tab_to_self_receiving_enabled(),
             device_infos[1]->send_tab_to_self_receiving_enabled());
 }
+
+IN_PROC_BROWSER_TEST_F(TwoClientSendTabToSelfSyncTest,
+                       SendTabToSelfTargetDeviceMap) {
+  ASSERT_TRUE(SetupSync());
+
+  DeviceInfoSyncServiceFactory::GetForProfile(GetProfile(0))
+      ->GetDeviceInfoTracker()
+      ->ForcePulseForTest();
+  DeviceInfoSyncServiceFactory::GetForProfile(GetProfile(1))
+      ->GetDeviceInfoTracker()
+      ->ForcePulseForTest();
+
+  ASSERT_TRUE(send_tab_to_self_helper::SendTabToSelfMultiDeviceActiveChecker(
+                  DeviceInfoSyncServiceFactory::GetForProfile(GetProfile(1))
+                      ->GetDeviceInfoTracker())
+                  .Wait());
+
+  std::map<std::string, send_tab_to_self::TargetDeviceInfo>
+      profile1_target_device_map =
+          SendTabToSelfSyncServiceFactory::GetForProfile(GetProfile(0))
+              ->GetSendTabToSelfModel()
+              ->GetTargetDeviceNameToCacheInfoMap();
+  std::map<std::string, send_tab_to_self::TargetDeviceInfo>
+      profile2_target_device_map =
+          SendTabToSelfSyncServiceFactory::GetForProfile(GetProfile(1))
+              ->GetSendTabToSelfModel()
+              ->GetTargetDeviceNameToCacheInfoMap();
+
+  EXPECT_EQ(1u, profile1_target_device_map.size());
+  EXPECT_EQ(1u, profile2_target_device_map.size());
+}

components/send_tab_to_self/send_tab_to_self_bridge.cc

@@ -556,8 +556,7 @@ bool SendTabToSelfBridge::ShouldUpdateTargetDeviceNameToCacheInfoMap() const {
   return target_device_name_to_cache_info_.empty() ||
          device_info_tracker_->GetAllDeviceInfo().size() !=
              number_of_devices_ ||
-         clock_->Now() - change_processor()->GetEntityModificationTime(
-                             oldest_device_cache_guid_) >
+         clock_->Now() - oldest_non_expired_device_timestamp_ >
              kDeviceExpiration;
 }
 
@@ -567,23 +566,21 @@ void SendTabToSelfBridge::SetTargetDeviceNameToCacheInfoMap() {
   number_of_devices_ = all_devices.size();
 
   // Sort the DeviceInfo vector so the most recenly modified devices are first.
-  const syncer::ModelTypeChangeProcessor* change_processor_ptr =
-      change_processor();
-  std::stable_sort(
-      all_devices.begin(), all_devices.end(),
-      [change_processor_ptr](
-          const std::unique_ptr<syncer::DeviceInfo>& device1,
-          const std::unique_ptr<syncer::DeviceInfo>& device2) {
-        return change_processor_ptr->GetEntityModificationTime(
-                   device1->guid()) >
-               change_processor_ptr->GetEntityModificationTime(device2->guid());
-      });
+  std::stable_sort(all_devices.begin(), all_devices.end(),
+                   [](const std::unique_ptr<syncer::DeviceInfo>& device1,
+                      const std::unique_ptr<syncer::DeviceInfo>& device2) {
+                     return device1->last_updated_timestamp() >
+                            device2->last_updated_timestamp();
+                   });
 
   target_device_name_to_cache_info_.clear();
   for (const auto& device : all_devices) {
-    // TODO(crbug/959487) If the current device is considered expired for our
-    // purposes, stop here since the next devices in the vector are at least
-    // as expired than this one.
+    // If the current device is considered expired for our purposes, stop here
+    // since the next devices in the vector are at least as expired than this
+    // one.
+    if (clock_->Now() - device->last_updated_timestamp() > kDeviceExpiration) {
+      break;
+    }
 
     // TODO(crbug.com/957716): Dedupe older versions of this device as well.
     // Don't include this device.
@@ -602,7 +599,7 @@ void SendTabToSelfBridge::SetTargetDeviceNameToCacheInfoMap() {
     TargetDeviceInfo target_device_info(device->guid(), device->device_type());
     target_device_name_to_cache_info_.emplace(device->client_name(),
                                               target_device_info);
-    oldest_device_cache_guid_ = device->guid();
+    oldest_non_expired_device_timestamp_ = device->last_updated_timestamp();
   }
 }
 

components/send_tab_to_self/send_tab_to_self_bridge.h

@@ -170,7 +170,7 @@ class SendTabToSelfBridge : public syncer::ModelTypeSyncBridge,
 
   // The following two variables are used to determine whether we should update
   // the target device name to cache guid map.
-  std::string oldest_device_cache_guid_ = "";
+  base::Time oldest_non_expired_device_timestamp_;
   size_t number_of_devices_ = 0;
 
   base::WeakPtrFactory<SendTabToSelfBridge> weak_ptr_factory_;

components/send_tab_to_self/send_tab_to_self_bridge_unittest.cc

@@ -94,6 +94,7 @@ class TestDeviceInfoTracker : public syncer::DeviceInfoTracker {
         device_info.guid(), device_info.client_name(),
         device_info.chrome_version(), device_info.sync_user_agent(),
         device_info.device_type(), device_info.signin_scoped_device_id(),
+        device_info.last_updated_timestamp(),
         device_info.send_tab_to_self_receiving_enabled());
   }
 
@@ -676,32 +677,26 @@ TEST_F(SendTabToSelfBridgeTest,
   InitializeBridge();
 
   // Create multiple DeviceInfo objects with the same name but different guids.
-  syncer::DeviceInfo device1(kOldGuid, "device_name", "72", "agent",
-                             sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
-                             "scoped_is",
-                             /*send_tab_to_self_receiving_enabled=*/true);
-  AddTestDevice(&device1);
-
-  syncer::DeviceInfo device2(kRecentGuid, "device_name", "72", "agent",
-                             sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
-                             "scoped_is",
-                             /*send_tab_to_self_receiving_enabled=*/true);
-  AddTestDevice(&device2);
-
-  syncer::DeviceInfo device3(kOlderGuid, "device_name", "72", "agent",
-                             sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
-                             "scoped_is",
-                             /*send_tab_to_self_receiving_enabled=*/true);
-  AddTestDevice(&device3);
-
-  // Make sure the device with cache id "recent_guid" was modified more
-  // recently.
-  ON_CALL(*processor(), GetEntityModificationTime(kRecentGuid))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(1)));
-  ON_CALL(*processor(), GetEntityModificationTime(kOldGuid))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(3)));
-  ON_CALL(*processor(), GetEntityModificationTime(kOlderGuid))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(5)));
+  syncer::DeviceInfo recent_device(
+      kRecentGuid, "device_name", "72", "agent",
+      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      clock()->Now() - base::TimeDelta::FromDays(1),
+      /*send_tab_to_self_receiving_enabled=*/true);
+  AddTestDevice(&recent_device);
+
+  syncer::DeviceInfo old_device(
+      kOldGuid, "device_name", "72", "agent",
+      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      /*last_updated_timestamp=*/clock()->Now() - base::TimeDelta::FromDays(3),
+      /*send_tab_to_self_receiving_enabled=*/true);
+  AddTestDevice(&old_device);
+
+  syncer::DeviceInfo older_device(
+      kOlderGuid, "device_name", "72", "agent",
+      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      /*last_updated_timestamp=*/clock()->Now() - base::TimeDelta::FromDays(5),
+      /*send_tab_to_self_receiving_enabled=*/true);
+  AddTestDevice(&older_device);
 
   TargetDeviceInfo target_device_info(kRecentGuid,
                                       sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
@@ -719,21 +714,17 @@ TEST_F(SendTabToSelfBridgeTest,
   syncer::DeviceInfo enabled_device(
       "enabled_guid", "enabled_device_name", "72", "agent",
       sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      /*last_updated_timestamp=*/clock()->Now(),
       /*send_tab_to_self_receiving_enabled=*/true);
   AddTestDevice(&enabled_device);
 
   syncer::DeviceInfo disabled_device(
       "disabled_guid", "disabled_device_name", "72", "agent",
       sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      /*last_updated_timestamp=*/clock()->Now(),
       /*send_tab_to_self_receiving_enabled=*/false);
   AddTestDevice(&disabled_device);
 
-  // Make sure the devices were used recently.
-  ON_CALL(*processor(), GetEntityModificationTime("enabled_guid"))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(1)));
-  ON_CALL(*processor(), GetEntityModificationTime("disabled_guid"))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(1)));
-
   TargetDeviceInfo target_device_info("enabled_guid",
                                       sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
 
@@ -750,21 +741,17 @@ TEST_F(SendTabToSelfBridgeTest,
   syncer::DeviceInfo expired_device(
       "expired_guid", "expired_device_name", "72", "agent",
       sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      /*last_updated_timestamp=*/clock()->Now() - base::TimeDelta::FromDays(11),
       /*send_tab_to_self_receiving_enabled=*/true);
   AddTestDevice(&expired_device);
 
   syncer::DeviceInfo valid_device(
       "valid_guid", "valid_device_name", "72", "agent",
       sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      /*last_updated_timestamp=*/clock()->Now() - base::TimeDelta::FromDays(1),
       /*send_tab_to_self_receiving_enabled=*/true);
   AddTestDevice(&valid_device);
 
-  // Set one device to be expired and the other to be valid.
-  ON_CALL(*processor(), GetEntityModificationTime("expired_guid"))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(11)));
-  ON_CALL(*processor(), GetEntityModificationTime("valid_guid"))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(1)));
-
   TargetDeviceInfo target_device_info("valid_guid",
                                       sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
 
@@ -780,21 +767,17 @@ TEST_F(SendTabToSelfBridgeTest,
   syncer::DeviceInfo local_device(
       kLocalDeviceCacheGuid, "local_device_name", "72", "agent",
       sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      /*last_updated_timestamp=*/clock()->Now(),
       /*send_tab_to_self_receiving_enabled=*/true);
   AddTestDevice(&local_device);
 
   syncer::DeviceInfo other_device(
       "other_guid", "other_device_name", "72", "agent",
       sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      /*last_updated_timestamp=*/clock()->Now(),
       /*send_tab_to_self_receiving_enabled=*/true);
   AddTestDevice(&other_device);
 
-  // Set both device to not be expired.
-  ON_CALL(*processor(), GetEntityModificationTime(kLocalDeviceCacheGuid))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(1)));
-  ON_CALL(*processor(), GetEntityModificationTime("other_guid"))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(1)));
-
   TargetDeviceInfo target_device_info("other_guid",
                                       sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
 
@@ -809,24 +792,20 @@ TEST_F(SendTabToSelfBridgeTest,
   InitializeBridge();
 
   // Set a device that is about to expire and a more recent device.
-  syncer::DeviceInfo older_device("older_guid", "older_name", "72", "agent",
-                                  sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
-                                  "scoped_is",
-                                  /*send_tab_to_self_receiving_enabled=*/true);
+  syncer::DeviceInfo older_device(
+      "older_guid", "older_name", "72", "agent",
+      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      /*last_updated_timestamp=*/clock()->Now() - base::TimeDelta::FromDays(9),
+      /*send_tab_to_self_receiving_enabled=*/true);
   AddTestDevice(&older_device);
 
-  syncer::DeviceInfo recent_device("recent_guid", "recent_name", "72", "agent",
-                                   sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
-                                   "scoped_is",
-                                   /*send_tab_to_self_receiving_enabled=*/true);
+  syncer::DeviceInfo recent_device(
+      "recent_guid", "recent_name", "72", "agent",
+      sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "scoped_is",
+      /*last_updated_timestamp=*/clock()->Now() - base::TimeDelta::FromDays(1),
+      /*send_tab_to_self_receiving_enabled=*/true);
   AddTestDevice(&recent_device);
 
-  // Set both device to not be expired.
-  ON_CALL(*processor(), GetEntityModificationTime("older_guid"))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(9)));
-  ON_CALL(*processor(), GetEntityModificationTime("recent_guid"))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(1)));
-
   TargetDeviceInfo device_info_1("older_guid",
                                  sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
   TargetDeviceInfo device_info_2("recent_guid",
@@ -851,13 +830,11 @@ TEST_F(SendTabToSelfBridgeTest,
   InitializeBridge();
 
   // Set a valid device.
-  syncer::DeviceInfo device("guid", "name", "72", "agent",
-                            sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
-                            "scoped_is",
-                            /*send_tab_to_self_receiving_enabled=*/true);
+  syncer::DeviceInfo device(
+      "guid", "name", "72", "agent", sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
+      "scoped_is", /*last_updated_timestamp=*/clock()->Now(),
+      /*send_tab_to_self_receiving_enabled=*/true);
   AddTestDevice(&device);
-  ON_CALL(*processor(), GetEntityModificationTime("guid"))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(1)));
 
   // Set the map by calling it. Make sure it has the device.
   TargetDeviceInfo device_info_1("guid",
@@ -870,10 +847,9 @@ TEST_F(SendTabToSelfBridgeTest,
   syncer::DeviceInfo new_device("new_guid", "new_name", "72", "agent",
                                 sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
                                 "scoped_is",
+                                /*last_updated_timestamp=*/clock()->Now(),
                                 /*send_tab_to_self_receiving_enabled=*/true);
   AddTestDevice(&new_device);
-  ON_CALL(*processor(), GetEntityModificationTime("new_guid"))
-      .WillByDefault(Return(clock()->Now() - base::TimeDelta::FromDays(1)));
 
   // Make sure both devices are in the map.
   TargetDeviceInfo device_info_2("new_guid",

components/sync_device_info/device_info.cc

@@ -14,6 +14,7 @@ DeviceInfo::DeviceInfo(const std::string& guid,
                        const std::string& sync_user_agent,
                        const sync_pb::SyncEnums::DeviceType device_type,
                        const std::string& signin_scoped_device_id,
+                       base::Time last_updated_timestamp,
                        bool send_tab_to_self_receiving_enabled)
     : guid_(guid),
       client_name_(client_name),
@@ -21,6 +22,7 @@ DeviceInfo::DeviceInfo(const std::string& guid,
       sync_user_agent_(sync_user_agent),
       device_type_(device_type),
       signin_scoped_device_id_(signin_scoped_device_id),
+      last_updated_timestamp_(last_updated_timestamp),
       send_tab_to_self_receiving_enabled_(send_tab_to_self_receiving_enabled) {}
 
 DeviceInfo::~DeviceInfo() {}
@@ -53,6 +55,10 @@ const std::string& DeviceInfo::signin_scoped_device_id() const {
   return signin_scoped_device_id_;
 }
 
+base::Time DeviceInfo::last_updated_timestamp() const {
+  return last_updated_timestamp_;
+}
+
 bool DeviceInfo::send_tab_to_self_receiving_enabled() const {
   return send_tab_to_self_receiving_enabled_;
 }
@@ -111,6 +117,7 @@ std::unique_ptr<base::DictionaryValue> DeviceInfo::ToValue() {
   value->SetString("os", GetOSString());
   value->SetString("type", GetDeviceTypeString());
   value->SetString("chromeVersion", chrome_version_);
+  value->SetInteger("lastUpdatedTimestamp", last_updated_timestamp().ToTimeT());
   value->SetBoolean("sendTabToSelfReceivingEnabled",
                     send_tab_to_self_receiving_enabled());
   return value;

components/sync_device_info/device_info.h

@@ -10,6 +10,7 @@
 
 #include "base/callback.h"
 #include "base/macros.h"
+#include "base/time/time.h"
 #include "components/sync/protocol/sync.pb.h"
 
 namespace base {
@@ -27,6 +28,7 @@ class DeviceInfo {
              const std::string& sync_user_agent,
              const sync_pb::SyncEnums::DeviceType device_type,
              const std::string& signin_scoped_device_id,
+             base::Time last_updated_timestamp,
              bool send_tab_to_self_receiving_enabled);
   ~DeviceInfo();
 
@@ -57,6 +59,9 @@ class DeviceInfo {
   // annotating login scoped refresh token.
   const std::string& signin_scoped_device_id() const;
 
+  // Returns the time at which this device was last updated to the sync servers.
+  base::Time last_updated_timestamp() const;
+
   // Whether the receiving side of the SendTabToSelf feature is enabled.
   bool send_tab_to_self_receiving_enabled() const;
 
@@ -100,6 +105,8 @@ class DeviceInfo {
   // and they are also reset when app/extension is uninstalled.
   std::string public_id_;
 
+  const base::Time last_updated_timestamp_;
+
   bool send_tab_to_self_receiving_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceInfo);

components/sync_device_info/device_info_sync_bridge.cc

@@ -58,6 +58,7 @@ std::unique_ptr<DeviceInfo> SpecificsToModel(
       specifics.cache_guid(), specifics.client_name(),
       specifics.chrome_version(), specifics.sync_user_agent(),
       specifics.device_type(), specifics.signin_scoped_device_id(),
+      ProtoTimeToTime(specifics.last_updated_timestamp()),
       specifics.feature_fields().send_tab_to_self_receiving_enabled());
 }
 
@@ -70,12 +71,9 @@ std::unique_ptr<EntityData> CopyToEntityData(
   return entity_data;
 }
 
-// Converts DeviceInfo into a freshly allocated DeviceInfoSpecifics. Takes
-// |last_updated_timestamp| to set because the model object does not contain
-// this concept.
-std::unique_ptr<DeviceInfoSpecifics> ModelToSpecifics(
-    const DeviceInfo& info,
-    int64_t last_updated_timestamp) {
+// Converts a local DeviceInfo into a freshly allocated DeviceInfoSpecifics.
+std::unique_ptr<DeviceInfoSpecifics> MakeLocalDeviceSpecifics(
+    const DeviceInfo& info) {
   auto specifics = std::make_unique<DeviceInfoSpecifics>();
   specifics->set_cache_guid(info.guid());
   specifics->set_client_name(info.client_name());
@@ -83,7 +81,10 @@ std::unique_ptr<DeviceInfoSpecifics> ModelToSpecifics(
   specifics->set_sync_user_agent(info.sync_user_agent());
   specifics->set_device_type(info.device_type());
   specifics->set_signin_scoped_device_id(info.signin_scoped_device_id());
-  specifics->set_last_updated_timestamp(last_updated_timestamp);
+  // The local device should have not been updated yet. Set the last updated
+  // timestamp to now.
+  DCHECK(info.last_updated_timestamp() == base::Time());
+  specifics->set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
 
   FeatureSpecificFields* feature_fields = specifics->mutable_feature_fields();
   feature_fields->set_send_tab_to_self_receiving_enabled(
@@ -471,9 +472,8 @@ void DeviceInfoSyncBridge::SendLocalDataWithBatch(
   DCHECK(local_device_info_provider_->GetLocalDeviceInfo());
   DCHECK(change_processor()->IsTrackingMetadata());
 
-  std::unique_ptr<DeviceInfoSpecifics> specifics =
-      ModelToSpecifics(*local_device_info_provider_->GetLocalDeviceInfo(),
-                       TimeToProtoTime(Time::Now()));
+  std::unique_ptr<DeviceInfoSpecifics> specifics = MakeLocalDeviceSpecifics(
+      *local_device_info_provider_->GetLocalDeviceInfo());
   change_processor()->Put(specifics->cache_guid(), CopyToEntityData(*specifics),
                           batch->GetMetadataChangeList());
   StoreSpecifics(std::move(specifics), batch.get());

components/sync_device_info/device_info_sync_bridge_unittest.cc

@@ -190,7 +190,7 @@ class TestLocalDeviceInfoProvider : public MutableLocalDeviceInfoProvider {
         cache_guid, session_name, ChromeVersionForSuffix(kLocalSuffix),
         SyncUserAgentForSuffix(kLocalSuffix),
         sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
-        SigninScopedDeviceIdForSuffix(kLocalSuffix), true);
+        SigninScopedDeviceIdForSuffix(kLocalSuffix), base::Time(), true);
   }
 
   void Clear() override { local_device_info_.reset(); }

components/sync_device_info/local_device_info_provider_impl.cc

@@ -61,9 +61,12 @@ void LocalDeviceInfoProviderImpl::Initialize(const std::string& cache_guid,
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!cache_guid.empty());
 
+  // The local device doesn't have a last updated timestamps. It will be set in
+  // the specifics when it will be synced up.
   local_device_info_ = std::make_unique<DeviceInfo>(
       cache_guid, session_name, version_, MakeUserAgentForSync(channel_),
       GetLocalDeviceType(), signin_scoped_device_id_callback_.Run(),
+      /*last_updated_timestamp=*/base::Time(),
       send_tab_to_self_receiving_enabled_callback_.Run());
 
   // Notify observers.