Remove some LazyInstance use in base/

base/cpu.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 "base/cpu.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "build/build_config.h"
 
 #if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX))
 #include "base/files/file_util.h"
-#include "base/lazy_instance.h"
 #endif
 
 #if defined(ARCH_CPU_X86_FAMILY)
 #if defined(_MSC_VER)
 #include <intrin.h>
 #include <immintrin.h>  // For _xgetbv()
 #endif
 #endif
 
 namespace base {
@@ skipping 93 matching lines @@
     }
   }
 
   const std::string& brand() const { return brand_; }
 
  private:
   std::string brand_;
   DISALLOW_COPY_AND_ASSIGN(LazyCpuInfoValue);
 };
 
-base::LazyInstance<LazyCpuInfoValue>::Leaky g_lazy_cpuinfo =
-    LAZY_INSTANCE_INITIALIZER;
-
 #endif  // defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) ||
         // defined(OS_LINUX))
 
 }  // anonymous namespace
 
 void CPU::Initialize() {
 #if defined(ARCH_CPU_X86_FAMILY)
   int cpu_info[4] = {-1};
   char cpu_string[48];
 
@@ skipping 68 matching lines @@
     }
     cpu_brand_.assign(cpu_string, cpu_string_ptr - cpu_string);
   }
 
   const int parameter_containing_non_stop_time_stamp_counter = 0x80000007;
   if (max_parameter >= parameter_containing_non_stop_time_stamp_counter) {
     __cpuid(cpu_info, parameter_containing_non_stop_time_stamp_counter);
     has_non_stop_time_stamp_counter_ = (cpu_info[3] & (1 << 8)) != 0;
   }
 #elif defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX))
-  cpu_brand_.assign(g_lazy_cpuinfo.Get().brand());
+  static auto lazy_cpuinfo = new LazyCpuInfoValue();

[Mark Mentovai, 2017/01/31 00:52:09]

I don’t know how much digging you want to do at each of these use sites, but it
occurs to me that in cases like this, we can simplify a little more:

// in place of class LazyCpuInfoValue
std::string CpuInfoBrandInternal();
std::string* CpuInfoBrand() {
  static std::string* value = new std::string(CpuInfoBrandInternal();
  return value;
}

  // right here
  cpu_brand_.assign(*CpuInfoBrand());

Or another thing I’ve done (I think we’ve done it together actually) has been to
get rid of the “internal” function and use a lambda.

std::string* CpuInfoBrand() {
  static std::string* value = [](){
    return new std::string(/* … */);
  }();
}

Or, in this case, since it’s only used in one place, get rid of both functions
and just put the static std::string* in one place, right here.

Different levels of improvement, and if it’s like 1,000 use sites, I don’t know
how intimate you’ll want to get with each one, but it’d be nice to not just get
rid of the legacy of LazyInstance but to also overcome design decisions that it
imposed on the code too.

+  cpu_brand_.assign(lazy_cpuinfo->brand());
 #endif
 }
 
 CPU::IntelMicroArchitecture CPU::GetIntelMicroArchitecture() const {
   if (has_avx2()) return AVX2;
   if (has_avx()) return AVX;
   if (has_sse42()) return SSE42;
   if (has_sse41()) return SSE41;
   if (has_ssse3()) return SSSE3;
   if (has_sse3()) return SSE3;
   if (has_sse2()) return SSE2;
   if (has_sse()) return SSE;
   return PENTIUM;
 }
 
 }  // namespace base