Remove static initializer in url_info.cc.

chrome/browser/net/url_info.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 "chrome/browser/net/url_info.h"
 
 #include <ctype.h>
 #include <math.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/format_macros.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace chrome_browser_net {
 
-static bool detailed_logging_enabled = false;
+namespace {
+
+// The number of OS cache entries we can guarantee(?) before cache eviction
+// might likely take place.
+const int kMaxGuaranteedDnsCacheSize = 50;
+
+// Common low end TTL for sites is 5 minutes.  However, DNS servers give us the
+// remaining time, not the original 5 minutes.  Hence it doesn't much matter
+// whether we found something in the local cache, or an ISP cache, it will on
+// average be 2.5 minutes before it expires.  We could try to model this with
+// 180 seconds, but simpler is just to do the lookups all the time (wasting OS
+// calls(?)), and let that OS cache decide what to do (with TTL in hand).  We
+// use a small time to help get some duplicate suppression, in case a page has
+// a TON of copies of the same domain name, so that we don't thrash the OS to
+// death.  Hopefully it is small enough that we're not hurting our cache hit
+// rate (i.e., we could always ask the OS).
+const int kDefaultCacheExpirationDuration = 5;
+
+TimeDelta MaxNonNetworkDnsLookupDuration() {
+  return TimeDelta::FromMilliseconds(15);
+}
+
+bool detailed_logging_enabled = false;
+
+struct GlobalState {
+  TimeDelta cache_expiration_duration;
+};
+
+struct InitializeGlobalState {
+  static const bool kRegisterOnExit = false;
+  static const bool kAllowedToAccessOnNonjoinableThread = true;
+
+  static GlobalState* New(void* instance) {

[battre, 2012/03/08 18:48:43]

Is this necessary? Could you not just use a constructor as in struct PathData of
base/path_service.cc for example and use LeakyLazyInstanceTraits?

I.e.

struct GlobalState {
  GlobalState() {
    cache_expiration_duration =
TimeDelta::FromSeconds(kDefaultCacheExpirationDuration);
  }
  TimeDelta cache_expiration_duration;
};

base::LazyInstance<GlobalState>::Leaky global_state = LAZY_INSTANCE_INITIALIZER;

[Philippe, 2012/03/09 08:48:09]

Indeed. I don't know how I managed to come up with such an unnecessarily
complicated thing :) I would have needed that if I only had the TimeDelta
without the struct.

+    GlobalState* const global = new(instance) GlobalState();
+    global->cache_expiration_duration =
+        TimeDelta::FromSeconds(kDefaultCacheExpirationDuration);
+    return global;
+  }
+
+  static void Delete(GlobalState* /* instance */) { /* Leaky */ }
+};
+
+base::LazyInstance<GlobalState, InitializeGlobalState> global_state;
+
+}  // anonymous namespace
 
 // Use command line switch to enable detailed logging.
 void EnablePredictorDetailedLog(bool enable) {
   detailed_logging_enabled = enable;
 }
 
 // static
 int UrlInfo::sequence_counter = 1;
 
 UrlInfo::UrlInfo()
     : state_(PENDING),
       old_prequeue_state_(state_),
-      resolve_duration_(kNullDuration),
-      queue_duration_(kNullDuration),
+      resolve_duration_(NullDuration()),
+      queue_duration_(NullDuration()),
       sequence_number_(0),
       motivation_(NO_PREFETCH_MOTIVATION),
       was_linked_(false) {
 }
 
 UrlInfo::~UrlInfo() {}
 
 bool UrlInfo::NeedsDnsUpdate() {
   switch (state_) {
     case PENDING:  // Just now created info.
       return true;
 
     case QUEUED:  // In queue.
     case ASSIGNED:  // It's being resolved.
     case ASSIGNED_BUT_MARKED:  // It's being resolved.
       return false;  // We're already working on it
 
     case NO_SUCH_NAME:  // Lookup failed.
     case FOUND:  // Lookup succeeded.
       return !IsStillCached();  // See if DNS cache expired.
 
     default:
       NOTREACHED();
       return false;
   }
 }
 
