Make ProfileSyncService a client of memory coordinator

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/browser_sync/browser_sync_switches.h"
@@ skipping 203 matching lines @@
   std::string last_version = sync_prefs_.GetLastRunVersion();
   std::string current_version = PRODUCT_VERSION;
   sync_prefs_.SetLastRunVersion(current_version);
 
   // Check for a major version change. Note that the versions have format
   // MAJOR.MINOR.BUILD.PATCH.
   if (last_version.substr(0, last_version.find('.')) !=
       current_version.substr(0, current_version.find('.'))) {
     passphrase_prompt_triggered_by_version_ = true;
   }
+
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }
 
 ProfileSyncService::~ProfileSyncService() {
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
   sync_prefs_.RemoveSyncPrefObserver(this);
   // Shutdown() should have been called before destruction.
   CHECK(!backend_initialized_);
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
 }
 
 bool ProfileSyncService::CanSyncStart() const {
   return IsSyncAllowed() && IsSyncRequested() && IsSignedIn();
 }
 
 void ProfileSyncService::Initialize() {
   sync_client_->Initialize();
 
   // We don't pass StartupController an Unretained reference to future-proof
@@ skipping 2178 matching lines @@
   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_.SetMemoryPressureWarningCount(
-        sync_prefs_.GetMemoryPressureWarningCount() + 1);
+    IncrementMemoryPressureWarningCount();
   }
 }
 
+void ProfileSyncService::OnMemoryStateChange(base::MemoryState state) {
+  // TODO(hajimehoshi): Adjust the size of this memory usage according to
+  // |state|. ProfileSyncService doesn't have a feature to limit memory usage at
+  // present.
+  switch (state) {
+    case base::MemoryState::NORMAL:
+      break;
+    case base::MemoryState::THROTTLED:
+      IncrementMemoryPressureWarningCount();
+      break;
+    case base::MemoryState::SUSPENDED:
+      // Note: Not supported at present. Fall through.
+    case base::MemoryState::UNKNOWN:
+      NOTREACHED();
+      break;
+  }
+}
+
+void ProfileSyncService::IncrementMemoryPressureWarningCount() {
+  sync_prefs_.SetMemoryPressureWarningCount(
+      sync_prefs_.GetMemoryPressureWarningCount() + 1);

[bashi, 2016/10/03 23:26:53]

Do we use the warning count to change behavior of ProfileSyncService or other
classes? In other words, is this purely for calculating statistics? If so,
Making ProfileSyncService be a MCC wouldn't make much sense IMO. Maybe we just
leave this MPL and remove later.

+}
+
 void ProfileSyncService::ReportPreviousSessionMemoryWarningCount() {
   int warning_received = sync_prefs_.GetMemoryPressureWarningCount();
 
   if (-1 != warning_received) {
     // -1 means it is new client.
     if (!sync_prefs_.DidSyncShutdownCleanly()) {
       UMA_HISTOGRAM_COUNTS("Sync.MemoryPressureWarningBeforeUncleanShutdown",
                            warning_received);
     } else {
       UMA_HISTOGRAM_COUNTS("Sync.MemoryPressureWarningBeforeCleanShutdown",
@@ skipping 28 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync