Make global variable g_testing_build_time lazily created

chrome/browser/ssl/ssl_error_classification.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 <vector>
 
 #include "chrome/browser/ssl/ssl_error_classification.h"
 
 #include "base/build_time.h"
+#include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/ssl_errors/error_info.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cert/x509_cert_types.h"
 #include "net/cert/x509_certificate.h"
 #include "url/gurl.h"
@@ skipping 58 matching lines @@
       kSecondRow[j+1] = std::min(std::min(
           kSecondRow[j] + 1, kFirstRow[j + 1] + 1), kFirstRow[j] + cost);
     }
     for (size_t j = 0; j < kFirstRow.size(); j++)
       kFirstRow[j] = kSecondRow[j];
   }
   return kSecondRow[str2.size()];
 }
 
 // The time to use when doing build time operations in browser tests.
-base::Time g_testing_build_time;
+base::LazyInstance<base::Time> g_testing_build_time = LAZY_INSTANCE_INITIALIZER;
 
 } // namespace
 
 SSLErrorClassification::SSLErrorClassification(const base::Time& current_time,
                                                const GURL& url,
                                                int cert_error,
                                                const net::X509Certificate& cert)
     : current_time_(current_time),
       request_url_(url),
       cert_error_(cert_error),
@@ skipping 56 matching lines @@
     default:
       break;
   }
   UMA_HISTOGRAM_ENUMERATION("interstitial.ssl.connection_type",
                             net::NetworkChangeNotifier::GetConnectionType(),
                             net::NetworkChangeNotifier::CONNECTION_LAST);
 }
 
 bool SSLErrorClassification::IsUserClockInThePast(const base::Time& time_now) {
   base::Time build_time;
-  if (!g_testing_build_time.is_null()) {
-    build_time = g_testing_build_time;
+  if (!g_testing_build_time.Get().is_null()) {
+    build_time = g_testing_build_time.Get();
   } else {
 #if defined(DONT_EMBED_BUILD_METADATA) && !defined(OFFICIAL_BUILD)
     return false;
 #else
     build_time = base::GetBuildTime();
 #endif
   }
 
   if (time_now < build_time - base::TimeDelta::FromDays(2))
     return true;
   return false;
 }
 
 bool SSLErrorClassification::IsUserClockInTheFuture(
     const base::Time& time_now) {
   base::Time build_time;
-  if (!g_testing_build_time.is_null()) {
-    build_time = g_testing_build_time;
+  if (!g_testing_build_time.Get().is_null()) {
+    build_time = g_testing_build_time.Get();
   } else {
 #if defined(DONT_EMBED_BUILD_METADATA) && !defined(OFFICIAL_BUILD)
     return false;
 #else
     build_time = base::GetBuildTime();
 #endif
   }
 
   if (time_now > build_time + base::TimeDelta::FromDays(365))
     return true;
   return false;
 }
 
 // static
 void SSLErrorClassification::SetBuildTimeForTesting(
     const base::Time& testing_time) {
-  g_testing_build_time = testing_time;
+  g_testing_build_time.Get() = testing_time;
 }
 
 bool SSLErrorClassification::MaybeWindowsLacksSHA256Support() {
 #if defined(OS_WIN)
   return !base::win::MaybeHasSHA256Support();
 #else
   return false;
 #endif
 }
 
@@ skipping 223 matching lines @@
   return std::find(dns_names_domain.begin(), dns_names_domain.end() - 1,
                    host_name_domain) != dns_names_domain.end() - 1;
 }
 
 // static
 bool SSLErrorClassification::IsHostnameNonUniqueOrDotless(
     const std::string& hostname) {
   return net::IsHostnameNonUnique(hostname) ||
          hostname.find('.') == std::string::npos;
 }