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/strings/string_util.h"
 #include "base/time/default_clock.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/sdch_net_log_params.h"
 
 namespace {
 
 enum DictionaryFate {
   // A Get-Dictionary header wasn't acted on.
   DICTIONARY_FATE_GET_IGNORED = 1,
 
@@ skipping 60 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))) {
+  // For debugging http://crbug.com/454198; remove when resolved.
+  AssertNotDestroyedAndClockNotNull(__LINE__, GURL());
   manager_->AddObserver(this);
 }
 
 SdchOwner::~SdchOwner() {
+  // For debugging http://crbug.com/454198; remove when resolved.
+  AssertNotDestroyedAndClockNotNull(__LINE__, GURL());
+
   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;
     }
   };
 
+  // For debugging http://crbug.com/454198; remove when resolved.
+  AssertNotDestroyedAndClockNotNull(__LINE__, dictionary_url);

[mmenke, 2015/02/20 17:30:09]

Sorry, I really wasn't thinking when I signed off...This is actually the wrong
URL.  I blame it on today being Friday (It's all Friday's fault, dangit!)  The
URL we'd actually want is the URL of the URLRequest that's calling into the
SdchManager to request the URL, which is a couple layers up in the stack.

+
   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;
     }
   }
 
+  // For debugging http://crbug.com/454198; remove when resolved.
+  AssertNotDestroyedAndClockNotNull(__LINE__, dictionary_url);
+
   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());
+
+  // For debugging http://crbug.com/454198; remove when resolved.
+  AssertNotDestroyedAndClockNotNull(__LINE__, dictionary_url);
 }
 
 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) {
+  // For debugging http://crbug.com/454198; remove when resolved.
+  AssertNotDestroyedAndClockNotNull(__LINE__, dictionary_url);
+
   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();
+
+  // For debugging http://crbug.com/454198; remove when resolved.
+  AssertNotDestroyedAndClockNotNull(__LINE__, GURL());
 }
 
 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();
 }
 
+// For debugging http://crbug.com/454198; remove when resolved.
+#if defined(OS_CHROMEOS)
+void SdchOwner::AssertNotDestroyedAndClockNotNull(int line, const GURL& url) {
+  if (destroyed_ != 0u || clock_.get() == nullptr) {
+    char url_buf[128];
+    base::strlcpy(url_buf, url.spec().c_str(), arraysize(url_buf));
+    CHECK(false) << "454198 test tripped on line " << line << ", destroyed "
+                 << destroyed_ << ", clock " << clock_.get();
+  }
+}
+#else
+void SdchOwner::AssertNotDestroyedAndClockNotNull(int line, const GURL& url) {
+}
+#endif
+
 }  // namespace net