Make SdchOwner a client of memory coordinator

net/sdch/sdch_owner.cc

 // Copyright 2014 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 "net/sdch/sdch_owner.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/sdch_net_log_params.h"
 #include "net/log/net_log_event_type.h"
 
 namespace net {
@@ skipping 280 matching lines @@
                      // Because |memory_pressure_listener_| is owned by
                      // SdchOwner, the SdchOwner object will be available
                      // for the lifetime of |memory_pressure_listener_|.
                      base::Unretained(this))),
       in_memory_pref_store_(new ValueMapPrefStorage()),
       external_pref_store_(nullptr),
       pref_store_(in_memory_pref_store_.get()),
       creation_time_(clock_->Now()) {
   manager_->AddObserver(this);
   InitializePrefStore(pref_store_);
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }
 
 SdchOwner::~SdchOwner() {
   for (DictionaryPreferenceIterator it(pref_store_); !it.IsAtEnd();
        it.Advance()) {
     int new_uses = it.use_count() - use_counts_at_load_[it.server_hash()];
     DictionaryFate fate = IsPersistingDictionaries() ?
                           DICTIONARY_FATE_UNLOAD_FOR_DESTRUCTION :
                           DICTIONARY_FATE_EVICT_FOR_DESTRUCTION;
     RecordDictionaryEvictionOrUnload(it.server_hash(), it.size(), new_uses,
                                      fate);
   }
   manager_->RemoveObserver(this);
 
   // This object only observes the external store during loading,
   // i.e. before it's made the default preferences store.
   if (external_pref_store_ && pref_store_ != external_pref_store_.get())
     external_pref_store_->StopObservingInit();
 
   int64_t object_lifetime = (clock_->Now() - creation_time_).InMilliseconds();
   for (const auto& val : consumed_byte_seconds_) {
     if (object_lifetime > 0) {
       // Objects that are created and immediately destroyed don't add any memory
       // pressure over time (and also cause a crash here).
       UMA_HISTOGRAM_MEMORY_KB("Sdch3.TimeWeightedMemoryUse",
                               val / object_lifetime);
     }
   }
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
 }
 
 void SdchOwner::EnablePersistentStorage(
     std::unique_ptr<PrefStorage> pref_store) {
   DCHECK(!external_pref_store_);
   DCHECK(pref_store);
   external_pref_store_ = std::move(pref_store);
   external_pref_store_->StartObservingInit(this);
 
   if (external_pref_store_->IsInitializationComplete())
@@ skipping 315 matching lines @@
 }
 
 void SdchOwner::SetFetcherForTesting(
     std::unique_ptr<SdchDictionaryFetcher> fetcher) {
   fetcher_ = std::move(fetcher);
 }
 
 void SdchOwner::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel level) {
   DCHECK_NE(base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE, level);
+  ClearData();
+}
 
+void SdchOwner::OnMemoryStateChange(base::MemoryState state) {
+  // TODO(hajimehoshi): When the state changes, adjust the sizes of the caches
+  // to reduce the limits. SdchOwner doesn't have the ability to limit at
+  // present.
+  switch (state) {
+    case base::MemoryState::NORMAL:
+      break;
+    case base::MemoryState::THROTTLED:
+      ClearData();
+      break;
+    case base::MemoryState::SUSPENDED:
+    // Note: Not supported at present. Fall through.
+    case base::MemoryState::UNKNOWN:
+      NOTREACHED();
+      break;
+  }
+}
+
+void SdchOwner::ClearData() {
   for (DictionaryPreferenceIterator it(pref_store_); !it.IsAtEnd();
        it.Advance()) {
     int new_uses = it.use_count() - use_counts_at_load_[it.server_hash()];
     RecordDictionaryEvictionOrUnload(it.server_hash(),
                                      it.size(),
                                      new_uses,
                                      DICTIONARY_FATE_EVICT_FOR_MEMORY);
   }
 
   // TODO(rdsmith): Make a distinction between moderate and critical
@@ skipping 52 matching lines @@
   }
 
   return true;
 }
 
 bool SdchOwner::IsPersistingDictionaries() const {
   return in_memory_pref_store_.get() != nullptr;
 }
 
 }  // namespace net