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

chrome/browser/sync/profile_sync_service.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/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 69 matching lines @@
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "sync/api/sync_error.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/http_bridge_network_resources.h"
 #include "sync/internal_api/public/network_resources.h"
 #include "sync/internal_api/public/sessions/type_debug_info_observer.h"
 #include "sync/internal_api/public/sync_core_proxy.h"
 #include "sync/internal_api/public/sync_encryption_handler.h"
 #include "sync/internal_api/public/util/experiments.h"
+#include "sync/internal_api/public/util/sync_db_util.h"
 #include "sync/internal_api/public/util/sync_string_conversions.h"
 #include "sync/js/js_event_details.h"
 #include "sync/util/cryptographer.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 
 #if defined(OS_ANDROID)
 #include "sync/internal_api/public/read_transaction.h"
 #endif
 
@@ skipping 573 matching lines @@
 
   DVLOG(1) << "Start backend mode: " << mode;
 
   if (backend_)
     ShutdownImpl(browser_sync::SyncBackendHost::STOP_AND_CLAIM_THREAD);
 
   backend_mode_ = mode;
 
   if (backend_mode_ == ROLLBACK)
     ClearBrowsingDataSinceFirstSync();
+  else if (backend_mode_ == SYNC)
+    CheckSyncBackupIfNeeded();
 
   base::FilePath sync_folder = backend_mode_ == SYNC ?
       base::FilePath(kSyncDataFolderName) :
       base::FilePath(kSyncBackupDataFolderName);
 
   invalidation::InvalidationService* invalidator = backend_mode_ == SYNC ?
       invalidation::InvalidationServiceFactory::GetForProfile(profile_) :
       NULL;
 
   backend_.reset(
@@ skipping 321 matching lines @@
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeFirstTime", delta);
   } else {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeRestoreTime", delta);
   }
 }
 
 void ProfileSyncService::PostBackendInitialization() {
   // Never get here for backup / restore.
   DCHECK_EQ(backend_mode_, SYNC);
 
+  if (last_backup_time_) {
+    browser_sync::SyncedDeviceTracker* device_tracker =
+        backend_->GetSyncedDeviceTracker();
+    if (device_tracker)
+      device_tracker->UpdateLocalDeviceBackupTime(*last_backup_time_);
+  }
+
   if (protocol_event_observers_.might_have_observers()) {
     backend_->RequestBufferedProtocolEventsAndEnableForwarding();
   }
 
   non_blocking_data_type_manager_.ConnectSyncBackend(
       backend_->GetSyncCoreProxy());
 
   if (type_debug_info_observers_.might_have_observers()) {
     backend_->EnableDirectoryTypeDebugInfoForwarding();
   }
@@ skipping 1512 matching lines @@
   if (first_sync_time.is_null())
     return;
 
   clear_browsing_data_.Run(profile_, first_sync_time, base::Time::Now());
 }
 
 void ProfileSyncService::SetClearingBrowseringDataForTesting(
     base::Callback<void(Profile*, base::Time, base::Time)> c) {
   clear_browsing_data_ = c;
 }
+
+void ProfileSyncService::CheckSyncBackupIfNeeded() {
+  DCHECK_EQ(backend_mode_, SYNC);
+
+#if defined(OS_WIN) || defined(OS_MACOSX) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
+  // Check backup once a day.
+  if (last_synced_time_.is_null() ||
+      base::Time::Now() - last_synced_time_ >= base::TimeDelta::FromDays(1)) {
+    // If sync thread is set, need to serialize check on sync thread after
+    // closing backup DB.
+    base::TaskRunner* check_task_runner = sync_thread_ ?
+        sync_thread_->message_loop_proxy().get() :
+        profile_->GetIOTaskRunner().get();
+    check_task_runner->PostTask(
+        FROM_HERE,
+        base::Bind(syncer::CheckSyncDbLastModifiedTime,
+                   profile_->GetPath().Append(kSyncBackupDataFolderName),
+                   base::MessageLoopProxy::current(),
+                   base::Bind(&ProfileSyncService::CheckSyncBackupCallback,
+                              weak_factory_.GetWeakPtr())));
+  }
+#endif
+}
+
+void ProfileSyncService::CheckSyncBackupCallback(base::Time backup_time) {
+  last_backup_time_.reset(new base::Time(backup_time));
+
+  if (HasSyncingBackend()) {
+    browser_sync::SyncedDeviceTracker* device_tracker =
+        backend_->GetSyncedDeviceTracker();
+    if (device_tracker)
+      device_tracker->UpdateLocalDeviceBackupTime(*last_backup_time_);
+  }
+}
+
+base::Time ProfileSyncService::GetDeviceBackupTimeForTesting() const {
+  return backend_->GetSyncedDeviceTracker()->GetLocalDeviceBackupTime();
+}