Fix static initializers in the Chrome OS ResourceReporter.

chrome/browser/chromeos/resource_reporter/resource_reporter.cc

 // Copyright 2015 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/chromeos/resource_reporter/resource_reporter.h"
 
 #include <cstdint>
 #include <queue>
 #include <utility>
 
@@ skipping 54 matching lines @@
 
 // Key used to store the last time a Rappor report was recorded in local_state.
 constexpr char kLastRapporReportTimeKey[] =
     "resource_reporter.last_report_time";
 
 // To keep privacy guarantees of Rappor, we limit the reports to at most once
 // per day.
 constexpr base::TimeDelta kMinimumTimeBetweenReports =
     base::TimeDelta::FromDays(1);
 
-// Gets the memory usage threshold of a process beyond which the process is
-// considered memory-intensive on the current device it's running on.
-int64_t GetMemoryThresholdForDeviceInBytes() {
-  const int64_t bytes_per_cpu = base::SysInfo::AmountOfPhysicalMemory() /
-                                base::SysInfo::NumberOfProcessors();
-
-  return bytes_per_cpu * 0.6;
-}
+constexpr double kTaskCpuThresholdForReporting = 70.0;
 
 }  // namespace
 
 ResourceReporter::TaskRecord::TaskRecord(task_manager::TaskId task_id)
     : id(task_id), cpu_percent(0.0), memory_bytes(0), is_background(false) {}
 
 ResourceReporter::TaskRecord::TaskRecord(task_manager::TaskId the_id,
                                          const std::string& task_name,
                                          double cpu_percent,
                                          int64_t memory_bytes,
@@ skipping 75 matching lines @@
         last_browser_process_memory_ = memory_usage >= 0 ? memory_usage : 0;
         break;
 
       case task_manager::Task::GPU:
         last_gpu_process_cpu_ = cpu_usage;
         last_gpu_process_memory_ = memory_usage >= 0 ? memory_usage : 0;
         break;
 
       default:
         // Other tasks types will be reported using Rappor.
-        if (memory_usage < kTaskMemoryThresholdForReporting &&
-            cpu_usage < kTaskCpuThresholdForReporting) {
+        if (memory_usage < GetTaskMemoryThresholdForReporting() &&
+            cpu_usage < GetTaskCpuThresholdForReporting()) {
           // We only care about CPU and memory intensive tasks.
           break;
         }
 
         task_records_.emplace_back(
             id, observed_task_manager()->GetTaskNameForRappor(id), cpu_usage,
             memory_usage,
             observed_task_manager()->IsTaskOnBackgroundedProcess(id));
     }
   }
 
   // Now that we got the data, we don't need the task manager anymore.
   if (base::MemoryPressureMonitor::Get()->GetCurrentPressureLevel() !=
           MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_CRITICAL ||
       !task_records_.empty()) {
     // The memory pressure events are emitted once per second. In order to avoid
     // unsubscribing and then resubscribing to the task manager again on the
     // next event, we keep listening to the task manager as long as the memory
     // pressure level is critical AND we couldn't find any violators yet.
     StopRecordingCurrentState();
   }
 
   // Schedule reporting the samples.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&ResourceReporter::ReportSamples, base::Unretained(this)));
 }
 
-// static
-const double ResourceReporter::kTaskCpuThresholdForReporting = 70.0;
-
-// static
-const int64_t ResourceReporter::kTaskMemoryThresholdForReporting =

[Lei Zhang, 2017/04/07 19:12:43]

This constant has to be computed at startup.

-    GetMemoryThresholdForDeviceInBytes();
-
 ResourceReporter::ResourceReporter()
     : TaskManagerObserver(base::TimeDelta::FromSeconds(kRefreshIntervalSeconds),
                           task_manager::REFRESH_TYPE_CPU |
                               task_manager::REFRESH_TYPE_MEMORY |
                               task_manager::REFRESH_TYPE_PRIORITY),
       task_manager_to_observe_(nullptr),
       system_cpu_cores_range_(GetCurrentSystemCpuCoresRange()),
       last_browser_process_cpu_(0.0),
       last_gpu_process_cpu_(0.0),
       last_browser_process_memory_(0),
       last_gpu_process_memory_(0),
       is_monitoring_(false) {}
 
 // static
+double ResourceReporter::GetTaskCpuThresholdForReporting() {
+  return kTaskCpuThresholdForReporting;
+}
+
+// static
+int64_t ResourceReporter::GetTaskMemoryThresholdForReporting() {
+  static const int64_t threshold = 0.6 *

[Lei Zhang, 2017/04/07 19:12:43]

Now it's computed at first use.

+                                   base::SysInfo::AmountOfPhysicalMemory() /
+                                   base::SysInfo::NumberOfProcessors();
+  return threshold;
+}
+
+// static
 std::unique_ptr<rappor::Sample> ResourceReporter::CreateRapporSample(
     rappor::RapporServiceImpl* rappor_service,
     const ResourceReporter::TaskRecord& task_record) {
   std::unique_ptr<rappor::Sample> sample(
       rappor_service->CreateSample(rappor::UMA_RAPPOR_TYPE));
   sample->SetStringField(kRapporTaskStringField,
                          task_record.task_name_for_rappor);
   sample->SetFlagsField(kRapporPriorityFlagsField,
                         task_record.is_background ?
                             GET_ENUM_VAL(TaskProcessPriority::BACKGROUND) :
@@ skipping 205 matching lines @@
       break;
     case base::MemoryState::SUSPENDED:
     // Note: Not supported at present. Fall through.
     case base::MemoryState::UNKNOWN:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace chromeos