SdchObserver: add OnDictionary{Added,Removed}

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 "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 466 matching lines @@
   dictionary_description->SetString(kDictionaryUrlKey, dictionary_url.spec());
   dictionary_description->SetDouble(kDictionaryLastUsedKey,
                                     last_used.ToDoubleT());
   dictionary_description->SetInteger(kDictionaryUseCountKey, use_count);
   dictionary_description->SetInteger(kDictionarySizeKey,
                                      dictionary_text.size());
   pref_dictionary_map->Set(server_hash, dictionary_description.Pass());
   load_times_[server_hash] = clock_->Now();
 }
 
-void SdchOwner::OnDictionaryUsed(SdchManager* manager,
-                                 const std::string& server_hash) {
+void SdchOwner::OnDictionaryAdded(const GURL& dictionary_url,
+                                  const std::string& server_hash) { }
+
+void SdchOwner::OnDictionaryRemoved(const std::string& server_hash) { }
+
+void SdchOwner::OnDictionaryUsed(const std::string& server_hash) {
   base::Time now(clock_->Now());
   base::DictionaryValue* pref_dictionary_map =
       GetPersistentStoreDictionaryMap(pref_store_);
   ScopedPrefNotifier scoped_pref_notifier(pref_store_);
 
   base::Value* value = nullptr;
   bool success = pref_dictionary_map->Get(server_hash, &value);
   if (!success) {
     // SdchManager::GetDictionarySet() pins the referenced dictionaries in
     // memory past a possible deletion.  For this reason, OnDictionaryUsed()
@@ skipping 32 matching lines @@
   // touched for 48 hours".
   UMA_HISTOGRAM_CUSTOM_TIMES(
       "Sdch3.UsageInterval",
       use_count ? time_since_last_used : base::TimeDelta::FromHours(48),
       base::TimeDelta(), base::TimeDelta::FromHours(48), 50);
 
   specific_dictionary_map->SetDouble(kDictionaryLastUsedKey, now.ToDoubleT());
   specific_dictionary_map->SetInteger(kDictionaryUseCountKey, use_count + 1);
 }
 
-void SdchOwner::OnGetDictionary(SdchManager* manager,
-                                const GURL& request_url,
+void SdchOwner::OnGetDictionary(const GURL& request_url,
                                 const GURL& dictionary_url) {
 #if defined(OS_CHROMEOS)
   // For debugging http://crbug.com/454198; remove when resolved.
   char url_buf[128];
   if (0u != destroyed_ || !clock_.get()) {
     base::strlcpy(url_buf, request_url.spec().c_str(), arraysize(url_buf));
   }
   base::debug::Alias(url_buf);
 
   CHECK_EQ(0u, destroyed_);
@@ skipping 21 matching lines @@
     // because SdchManager is layered underneath URLRequest.
     return;
   }
 
   fetcher_->Schedule(dictionary_url,
                      base::Bind(&SdchOwner::OnDictionaryFetched,
                                 // SdchOwner will outlive its member variables.
                                 base::Unretained(this), base::Time(), 0));
 }
 
-void SdchOwner::OnClearDictionaries(SdchManager* manager) {
+void SdchOwner::OnClearDictionaries() {
   total_dictionary_bytes_ = 0;
   fetcher_->Cancel();
 
   InitializePrefStore(pref_store_);
 }
 
 void SdchOwner::OnPrefValueChanged(const std::string& key) {
 }
 
 void SdchOwner::OnInitializationCompleted(bool succeeded) {
@@ skipping 177 matching lines @@
   }
 
   return true;
 }
 
 bool SdchOwner::IsPersistingDictionaries() const {
   return in_memory_pref_store_.get() != nullptr;
 }
 
 }  // namespace net