forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
sys_info.cc
135 lines (113 loc) · 4.35 KB
/
sys_info.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
// 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/system/sys_info.h"
#include <algorithm>
#include "base/base_switches.h"
#include "base/bind.h"
#include "base/callback.h"
#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/lazy_instance.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/metrics/field_trial_params.h"
#include "base/system/sys_info_internal.h"
#include "base/task/post_task.h"
#include "base/task/task_traits.h"
#include "base/task_runner_util.h"
#include "base/time/time.h"
#include "build/build_config.h"
namespace base {
namespace {
// Feature used to control the heuristics used to categorize a device as low
// end.
const base::Feature kLowEndDeviceDetectionFeature{
"LowEndDeviceDetection", base::FEATURE_DISABLED_BY_DEFAULT};
static const int kLowMemoryDeviceThresholdMBDefault = 512;
int GetLowMemoryDeviceThresholdMB() {
static constexpr base::FeatureParam<int> kLowEndDeviceMemoryThresholdMB{
&kLowEndDeviceDetectionFeature, "LowEndDeviceMemoryThresholdMB",
kLowMemoryDeviceThresholdMBDefault};
// If the feature is disabled then |Get| will return the default value.
return kLowEndDeviceMemoryThresholdMB.Get();
}
} // namespace
// static
int64_t SysInfo::AmountOfPhysicalMemory() {
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableLowEndDeviceMode)) {
return GetLowMemoryDeviceThresholdMB() * 1024 * 1024;
}
return AmountOfPhysicalMemoryImpl();
}
// static
int64_t SysInfo::AmountOfAvailablePhysicalMemory() {
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableLowEndDeviceMode)) {
// Estimate the available memory by subtracting our memory used estimate
// from the fake |GetLowMemoryDeviceThresholdMB()| limit.
size_t memory_used =
AmountOfPhysicalMemoryImpl() - AmountOfAvailablePhysicalMemoryImpl();
size_t memory_limit = GetLowMemoryDeviceThresholdMB() * 1024 * 1024;
// std::min ensures no underflow, as |memory_used| can be > |memory_limit|.
return memory_limit - std::min(memory_used, memory_limit);
}
return AmountOfAvailablePhysicalMemoryImpl();
}
bool SysInfo::IsLowEndDevice() {
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableLowEndDeviceMode)) {
return true;
}
return IsLowEndDeviceImpl();
}
#if !defined(OS_ANDROID)
bool DetectLowEndDevice() {
CommandLine* command_line = CommandLine::ForCurrentProcess();
if (command_line->HasSwitch(switches::kEnableLowEndDeviceMode))
return true;
if (command_line->HasSwitch(switches::kDisableLowEndDeviceMode))
return false;
int ram_size_mb = SysInfo::AmountOfPhysicalMemoryMB();
return (ram_size_mb > 0 && ram_size_mb <= GetLowMemoryDeviceThresholdMB());
}
static LazyInstance<internal::LazySysInfoValue<bool, DetectLowEndDevice>>::Leaky
g_lazy_low_end_device = LAZY_INSTANCE_INITIALIZER;
// static
bool SysInfo::IsLowEndDeviceImpl() {
return g_lazy_low_end_device.Get().value();
}
#endif
#if !defined(OS_MACOSX) && !defined(OS_ANDROID)
std::string SysInfo::HardwareModelName() {
return std::string();
}
#endif
void SysInfo::GetHardwareInfo(base::OnceCallback<void(HardwareInfo)> callback) {
#if defined(OS_WIN)
base::PostTaskAndReplyWithResult(
base::CreateCOMSTATaskRunnerWithTraits({}).get(), FROM_HERE,
base::BindOnce(&GetHardwareInfoSync), std::move(callback));
#elif defined(OS_ANDROID) || defined(OS_MACOSX)
base::PostTaskAndReplyWithResult(
FROM_HERE, base::BindOnce(&GetHardwareInfoSync), std::move(callback));
#elif defined(OS_LINUX)
base::PostTaskWithTraitsAndReplyWithResult(
FROM_HERE, {base::MayBlock()}, base::BindOnce(&GetHardwareInfoSync),
std::move(callback));
#else
NOTIMPLEMENTED();
base::PostTask(FROM_HERE,
base::BindOnce(std::move(callback), HardwareInfo()));
#endif
}
// static
base::TimeDelta SysInfo::Uptime() {
// This code relies on an implementation detail of TimeTicks::Now() - that
// its return value happens to coincide with the system uptime value in
// microseconds, on Win/Mac/iOS/Linux/ChromeOS and Android.
int64_t uptime_in_microseconds = TimeTicks::Now().ToInternalValue();
return base::TimeDelta::FromMicroseconds(uptime_in_microseconds);
}
} // namespace base