[Sync] Add histogram for events in ClearServerData flow.

components/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 "components/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 97 matching lines @@
 using syncer::ModelTypeSet;
 using syncer::ModelTypeStore;
 using syncer::ProtocolEventObserver;
 using syncer::SyncEngine;
 using syncer::SyncCredentials;
 using syncer::SyncProtocolError;
 using syncer::WeakHandle;
 
 namespace browser_sync {
 
+namespace {
+
 typedef GoogleServiceAuthError AuthError;
 
+// Events in ClearServerData flow to be recorded in histogram. Existing
+// constants should not be deleted or reordered. New ones shold be added at the
+// end, before CLEAR_SERVER_DATA_MAX.
+enum ClearServerDataEvents {
+  // ClearServerData started after user switched to custom passphrase.
+  CLEAR_SERVER_DATA_STARTED,
+  // DataTypeManager reported that catchup configuration failed.
+  CLEAR_SERVER_DATA_CATCHUP_FAILED,
+  // ClearServerData flow restarted after browser restart.
+  CLEAR_SERVER_DATA_RETRIED,
+  // Success.
+  CLEAR_SERVER_DATA_SUCCEEDED,
+  // Client received RECET_LOCAL_SYNC_DATA after custom passphrase was enabled
+  // on different client.
+  CLEAR_SERVER_DATA_RESET_LOCAL_DATA_RECEIVED,
+  CLEAR_SERVER_DATA_MAX
+};
+
+const char kClearServerDataEventsHistogramName[] = "Sync.ClearServerDataEvents";
+
 const char kSyncUnrecoverableErrorHistogram[] = "Sync.UnrecoverableErrors";
 
 const net::BackoffEntry::Policy kRequestAccessTokenBackoffPolicy = {
     // Number of initial errors (in sequence) to ignore before applying
     // exponential back-off rules.
     0,
 
     // Initial delay for exponential back-off in ms.
     2000,
 
@@ skipping 10 matching lines @@
     1000 * 3600 * 4,  // 4 hours.
 
     // Time to keep an entry from being discarded even when it
     // has no significant state, -1 to never discard.
     -1,
 
     // Don't use initial delay unless the last request was an error.
     false,
 };
 
-static const base::FilePath::CharType kSyncDataFolderName[] =
+const base::FilePath::CharType kSyncDataFolderName[] =
     FILE_PATH_LITERAL("Sync Data");
-static const base::FilePath::CharType kLevelDBFolderName[] =
+const base::FilePath::CharType kLevelDBFolderName[] =
     FILE_PATH_LITERAL("LevelDB");
 
 #if defined(OS_WIN)
-static const base::FilePath::CharType kLoopbackServerBackendFilename[] =
+const base::FilePath::CharType kLoopbackServerBackendFilename[] =
     FILE_PATH_LITERAL("profile.pb");
 #endif
 
-namespace {
-
 // Perform the actual sync data folder deletion.
 // This should only be called on the sync thread.
 void DeleteSyncDataFolder(const base::FilePath& directory_path) {
   if (base::DirectoryExists(directory_path)) {
     if (!base::DeleteFile(directory_path, true))
       LOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 }  // namespace
@@ skipping 208 matching lines @@
     startup_controller_->TryStartImmediately();
   } else {
     startup_controller_->TryStart();
   }
 }
 
 void ProfileSyncService::StartSyncingWithServer() {
   if (base::FeatureList::IsEnabled(
           switches::kSyncClearDataOnPassphraseEncryption) &&
       sync_prefs_.GetPassphraseEncryptionTransitionInProgress()) {
+    // We are restarting catchup configuration after browser restart.
+    UMA_HISTOGRAM_ENUMERATION(kClearServerDataEventsHistogramName,
+                              CLEAR_SERVER_DATA_RETRIED, CLEAR_SERVER_DATA_MAX);
+
     BeginConfigureCatchUpBeforeClear();
     return;
   }
 
   if (engine_)
     engine_->StartSyncingWithServer();
 }
 
 void ProfileSyncService::RegisterAuthNotifications() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 895 matching lines @@
       break;
     case syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT:
       // Sync disabled by domain admin. we should stop syncing until next
       // restart.
       sync_disabled_by_admin_ = true;
       ShutdownImpl(syncer::DISABLE_SYNC);
       break;
     case syncer::RESET_LOCAL_SYNC_DATA:
       ShutdownImpl(syncer::DISABLE_SYNC);
       startup_controller_->TryStart();
+      UMA_HISTOGRAM_ENUMERATION(kClearServerDataEventsHistogramName,
+                                CLEAR_SERVER_DATA_RESET_LOCAL_DATA_RECEIVED,
+                                CLEAR_SERVER_DATA_MAX);
       break;
     default:
       NOTREACHED();
   }
   NotifyObservers();
 }
 
 void ProfileSyncService::OnLocalSetPassphraseEncryption(
     const syncer::SyncEncryptionHandler::NigoriState& nigori_state) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!base::FeatureList::IsEnabled(
           switches::kSyncClearDataOnPassphraseEncryption))
     return;
 
   // At this point the user has set a custom passphrase and we have received the
   // updated nigori state. Time to cache the nigori state, and catch up the
   // active data types.
