Remove usage of MainEntryPointTime() inside the impl which has direct access to the variable.

components/startup_metric_utils/browser/startup_metric_utils.cc

 // Copyright 2013 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 "components/startup_metric_utils/browser/startup_metric_utils.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/environment.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 250 matching lines @@
   // conversion.
   const base::TimeDelta delta_since_base = time_base - time;
   return trace_ticks_base - delta_since_base;
 }
 
 // Record time of main entry so it can be read from Telemetry performance tests.
 // TODO(jeremy): Remove once crbug.com/317481 is fixed.
 void RecordMainEntryTimeHistogram() {
   const int kLowWordMask = 0xFFFFFFFF;
   const int kLower31BitsMask = 0x7FFFFFFF;
-  DCHECK(!MainEntryPointTime().is_null());
+  DCHECK(!g_main_entry_point_time.Get().is_null());
   base::TimeDelta browser_main_entry_time_absolute =
-      MainEntryPointTime() - base::Time::UnixEpoch();
+      g_main_entry_point_time.Get() - base::Time::UnixEpoch();
 
   uint64 browser_main_entry_time_raw_ms =
       browser_main_entry_time_absolute.InMilliseconds();
 
   base::TimeDelta browser_main_entry_time_raw_ms_high_word =
       base::TimeDelta::FromMilliseconds(
           (browser_main_entry_time_raw_ms >> 32) & kLowWordMask);
   // Shift by one because histograms only support non-negative values.
   base::TimeDelta browser_main_entry_time_raw_ms_low_word =
       base::TimeDelta::FromMilliseconds(
@@ skipping 32 matching lines @@
   g_non_browser_ui_displayed = true;
 }
 
 void RecordStartupProcessCreationTime(const base::Time& time) {
   DCHECK(g_process_creation_time.Get().is_null());
   g_process_creation_time.Get() = time;
   DCHECK(!g_process_creation_time.Get().is_null());
 }
 
 void RecordMainEntryPointTime(const base::Time& time) {
-  DCHECK(MainEntryPointTime().is_null());
+  DCHECK(g_main_entry_point_time.Get().is_null());
   g_main_entry_point_time.Get() = time;
-  DCHECK(!MainEntryPointTime().is_null());
+  DCHECK(!g_main_entry_point_time.Get().is_null());
 }
 
 void RecordExeMainEntryPointTime(const base::Time& time) {
   std::string exe_load_time = base::Int64ToString(time.ToInternalValue());
   scoped_ptr<base::Environment> env(base::Environment::Create());
   env->SetVar(kChromeMainTimeEnvVar, exe_load_time);
 }
 
 void RecordBrowserMainMessageLoopStart(const base::Time& time,
                                        bool is_first_run) {
@@ skipping 11 matching lines @@
   // autostarted and the machine is under io pressure.
   if (base::SysInfo::Uptime() < base::TimeDelta::FromMinutes(7))
     return;
 
   // The Startup.BrowserMessageLoopStartTime histogram exhibits instability in
   // the field which limits its usefulness in all scenarios except when we have
   // a very large sample size. Attempt to mitigate this with a new metric:
   // * Measure time from main entry rather than the OS' notion of process start.
   // * Only measure launches that occur 7 minutes after boot to try to avoid
   //   cases where Chrome is auto-started and IO is heavily loaded.
-  const base::Time dll_main_time = MainEntryPointTime();
   if (is_first_run) {
     UMA_HISTOGRAM_AND_TRACE_WITH_STARTUP_TEMPERATURE(
         UMA_HISTOGRAM_LONG_TIMES,
         "Startup.BrowserMessageLoopStartTimeFromMainEntry.FirstRun",
-        dll_main_time, time);
+        g_main_entry_point_time.Get(), time);
   } else {
     UMA_HISTOGRAM_AND_TRACE_WITH_STARTUP_TEMPERATURE(
         UMA_HISTOGRAM_LONG_TIMES,
-        "Startup.BrowserMessageLoopStartTimeFromMainEntry", dll_main_time,
-        time);
+        "Startup.BrowserMessageLoopStartTimeFromMainEntry",
+        g_main_entry_point_time.Get(), time);
   }
 
   // Record timings between process creation, the main() in the executable being
   // reached and the main() in the shared library being reached.
   if (!process_creation_time.is_null()) {
     const base::Time exe_main_time = ExeMainEntryPointTime();
     if (!exe_main_time.is_null()) {
       // Process create to chrome.exe:main().
       UMA_HISTOGRAM_AND_TRACE_WITH_STARTUP_TEMPERATURE(
           UMA_HISTOGRAM_LONG_TIMES, "Startup.LoadTime.ProcessCreateToExeMain",
           process_creation_time, exe_main_time);
 
       // chrome.exe:main() to chrome.dll:main().
       UMA_HISTOGRAM_AND_TRACE_WITH_STARTUP_TEMPERATURE(
           UMA_HISTOGRAM_LONG_TIMES, "Startup.LoadTime.ExeMainToDllMain",
-          exe_main_time, dll_main_time);
+          exe_main_time, g_main_entry_point_time.Get());
 
       // Process create to chrome.dll:main(). Reported as a histogram only as
       // the other two events above are sufficient for tracing purposes.
       UMA_HISTOGRAM_WITH_STARTUP_TEMPERATURE(
           UMA_HISTOGRAM_LONG_TIMES, "Startup.LoadTime.ProcessCreateToDllMain",
-          dll_main_time - process_creation_time);
+          g_main_entry_point_time.Get() - process_creation_time);
     }
   }
 }
 
 void RecordBrowserWindowDisplay(const base::Time& time) {
   static bool is_first_call = true;
   if (!is_first_call || time.is_null())
     return;
   is_first_call = false;
   if (WasNonBrowserUIDisplayed() || g_process_creation_time.Get().is_null())
@@ skipping 96 matching lines @@
 
 base::Time MainEntryPointTime() {
   return g_main_entry_point_time.Get();
 }
 
 StartupTemperature GetStartupTemperature() {
   return g_startup_temperature;
 }
 
 }  // namespace startup_metric_utils