Instrument SdchOwner for clock nullification.

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/metrics/histogram_macros.h"
 #include "base/time/default_clock.h"
 #include "net/base/sdch_manager.h"
@@ skipping 68 matching lines @@
       fetcher_(context,
                base::Bind(&SdchOwner::OnDictionaryFetched,
                           // Because |fetcher_| is owned by SdchOwner, the
                           // SdchOwner object will be available for the lifetime
                           // of |fetcher_|.
                           base::Unretained(this))),
       total_dictionary_bytes_(0),
       clock_(new base::DefaultClock),
       max_total_dictionary_size_(kMaxTotalDictionarySize),
       min_space_for_dictionary_fetch_(kMinSpaceForDictionaryFetch),
+#if defined(OS_CHROMEOS)
+      // For debugging http://crbug.com/454198; remove when resolved.
+      destroyed_(0),
+#endif
       memory_pressure_listener_(
           base::Bind(&SdchOwner::OnMemoryPressure,
                      // Because |memory_pressure_listener_| is owned by
                      // SdchOwner, the SdchOwner object will be available
                      // for the lifetime of |memory_pressure_listener_|.
                      base::Unretained(this))) {
+#if defined(OS_CHROMEOS)
+  // For debugging http://crbug.com/454198; remove when resolved.
+  CHECK(clock_.get());
+#endif
   manager_->AddObserver(this);
 }
 
 SdchOwner::~SdchOwner() {
+#if defined(OS_CHROMEOS)
+  // For debugging http://crbug.com/454198; remove when resolved.
+  CHECK_EQ(0u, destroyed_);
+  CHECK(clock_.get());
+  clock_.reset();
+#endif
+
   for (auto it = local_dictionary_info_.begin();
        it != local_dictionary_info_.end(); ++it) {
     RecordDictionaryEviction(it->second.use_count,
                              DICTIONARY_FATE_EVICT_FOR_DESTRUCTION);
   }
   manager_->RemoveObserver(this);
+#if defined(OS_CHROMEOS)
+  destroyed_ = 0xdeadbeef;
+#endif
 }
 
 void SdchOwner::SetMaxTotalDictionarySize(size_t max_total_dictionary_size) {
   max_total_dictionary_size_ = max_total_dictionary_size;
 }
 
 void SdchOwner::SetMinSpaceForDictionaryFetch(
     size_t min_space_for_dictionary_fetch) {
   min_space_for_dictionary_fetch_ = min_space_for_dictionary_fetch;
 }
@@ skipping 16 matching lines @@
           server_hash(server_hash),
           use_count(use_count),
           dictionary_size(dictionary_size) {}
     DictionaryItem(const DictionaryItem& rhs) = default;
     DictionaryItem& operator=(const DictionaryItem& rhs) = default;
     bool operator<(const DictionaryItem& rhs) const {
       return last_used < rhs.last_used;
     }
   };
 
+#if defined(OS_CHROMEOS)
+  // For debugging http://crbug.com/454198; remove when resolved.
+  CHECK_EQ(0u, destroyed_);
+  CHECK(clock_.get());
+#endif
+
   std::vector<DictionaryItem> stale_dictionary_list;
   size_t recoverable_bytes = 0;
   base::Time stale_boundary(clock_->Now() - base::TimeDelta::FromDays(1));
   for (auto used_it = local_dictionary_info_.begin();
        used_it != local_dictionary_info_.end(); ++used_it) {
     if (used_it->second.last_used < stale_boundary) {
       stale_dictionary_list.push_back(
           DictionaryItem(used_it->second.last_used, used_it->first,
                          used_it->second.use_count, used_it->second.size));
       recoverable_bytes += used_it->second.size;
     }
   }
 
+#if defined(OS_CHROMEOS)
+  // For debugging http://crbug.com/454198; remove when resolved.
+  CHECK_EQ(0u, destroyed_);
+  CHECK(clock_.get());
+#endif
+
   if (total_dictionary_bytes_ + dictionary_text.size() - recoverable_bytes >
       max_total_dictionary_size_) {
     RecordDictionaryFate(DICTIONARY_FATE_FETCH_IGNORED_NO_SPACE);
     net::SdchManager::SdchErrorRecovery(SDCH_DICTIONARY_NO_ROOM);
     net_log.AddEvent(net::NetLog::TYPE_SDCH_DICTIONARY_ERROR,
                      base::Bind(&net::NetLogSdchDictionaryFetchProblemCallback,
                                 SDCH_DICTIONARY_NO_ROOM, dictionary_url, true));
     return;
   }
 
@@ skipping 27 matching lines @@
   RecordDictionaryFate(DICTIONARY_FATE_ADDED);
 
   DCHECK(local_dictionary_info_.end() ==
          local_dictionary_info_.find(server_hash));
   total_dictionary_bytes_ += dictionary_text.size();
   local_dictionary_info_[server_hash] = DictionaryInfo(
       // Set the time last used to something to avoid thrashing, but not recent,
       // to avoid taking too much time/space with useless dictionaries/one-off
       // visits to web sites.
       clock_->Now() - base::TimeDelta::FromHours(23), dictionary_text.size());
+
+#if defined(OS_CHROMEOS)
+  // For debugging http://crbug.com/454198; remove when resolved.
+  CHECK_EQ(0u, destroyed_);
+  CHECK(clock_.get());
+#endif
 }
 
 void SdchOwner::OnDictionaryUsed(SdchManager* manager,
                                  const std::string& server_hash) {
   auto it = local_dictionary_info_.find(server_hash);
   DCHECK(local_dictionary_info_.end() != it);
 
   it->second.last_used = clock_->Now();
   it->second.use_count++;
 }
 
 void SdchOwner::OnGetDictionary(net::SdchManager* manager,
                                 const GURL& request_url,
                                 const GURL& dictionary_url) {
+#if defined(OS_CHROMEOS)
+  // For debugging http://crbug.com/454198; remove when resolved.
+  CHECK_EQ(0u, destroyed_);
+  CHECK(clock_.get());
+#endif
+
   base::Time stale_boundary(clock_->Now() - base::TimeDelta::FromDays(1));
   size_t avail_bytes = 0;
   for (auto it = local_dictionary_info_.begin();
        it != local_dictionary_info_.end(); ++it) {
     if (it->second.last_used < stale_boundary)
       avail_bytes += it->second.size;
   }
 
   // Don't initiate the fetch if we wouldn't be able to store any
   // reasonable dictionary.
@@ skipping 13 matching lines @@
 }
 
 void SdchOwner::OnClearDictionaries(net::SdchManager* manager) {
   total_dictionary_bytes_ = 0;
   local_dictionary_info_.clear();
   fetcher_.Cancel();
 }
 
 void SdchOwner::SetClockForTesting(scoped_ptr<base::Clock> clock) {
   clock_ = clock.Pass();
+
+#if defined(OS_CHROMEOS)
+  // For debugging http://crbug.com/454198; remove when resolved.
+  CHECK_EQ(0u, destroyed_);
+  CHECK(clock_.get());
+#endif
 }
 
 void SdchOwner::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel level) {
   DCHECK_NE(base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE, level);
 
   for (auto it = local_dictionary_info_.begin();
        it != local_dictionary_info_.end(); ++it) {
     RecordDictionaryEviction(it->second.use_count,
                              DICTIONARY_FATE_EVICT_FOR_MEMORY);
   }
 
   // TODO(rdsmith): Make a distinction between moderate and critical
   // memory pressure.
   manager_->ClearData();
 }
 
 }  // namespace net