+  UMA_HISTOGRAM_ENUMERATION(kClearServerDataEventsHistogramName,
+                            CLEAR_SERVER_DATA_STARTED, CLEAR_SERVER_DATA_MAX);
   sync_prefs_.SetNigoriSpecificsForPassphraseTransition(
       nigori_state.nigori_specifics);
   sync_prefs_.SetPassphraseEncryptionTransitionInProgress(true);
   BeginConfigureCatchUpBeforeClear();
 }
 
 void ProfileSyncService::BeginConfigureCatchUpBeforeClear() {
   DCHECK(data_type_manager_);
   DCHECK(!saved_nigori_state_);
   saved_nigori_state_ =
@@ skipping 17 matching lines @@
   sync_prefs_.SetPassphraseEncryptionTransitionInProgress(false);
 
   // Call to ClearServerData generates new keystore key on the server. This
   // makes keystore bootstrap token invalid. Let's clear it from preferences.
   sync_prefs_.SetKeystoreEncryptionBootstrapToken(std::string());
 
   // Shutdown sync, delete the Directory, then restart, restoring the cached
   // nigori state.
   ShutdownImpl(syncer::DISABLE_SYNC);
   startup_controller_->TryStart();
+  UMA_HISTOGRAM_ENUMERATION(kClearServerDataEventsHistogramName,
+                            CLEAR_SERVER_DATA_SUCCEEDED, CLEAR_SERVER_DATA_MAX);
 }
 
 void ProfileSyncService::OnConfigureDone(
     const DataTypeManager::ConfigureResult& result) {
   DCHECK(thread_checker_.CalledOnValidThread());
   configure_status_ = result.status;
   data_type_status_table_ = result.data_type_status_table;
 
   // We should have cleared our cached passphrase before we get here (in
   // OnEngineInitialized()).
   DCHECK(cached_passphrase_.empty());
 
   if (!sync_configure_start_time_.is_null()) {
-    if (result.status == DataTypeManager::OK) {
+    if (configure_status_ == DataTypeManager::OK) {
       base::Time sync_configure_stop_time = base::Time::Now();
       base::TimeDelta delta =
           sync_configure_stop_time - sync_configure_start_time_;
       if (is_first_time_sync_configure_) {
         UMA_HISTOGRAM_LONG_TIMES("Sync.ServiceInitialConfigureTime", delta);
       } else {
         UMA_HISTOGRAM_LONG_TIMES("Sync.ServiceSubsequentConfigureTime", delta);
       }
     }
     sync_configure_start_time_ = base::Time();
@@ skipping 13 matching lines @@
   // First handle the abort case.
   if (configure_status_ == DataTypeManager::ABORTED &&
       expect_sync_configuration_aborted_) {
     DVLOG(0) << "ProfileSyncService::Observe Sync Configure aborted";
     expect_sync_configuration_aborted_ = false;
     return;
   }
 
   // Handle unrecoverable error.
   if (configure_status_ != DataTypeManager::OK) {
+    if (catch_up_configure_in_progress_) {
+      // Record catchup configuration failure.
+      UMA_HISTOGRAM_ENUMERATION(kClearServerDataEventsHistogramName,
+                                CLEAR_SERVER_DATA_CATCHUP_FAILED,
+                                CLEAR_SERVER_DATA_MAX);
+    }
     // Something catastrophic had happened. We should only have one
     // error representing it.
     syncer::SyncError error = data_type_status_table_.GetUnrecoverableError();
     DCHECK(error.IsSet());
     std::string message =
         "Sync configuration failed with status " +
         DataTypeManager::ConfigureStatusToString(configure_status_) +
         " caused by " +
         syncer::ModelTypeSetToString(
             data_type_status_table_.GetUnrecoverableErrorTypes()) +
@@ skipping 1224 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsEngineInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync