Make HistoryBackend a client of memory coordinator

components/history/core/browser/history_backend.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/history/core/browser/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
@@ skipping 21 matching lines @@
 #include "components/history/core/browser/history_backend_observer.h"
 #include "components/history/core/browser/history_constants.h"
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/in_memory_history_backend.h"
 #include "components/history/core/browser/keyword_search_term.h"
 #include "components/history/core/browser/page_usage_data.h"
 #include "components/history/core/browser/typed_url_syncable_service.h"
 #include "components/history/core/browser/url_utils.h"
+#include "components/memory_coordinator/browser/memory_coordinator.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "sql/error_delegate_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "url/gurl.h"
 #include "url/url_constants.h"
 
 #if defined(OS_IOS)
 #include "base/ios/scoped_critical_action.h"
 #endif
@@ skipping 175 matching lines @@
   // First close the databases before optionally running the "destroy" task.
   CloseAllDatabases();
 
   if (!backend_destroy_task_.is_null()) {
     // Notify an interested party (typically a unit test) that we're done.
     DCHECK(backend_destroy_message_loop_);
     backend_destroy_message_loop_->task_runner()->PostTask(
         FROM_HERE, backend_destroy_task_);
   }
 
+  if (memory_coordinator::MemoryCoordinator::GetInstance()) {
+    memory_coordinator::MemoryCoordinator::GetInstance()->UnregisterClient(
+        this);
+  }
+
 #if defined(OS_ANDROID)
   if (backend_client_ && !history_dir_.empty())
     backend_client_->OnHistoryBackendDestroyed(this, history_dir_);
 #endif
 }
 
 void HistoryBackend::Init(
     bool force_fail,
     const HistoryDatabaseParams& history_database_params) {
   // HistoryBackend is created on the UI thread by HistoryService, then the
   // HistoryBackend::Init() method is called on the DB thread. Create the
   // base::SupportsUserData on the DB thread since it is not thread-safe.
   supports_user_data_helper_.reset(new HistoryBackendHelper);
 
   if (!force_fail)
     InitImpl(history_database_params);
   delegate_->DBLoaded();
   typed_url_syncable_service_.reset(new TypedUrlSyncableService(this));
-  memory_pressure_listener_.reset(new base::MemoryPressureListener(
-      base::Bind(&HistoryBackend::OnMemoryPressure, base::Unretained(this))));
+  if (memory_coordinator::MemoryCoordinator::GetInstance()) {
+    memory_coordinator::MemoryCoordinator::GetInstance()->RegisterClient(this);
+  } else {
+    memory_pressure_listener_.reset(new base::MemoryPressureListener(
+        base::Bind(&HistoryBackend::OnMemoryPressure, base::Unretained(this))));
+  }
 }
 
 void HistoryBackend::SetOnBackendDestroyTask(base::MessageLoop* message_loop,
                                              const base::Closure& task) {
   if (!backend_destroy_task_.is_null())
     DLOG(WARNING) << "Setting more than one destroy task, overriding";
   backend_destroy_message_loop_ = message_loop;
   backend_destroy_task_ = task;
 }
 
@@ skipping 463 matching lines @@
 #if defined(OS_ANDROID)
   if (backend_client_) {
     backend_client_->OnHistoryBackendInitialized(
         this, db_.get(), thumbnail_db_.get(), history_dir_);
   }
 #endif
 
   LOCAL_HISTOGRAM_TIMES("History.InitTime", TimeTicks::Now() - beginning_time);
 }
 
+void HistoryBackend::TrimMemory(bool trim_aggressively) {
+  if (db_)
+    db_->TrimMemory(trim_aggressively);
+  if (thumbnail_db_)
+    thumbnail_db_->TrimMemory(trim_aggressively);
+}
+
 void HistoryBackend::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   bool trim_aggressively =
       memory_pressure_level ==
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
-  if (db_)
-    db_->TrimMemory(trim_aggressively);
-  if (thumbnail_db_)
-    thumbnail_db_->TrimMemory(trim_aggressively);
+  TrimMemory(trim_aggressively);
 }
 
 void HistoryBackend::CloseAllDatabases() {
   if (db_) {
     // Commit the long-running transaction.
     db_->CommitTransaction();
     db_.reset();
     // Forget the first recorded time since the database is closed.
     first_recorded_time_ = base::Time();
   }
@@ skipping 139 matching lines @@
   // TODO(brettw) bug 1140015: Add an "add page" notification so the history
   // views can keep in sync.
   NotifyURLsModified(changed_urls);
   ScheduleCommit();
 }
 
 bool HistoryBackend::IsExpiredVisitTime(const base::Time& time) {
   return time < expirer_.GetCurrentExpirationTime();
 }
 
+void HistoryBackend::OnMemoryStateChange(
+    memory_coordinator::MemoryState state) {
+  bool trim_aggressively = state == memory_coordinator::MemoryState::SUSPENDED;
+  TrimMemory(trim_aggressively);
+}
+
 void HistoryBackend::SetPageTitle(const GURL& url,
                                   const base::string16& title) {
   if (!db_)
     return;
 
   // Search for recent redirects which should get the same title. We make a
   // dummy list containing the exact URL visited if there are no redirects so
   // the processing below can be the same.
   RedirectList dummy_list;
   RedirectList* redirects;
@@ skipping 1711 matching lines @@
   // transaction is currently open.
   db_->CommitTransaction();
   db_->Vacuum();
   db_->BeginTransaction();
   db_->GetStartDate(&first_recorded_time_);
 
   return true;
 }
 
 }  // namespace history