Add UMA data for memory pressure warning received for sync

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 <vector>
 
@@ skipping 347 matching lines @@
   }
 
 #if defined(ENABLE_PRE_SYNC_BACKUP)
   if (!running_rollback && signin_->GetAccountIdToUse().empty()) {
     CleanUpBackup();
   }
 #else
   DCHECK(!running_rollback);
 #endif
 
+  memory_pressure_listener_.reset(new base::MemoryPressureListener(base::Bind(
+      &ProfileSyncService::OnMemoryPressure, weak_factory_.GetWeakPtr())));
   startup_controller_->Reset(GetRegisteredDataTypes());
   startup_controller_->TryStart();
 }
 
 void ProfileSyncService::TrySyncDatatypePrefRecovery() {
   DCHECK(!backend_initialized());
   if (!HasSyncSetupCompleted())
     return;
 
   // There was a bug where OnUserChoseDatatypes was not properly called on
@@ skipping 317 matching lines @@
           invalidator,
           sync_prefs_.AsWeakPtr(),
           sync_folder));
 
   // Initialize the backend.  Every time we start up a new SyncBackendHost,
   // we'll want to start from a fresh SyncDB, so delete any old one that might
   // be there.
   InitializeBackend(ShouldDeleteSyncFolder());
 
   UpdateFirstSyncTimePref();
+
+  CheckPreviousShutdownMemoryWarning();
 }
 
 void ProfileSyncService::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK_EQ(access_token_request_, request);
   access_token_request_.reset();
   access_token_ = access_token;
   token_receive_time_ = base::Time::Now();
@@ skipping 190 matching lines @@
   encryption_pending_ = false;
   encrypt_everything_ = false;
   encrypted_types_ = syncer::SyncEncryptionHandler::SensitiveTypes();
   passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
   request_access_token_retry_timer_.Stop();
   // Revert to "no auth error".
   if (last_auth_error_.state() != GoogleServiceAuthError::NONE)
     UpdateAuthErrorState(GoogleServiceAuthError::AuthErrorNone());
 
   NotifyObservers();
+
+  sync_prefs_.SetCurrentShutdown(false);
 }
 
 void ProfileSyncService::DisableForUser() {
   // Clear prefs (including SyncSetupHasCompleted) before shutting down so
   // PSS clients don't think we're set up while we're shutting down.
   sync_prefs_.ClearPreferences();
   ClearUnrecoverableError();
   ShutdownImpl(syncer::DISABLE_SYNC);
 }
 
@@ skipping 1788 matching lines @@
   std::string birthday;
   syncer::UserShare* user_share = GetUserShare();
   if (user_share && user_share->directory.get()) {
     birthday = user_share->directory->store_birthday();
   }
   if (!access_token_.empty() && !cache_guid.empty() && !birthday.empty()) {
     sync_stopped_reporter_->ReportSyncStopped(
         access_token_, cache_guid, birthday);
   }
 }
+
+void ProfileSyncService::OnMemoryPressure(
+    base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  if (memory_pressure_level ==
+      base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
+    sync_prefs_.SetMemoryPressure(sync_prefs_.GetMemoryPressure() + 1);
+  }
+}
+
+void ProfileSyncService::CheckPreviousShutdownMemoryWarning() {
+  int warning_received = sync_prefs_.GetMemoryPressure();
+
+  if (-1 != warning_received) {
+    // -1 means it is new client
+    if (sync_prefs_.IsPreviousCrashed()) {
+      UMA_HISTOGRAM_COUNTS("Sync.MemoryPressureWarningBeforeCrash",
+                           warning_received);
+    } else {
+      UMA_HISTOGRAM_COUNTS("Sync.MemoryPressureWarningwithoutCrash",
+                           warning_received);
+    }
+  }
+  sync_prefs_.SetMemoryPressure(0);
+  sync_prefs_.SetCurrentShutdown(true);
+}