-const TimeDelta UrlInfo::kNullDuration(TimeDelta::FromMilliseconds(-1));
-
-// Common low end TTL for sites is 5 minutes.  However, DNS servers give us
-// the remaining time, not the original 5 minutes.  Hence it doesn't much matter
-// whether we found something in the local cache, or an ISP cache, it will
-// on average be 2.5 minutes before it expires.  We could try to model this with
-// 180 seconds, but simpler is just to do the lookups all the time (wasting
-// OS calls(?)), and let that OS cache decide what to do (with TTL in hand).
-// We use a small time to help get some duplicate suppression, in case a page
-// has a TON of copies of the same domain name, so that we don't thrash the OS
-// to death.  Hopefully it is small enough that we're not hurting our cache hit
-// rate (i.e., we could always ask the OS).
-TimeDelta UrlInfo::cache_expiration_duration_(TimeDelta::FromSeconds(5));
-
-const TimeDelta UrlInfo::kMaxNonNetworkDnsLookupDuration(
-    TimeDelta::FromMilliseconds(15));
-
-// Used by test ONLY.  The value is otherwise constant.
+// Used by test ONLY. The value is otherwise constant.
 // static
 void UrlInfo::set_cache_expiration(TimeDelta time) {
-  cache_expiration_duration_ = time;
+  global_state.Pointer()->cache_expiration_duration = time;
 }
 
 // static
 TimeDelta UrlInfo::get_cache_expiration() {
-  return cache_expiration_duration_;
+  return global_state.Get().cache_expiration_duration;
 }
 
 void UrlInfo::SetQueuedState(ResolutionMotivation motivation) {
   DCHECK(PENDING == state_ || FOUND == state_ || NO_SUCH_NAME == state_);
   old_prequeue_state_ = state_;
   state_ = QUEUED;
-  queue_duration_ = resolve_duration_ = kNullDuration;
+  queue_duration_ = resolve_duration_ = NullDuration();
   SetMotivation(motivation);
   GetDuration();  // Set time_
   DLogResultsStats("DNS Prefetch in queue");
 }
 
 void UrlInfo::SetAssignedState() {
   DCHECK(QUEUED == state_);
   state_ = ASSIGNED;
   queue_duration_ = GetDuration();
   DLogResultsStats("DNS Prefetch assigned");
   UMA_HISTOGRAM_TIMES("DNS.PrefetchQueue", queue_duration_);
 }
 
 void UrlInfo::RemoveFromQueue() {
   DCHECK(ASSIGNED == state_);
   state_ = old_prequeue_state_;
   DLogResultsStats("DNS Prefetch reset to prequeue");
-  static const TimeDelta kBoundary = TimeDelta::FromSeconds(2);
+  const TimeDelta kBoundary = TimeDelta::FromSeconds(2);
   if (queue_duration_ > kBoundary) {
     UMA_HISTOGRAM_MEDIUM_TIMES("DNS.QueueRecycledDeltaOver2",
                                queue_duration_ - kBoundary);
     return;
   }
   // Make a custom linear histogram for the region from 0 to boundary.
-  const size_t kBucketCount = 52;
+  static const size_t kBucketCount = 52;
   static base::Histogram* histogram(NULL);
   if (!histogram)
     histogram = base::LinearHistogram::FactoryTimeGet(
         "DNS.QueueRecycledUnder2", TimeDelta(), kBoundary, kBucketCount,
         base::Histogram::kUmaTargetedHistogramFlag);
   histogram->AddTime(queue_duration_);
 }
 
 void UrlInfo::SetPendingDeleteState() {
   DCHECK(ASSIGNED == state_  || ASSIGNED_BUT_MARKED == state_);
   state_ = ASSIGNED_BUT_MARKED;
 }
 
 void UrlInfo::SetFoundState() {
   DCHECK(ASSIGNED == state_);
   state_ = FOUND;
   resolve_duration_ = GetDuration();
-  if (kMaxNonNetworkDnsLookupDuration <= resolve_duration_) {
+  const TimeDelta max_duration = MaxNonNetworkDnsLookupDuration();
+  if (max_duration <= resolve_duration_) {
     UMA_HISTOGRAM_CUSTOM_TIMES("DNS.PrefetchResolution", resolve_duration_,
-        kMaxNonNetworkDnsLookupDuration, TimeDelta::FromMinutes(15), 100);
+        max_duration, TimeDelta::FromMinutes(15), 100);
   }
   sequence_number_ = sequence_counter++;
   DLogResultsStats("DNS PrefetchFound");
 }
 
 void UrlInfo::SetNoSuchNameState() {
   DCHECK(ASSIGNED == state_);
   state_ = NO_SUCH_NAME;
   resolve_duration_ = GetDuration();
-  if (kMaxNonNetworkDnsLookupDuration <= resolve_duration_) {
+  if (MaxNonNetworkDnsLookupDuration() <= resolve_duration_) {
     DHISTOGRAM_TIMES("DNS.PrefetchNotFoundName", resolve_duration_);
   }
   sequence_number_ = sequence_counter++;
   DLogResultsStats("DNS PrefetchNotFound");
 }
 
 void UrlInfo::SetUrl(const GURL& url) {
   if (url_.is_empty())  // Not yet initialized.
     url_ = url;
   else
     DCHECK_EQ(url_, url);
 }
 
 // IsStillCached() guesses if the DNS cache still has IP data,
 // or at least remembers results about "not finding host."
 bool UrlInfo::IsStillCached() const {
   DCHECK(FOUND == state_ || NO_SUCH_NAME == state_);
 
   // Default MS OS does not cache failures. Hence we could return false almost
   // all the time for that case.  However, we'd never try again to prefetch
   // the value if we returned false that way.  Hence we'll just let the lookup
   // time out the same way as FOUND case.
 
   if (sequence_counter - sequence_number_ > kMaxGuaranteedDnsCacheSize)
     return false;
 
-  TimeDelta time_since_resolution = TimeTicks::Now() - time_;
-
-  return time_since_resolution < cache_expiration_duration_;
+  const TimeDelta time_since_resolution = TimeTicks::Now() - time_;
+  return time_since_resolution < global_state.Get().cache_expiration_duration;
 }
 
 void UrlInfo::DLogResultsStats(const char* message) const {
   if (!detailed_logging_enabled)
     return;
   DVLOG(1) << "\t" << message << "\tq=" << queue_duration().InMilliseconds()
            << "ms,\tr=" << resolve_duration().InMilliseconds()
            << "ms,\tp=" << sequence_number_ << "\t" << url_.spec();
 }
 
@@ skipping 148 matching lines @@
 
     case LEARNED_REFERAL_MOTIVATED:
       return RemoveJs(referring_url_.spec());
 
     default:
       return "";
   }
 }
 
 }  // namespace chrome_browser_net