0

[base] [trace_event] Rename Macro-like enum values in base/trace_event

Many macro-like enum values are defined in //base/trace_event/,
for example, `enum class MemoryDumpDeterminism : uint32_t { NONE,
FORCE_GC }`.

Google C++ style guide recommends today to not name macro-like enum
values.

This patch only renames some Macro-like enum values, and the remaining
Macro-like enum values will be renamed in subsequent patches.

Bug: 1453482
Change-Id: I0d103a0d258ef4c60876c1f8bc8e4d9685792744
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4841679
Reviewed-by: Primiano Tucci <primiano@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Owners-Override: Lei Zhang <thestig@chromium.org>
Commit-Queue: Ho Cheung <uioptt24@gmail.com>
Cr-Commit-Position: refs/heads/main@{#1193888}
This commit is contained in:
Ho Cheung
2023-09-08 02:01:11 +00:00
committed by Chromium LUCI CQ
parent 00a18d3032
commit adbf3fb72a
102 changed files with 416 additions and 403 deletions
base
cc
chrome
components
content/browser
fuchsia_web/webengine/browser
gin
gpu
mojo/core
net/url_request
services/resource_coordinator
skia/ext
sql
third_party
ui/android/resources

@ -53,7 +53,7 @@ bool MeminfoDumpProvider::OnMemoryDump(
// would confuse data in UMA. In particular, the background/foreground session
// filter would no longer be accurate.
if (stale_data && args.level_of_detail !=
base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {
base::trace_event::MemoryDumpLevelOfDetail::kDetailed) {
return true;
}

@ -30,7 +30,7 @@ TEST(MeminfoDumpProviderTest, Simple) {
auto& instance = MeminfoDumpProvider::Initialize();
base::trace_event::MemoryDumpArgs args{};
args.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::DETAILED;
args.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::kDetailed;
base::trace_event::ProcessMemoryDump first_pmd{args};
bool success = instance.OnMemoryDump(args, &first_pmd);
@ -80,7 +80,8 @@ TEST(MeminfoDumpProviderTest, NoStaleReportsInBackgroundDumps) {
// First dump, data may or may not be stale.
{
base::trace_event::MemoryDumpArgs args{};
args.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::DETAILED;
args.level_of_detail =
base::trace_event::MemoryDumpLevelOfDetail::kDetailed;
base::trace_event::ProcessMemoryDump pmd{args};
ASSERT_TRUE(instance.OnMemoryDump(args, &pmd));
}
@ -89,7 +90,7 @@ TEST(MeminfoDumpProviderTest, NoStaleReportsInBackgroundDumps) {
{
base::trace_event::MemoryDumpArgs args{};
args.level_of_detail =
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND;
base::trace_event::MemoryDumpLevelOfDetail::kBackground;
base::trace_event::ProcessMemoryDump pmd{args};
ASSERT_TRUE(instance.OnMemoryDump(args, &pmd));
base::trace_event::MemoryAllocatorDump* dump =

@ -462,7 +462,7 @@ TEST(DiscardableSharedMemoryTest, TracingOwnershipEdges) {
ASSERT_TRUE(rv);
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
trace_event::ProcessMemoryDump pmd(args);
trace_event::MemoryAllocatorDump* client_dump =
pmd.CreateAllocatorDump("discardable_manager/map1");

@ -54,7 +54,7 @@ bool MadvFreeDiscardableMemoryAllocatorPosix::OnMemoryDump(
trace_event::ProcessMemoryDump* pmd) {
#if BUILDFLAG(ENABLE_BASE_TRACING)
if (args.level_of_detail !=
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
return true;
}

@ -37,7 +37,7 @@ class MadvFreeDiscardableMemoryAllocatorPosixTest : public ::testing::Test {
MadvFreeDiscardableMemoryAllocatorPosixTest() {
#if BUILDFLAG(ENABLE_BASE_TRACING)
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
pmd_ = std::make_unique<base::trace_event::ProcessMemoryDump>(dump_args);
#endif // BUILDFLAG(ENABLE_BASE_TRACING)
}

@ -45,7 +45,7 @@ class HeapProfilerScopedTaskExecutionTracker {
: context_(task_context) {
using base::trace_event::AllocationContextTracker;
if (UNLIKELY(AllocationContextTracker::capture_mode() !=
AllocationContextTracker::CaptureMode::DISABLED)) {
AllocationContextTracker::CaptureMode::kDisabled)) {
AllocationContextTracker::GetInstanceForCurrentThread()
->PushCurrentTaskContext(context_);
}
@ -54,7 +54,7 @@ class HeapProfilerScopedTaskExecutionTracker {
inline ~HeapProfilerScopedTaskExecutionTracker() {
using base::trace_event::AllocationContextTracker;
if (UNLIKELY(AllocationContextTracker::capture_mode() !=
AllocationContextTracker::CaptureMode::DISABLED)) {
AllocationContextTracker::CaptureMode::kDisabled)) {
AllocationContextTracker::GetInstanceForCurrentThread()
->PopCurrentTaskContext(context_);
}

@ -31,15 +31,15 @@ namespace trace_event {
// pointer from process' address space.
struct BASE_EXPORT StackFrame {
enum class Type {
THREAD_NAME, // const char* thread name
PROGRAM_COUNTER, // as returned by stack tracing (e.g. by StackTrace)
kThreadName, // const char* thread name
kProgramCounter, // as returned by stack tracing (e.g. by StackTrace)
};
static StackFrame FromThreadName(const char* name) {
return {Type::THREAD_NAME, name};
return {Type::kThreadName, name};
}
static StackFrame FromProgramCounter(const void* pc) {
return {Type::PROGRAM_COUNTER, pc};
return {Type::kProgramCounter, pc};
}
Type type;

@ -17,7 +17,7 @@ namespace trace_event {
std::atomic<AllocationContextTracker::CaptureMode>
AllocationContextTracker::capture_mode_{
AllocationContextTracker::CaptureMode::DISABLED};
AllocationContextTracker::CaptureMode::kDisabled};
namespace {
@ -64,7 +64,7 @@ AllocationContextTracker::~AllocationContextTracker() = default;
// static
void AllocationContextTracker::SetCurrentThreadName(const char* name) {
if (name && capture_mode() != CaptureMode::DISABLED) {
if (name && capture_mode() != CaptureMode::kDisabled) {
GetInstanceForCurrentThread()->thread_name_ = name;
}
}

@ -23,12 +23,12 @@ namespace trace_event {
class BASE_EXPORT AllocationContextTracker {
public:
enum class CaptureMode : int32_t {
DISABLED, // Don't capture anything
NATIVE_STACK, // Backtrace has full native backtraces from stack unwinding
kDisabled, // Don't capture anything
kNativeStack, // Backtrace has full native backtraces from stack unwinding
};
// Globally sets capturing mode.
// TODO(primiano): How to guard against *_STACK -> DISABLED -> *_STACK?
// TODO(primiano): How to guard against *Stack -> kDisabled -> *Stack?
static void SetCaptureMode(CaptureMode mode);
// Returns global capturing mode.
@ -36,13 +36,15 @@ class BASE_EXPORT AllocationContextTracker {
// A little lag after heap profiling is enabled or disabled is fine, it is
// more important that the check is as cheap as possible when capturing is
// not enabled, so do not issue a memory barrier in the fast path.
if (capture_mode_.load(std::memory_order_relaxed) == CaptureMode::DISABLED)
return CaptureMode::DISABLED;
if (capture_mode_.load(std::memory_order_relaxed) ==
CaptureMode::kDisabled) {
return CaptureMode::kDisabled;
}
// In the slow path, an acquire load is required to pair with the release
// store in |SetCaptureMode|. This is to ensure that the TLS slot for
// the thread-local allocation context tracker has been initialized if
// |capture_mode| returns something other than DISABLED.
// |capture_mode| returns something other than kDisabled.
return capture_mode_.load(std::memory_order_acquire);
}

@ -12,7 +12,7 @@ namespace trace_event {
TEST(JavaHeapDumpProviderTest, JavaHeapDump) {
auto* jhdp = JavaHeapDumpProvider::GetInstance();
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::kDetailed};
std::unique_ptr<ProcessMemoryDump> pmd(new ProcessMemoryDump(dump_args));
jhdp->OnMemoryDump(dump_args, pmd.get());

@ -86,7 +86,7 @@ void ReportWinHeapStats(MemoryDumpLevelOfDetail level_of_detail,
size_t* allocated_objects_size,
size_t* allocated_objects_count) {
// This is too expensive on Windows, crbug.com/780735.
if (level_of_detail == MemoryDumpLevelOfDetail::DETAILED) {
if (level_of_detail == MemoryDumpLevelOfDetail::kDetailed) {
WinHeapInfo main_heap_info = {};
WinHeapMemoryDumpImpl(&main_heap_info);
*total_virtual_size +=
@ -122,7 +122,7 @@ void ReportPartitionAllocStats(ProcessMemoryDump* pmd,
size_t* cumulative_brp_quarantined_count) {
MemoryDumpPartitionStatsDumper partition_stats_dumper("malloc", pmd,
level_of_detail);
bool is_light_dump = level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND;
bool is_light_dump = level_of_detail == MemoryDumpLevelOfDetail::kBackground;
auto* allocator = allocator_shim::internal::PartitionAllocMalloc::Allocator();
allocator->DumpStats("allocator", is_light_dump, &partition_stats_dumper);
@ -477,7 +477,7 @@ MemoryDumpPartitionStatsDumper::MemoryDumpPartitionStatsDumper(
MemoryDumpLevelOfDetail level_of_detail)
: root_name_(root_name),
memory_dump_(memory_dump),
detailed_(level_of_detail != MemoryDumpLevelOfDetail::BACKGROUND) {}
detailed_(level_of_detail != MemoryDumpLevelOfDetail::kBackground) {}
void MemoryDumpPartitionStatsDumper::PartitionDumpTotals(
const char* partition_name,

@ -56,7 +56,7 @@ void MemoryAllocatorDump::AddString(const char* name,
const char* units,
const std::string& value) {
// String attributes are disabled in background mode.
if (level_of_detail_ == MemoryDumpLevelOfDetail::BACKGROUND) {
if (level_of_detail_ == MemoryDumpLevelOfDetail::kBackground) {
NOTREACHED();
return;
}

@ -75,13 +75,13 @@ void CheckScalar(const MemoryAllocatorDump* dump,
TEST(MemoryAllocatorDumpTest, GuidGeneration) {
std::unique_ptr<MemoryAllocatorDump> mad(new MemoryAllocatorDump(
"foo", MemoryDumpLevelOfDetail::FIRST, MemoryAllocatorDumpGuid(0x42u)));
"foo", MemoryDumpLevelOfDetail::kFirst, MemoryAllocatorDumpGuid(0x42u)));
ASSERT_EQ("42", mad->guid().ToString());
}
TEST(MemoryAllocatorDumpTest, DumpIntoProcessMemoryDump) {
FakeMemoryAllocatorDumpProvider fmadp;
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::kDetailed};
ProcessMemoryDump pmd(dump_args);
fmadp.OnMemoryDump(dump_args, &pmd);
@ -120,7 +120,7 @@ TEST(MemoryAllocatorDumpTest, DumpIntoProcessMemoryDump) {
}
TEST(MemoryAllocatorDumpTest, GetSize) {
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::kDetailed};
ProcessMemoryDump pmd(dump_args);
MemoryAllocatorDump* dump = pmd.CreateAllocatorDump("allocator_for_size");
dump->AddScalar(MemoryAllocatorDump::kNameSize,
@ -130,7 +130,7 @@ TEST(MemoryAllocatorDumpTest, GetSize) {
}
TEST(MemoryAllocatorDumpTest, ReadValues) {
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::kDetailed};
ProcessMemoryDump pmd(dump_args);
MemoryAllocatorDump* dump = pmd.CreateAllocatorDump("allocator_for_size");
dump->AddScalar("one", "byte", 1);
@ -154,7 +154,7 @@ TEST(MemoryAllocatorDumpTest, MovingAnEntry) {
!BUILDFLAG(IS_FUCHSIA)
TEST(MemoryAllocatorDumpTest, ForbidDuplicatesDeathTest) {
FakeMemoryAllocatorDumpProvider fmadp;
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::kDetailed};
ProcessMemoryDump pmd(dump_args);
pmd.CreateAllocatorDump("foo_allocator");
pmd.CreateAllocatorDump("bar_allocator/heap");
@ -164,7 +164,7 @@ TEST(MemoryAllocatorDumpTest, ForbidDuplicatesDeathTest) {
}
TEST(MemoryAllocatorDumpTest, ForbidStringsInBackgroundModeDeathTest) {
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::BACKGROUND};
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::kBackground};
ProcessMemoryDump pmd(dump_args);
MemoryAllocatorDump* dump = pmd.CreateAllocatorDump("malloc");
ASSERT_DEATH(dump->AddString("foo", "bar", "baz"), "");

@ -314,7 +314,7 @@ void MemoryDumpManager::CreateProcessDump(const MemoryDumpRequestArgs& args,
if (TraceLog::GetInstance()
->GetCurrentTraceConfig()
.IsArgumentFilterEnabled()) {
CHECK_EQ(MemoryDumpLevelOfDetail::BACKGROUND, args.level_of_detail);
CHECK_EQ(MemoryDumpLevelOfDetail::kBackground, args.level_of_detail);
}
std::unique_ptr<ProcessMemoryDumpAsyncState> pmd_async_state;
@ -363,7 +363,7 @@ void MemoryDumpManager::ContinueAsyncProcessDump(
// If we are in background mode, we should invoke only the allowed
// providers. Ignore other providers and continue.
if (pmd_async_state->req_args.level_of_detail ==
MemoryDumpLevelOfDetail::BACKGROUND &&
MemoryDumpLevelOfDetail::kBackground &&
!mdpinfo->allowed_in_background_mode) {
pmd_async_state->pending_dump_providers.pop_back();
continue;
@ -507,11 +507,11 @@ void MemoryDumpManager::SetupForTracing(
MemoryDumpScheduler::Config periodic_config;
for (const auto& trigger : memory_dump_config.triggers) {
if (trigger.trigger_type == MemoryDumpType::PERIODIC_INTERVAL) {
if (trigger.trigger_type == MemoryDumpType::kPeriodicInterval) {
if (periodic_config.triggers.empty()) {
periodic_config.callback =
BindRepeating(&DoGlobalDumpWithoutCallback, request_dump_function_,
MemoryDumpType::PERIODIC_INTERVAL);
MemoryDumpType::kPeriodicInterval);
}
periodic_config.triggers.push_back(
{trigger.level_of_detail, trigger.min_time_between_dumps_ms});

@ -46,19 +46,19 @@ namespace trace_event {
// GTest matchers for MemoryDumpRequestArgs arguments.
MATCHER(IsDetailedDump, "") {
return arg.level_of_detail == MemoryDumpLevelOfDetail::DETAILED;
return arg.level_of_detail == MemoryDumpLevelOfDetail::kDetailed;
}
MATCHER(IsLightDump, "") {
return arg.level_of_detail == MemoryDumpLevelOfDetail::LIGHT;
return arg.level_of_detail == MemoryDumpLevelOfDetail::kLight;
}
MATCHER(IsDeterministicDump, "") {
return arg.determinism == MemoryDumpDeterminism::FORCE_GC;
return arg.determinism == MemoryDumpDeterminism::kForceGc;
}
MATCHER(IsNotDeterministicDump, "") {
return arg.determinism == MemoryDumpDeterminism::NONE;
return arg.determinism == MemoryDumpDeterminism::kNone;
}
namespace {
@ -287,9 +287,9 @@ TEST_F(MemoryDumpManagerTest, SingleDumper) {
EnableForTracing();
EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(3);
for (int i = 0; i < 3; ++i) {
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
}
DisableTracing();
@ -300,9 +300,9 @@ TEST_F(MemoryDumpManagerTest, SingleDumper) {
EnableForTracing();
EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
for (int i = 0; i < 3; ++i) {
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
}
DisableTracing();
}
@ -315,9 +315,9 @@ TEST_F(MemoryDumpManagerTest, CheckMemoryDumpArgs) {
RegisterDumpProvider(&mdp, SingleThreadTaskRunner::GetCurrentDefault());
EnableForTracing();
EXPECT_CALL(mdp, OnMemoryDump(IsDetailedDump(), _));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
DisableTracing();
mdm_->UnregisterDumpProvider(&mdp);
@ -326,9 +326,9 @@ TEST_F(MemoryDumpManagerTest, CheckMemoryDumpArgs) {
RegisterDumpProvider(&mdp, SingleThreadTaskRunner::GetCurrentDefault());
EnableForTracing();
EXPECT_CALL(mdp, OnMemoryDump(IsLightDump(), _));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::LIGHT,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kLight,
MemoryDumpDeterminism::kNone));
DisableTracing();
mdm_->UnregisterDumpProvider(&mdp);
}
@ -341,9 +341,9 @@ TEST_F(MemoryDumpManagerTest, CheckMemoryDumpArgsDeterministic) {
RegisterDumpProvider(&mdp, SingleThreadTaskRunner::GetCurrentDefault());
EnableForTracing();
EXPECT_CALL(mdp, OnMemoryDump(IsDeterministicDump(), _));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::FORCE_GC));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kForceGc));
DisableTracing();
mdm_->UnregisterDumpProvider(&mdp);
@ -352,9 +352,9 @@ TEST_F(MemoryDumpManagerTest, CheckMemoryDumpArgsDeterministic) {
RegisterDumpProvider(&mdp, SingleThreadTaskRunner::GetCurrentDefault());
EnableForTracing();
EXPECT_CALL(mdp, OnMemoryDump(IsNotDeterministicDump(), _));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::LIGHT,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kLight,
MemoryDumpDeterminism::kNone));
DisableTracing();
mdm_->UnregisterDumpProvider(&mdp);
}
@ -369,9 +369,9 @@ TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
EnableForTracing();
EXPECT_CALL(mdp1, OnMemoryDump(_, _));
EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(0);
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
DisableTracing();
// Invert: enable mdp2 and disable mdp1.
@ -380,9 +380,9 @@ TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
EnableForTracing();
EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(0);
EXPECT_CALL(mdp2, OnMemoryDump(_, _));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
DisableTracing();
// Enable both mdp1 and mdp2.
@ -390,9 +390,9 @@ TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
EnableForTracing();
EXPECT_CALL(mdp1, OnMemoryDump(_, _));
EXPECT_CALL(mdp2, OnMemoryDump(_, _));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
DisableTracing();
}
@ -412,9 +412,9 @@ TEST_F(MemoryDumpManagerTest, MAYBE_RegistrationConsistency) {
{
EXPECT_CALL(mdp, OnMemoryDump(_, _));
EnableForTracing();
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
DisableTracing();
}
@ -423,9 +423,9 @@ TEST_F(MemoryDumpManagerTest, MAYBE_RegistrationConsistency) {
{
EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
EnableForTracing();
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
DisableTracing();
}
@ -435,9 +435,9 @@ TEST_F(MemoryDumpManagerTest, MAYBE_RegistrationConsistency) {
{
EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
EnableForTracing();
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
DisableTracing();
}
@ -448,9 +448,9 @@ TEST_F(MemoryDumpManagerTest, MAYBE_RegistrationConsistency) {
{
EXPECT_CALL(mdp, OnMemoryDump(_, _));
EnableForTracing();
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
DisableTracing();
}
}
@ -487,9 +487,9 @@ TEST_F(MemoryDumpManagerTest, RespectTaskRunnerAffinity) {
EnableForTracing();
while (!threads.empty()) {
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
// Unregister a MDP and destroy one thread at each iteration to check the
// live unregistration logic. The unregistration needs to happen on the same
@ -534,16 +534,16 @@ TEST_F(MemoryDumpManagerTest, PostTaskForSequencedTaskRunner) {
EnableForTracing();
task_runner1->set_enabled(false);
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
EXPECT_EQ(1u, task_runner1->no_of_post_tasks());
EXPECT_EQ(1u, task_runner2->no_of_post_tasks());
task_runner1->set_enabled(true);
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
EXPECT_EQ(2u, task_runner1->no_of_post_tasks());
EXPECT_EQ(2u, task_runner2->no_of_post_tasks());
DisableTracing();
@ -573,9 +573,9 @@ TEST_F(MemoryDumpManagerTest, DisableFailingDumpers) {
const int kNumDumps = 2 * GetMaxConsecutiveFailuresCount();
for (int i = 0; i < kNumDumps; i++) {
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
}
DisableTracing();
@ -605,9 +605,9 @@ TEST_F(MemoryDumpManagerTest, RegisterDumperWhileDumping) {
EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(Between(2, 3));
for (int i = 0; i < 4; i++) {
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
}
DisableTracing();
@ -639,9 +639,9 @@ TEST_F(MemoryDumpManagerTest, UnregisterDumperWhileDumping) {
EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(Between(1, 2));
for (int i = 0; i < 4; i++) {
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
}
DisableTracing();
@ -688,9 +688,9 @@ TEST_F(MemoryDumpManagerTest, UnregisterDumperFromThreadWhileDumping) {
}
EnableForTracing();
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
ASSERT_EQ(1, on_memory_dump_call_count);
DisableTracing();
@ -736,9 +736,9 @@ TEST_F(MemoryDumpManagerTest, TearDownThreadWhileDumping) {
}
EnableForTracing();
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
ASSERT_EQ(1, on_memory_dump_call_count);
DisableTracing();
@ -750,9 +750,9 @@ TEST_F(MemoryDumpManagerTest, TriggerDumpWithoutTracing) {
MockMemoryDumpProvider mdp;
RegisterDumpProvider(&mdp, nullptr);
EXPECT_CALL(mdp, OnMemoryDump(_, _));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
}
TEST_F(MemoryDumpManagerTest, BackgroundAllowlisting) {
@ -766,9 +766,9 @@ TEST_F(MemoryDumpManagerTest, BackgroundAllowlisting) {
EnableForTracing();
EXPECT_CALL(backgroundMdp, OnMemoryDump(_, _)).Times(1);
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::SUMMARY_ONLY,
MemoryDumpLevelOfDetail::BACKGROUND,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kSummaryOnly,
MemoryDumpLevelOfDetail::kBackground,
MemoryDumpDeterminism::kNone));
DisableTracing();
}
@ -829,9 +829,9 @@ TEST_F(MemoryDumpManagerTest, UnregisterAndDeleteDumpProviderSoonDuringDump) {
EnableForTracing();
for (int i = 0; i < 2; ++i) {
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
}
DisableTracing();
}
@ -883,15 +883,15 @@ TEST_F(MemoryDumpManagerTest, NoStackOverflowWithTooManyMDPs) {
}
stopped_thread->Stop();
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::BACKGROUND,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::SUMMARY_ONLY,
MemoryDumpLevelOfDetail::BACKGROUND,
MemoryDumpDeterminism::NONE));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kBackground,
MemoryDumpDeterminism::kNone));
EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::kSummaryOnly,
MemoryDumpLevelOfDetail::kBackground,
MemoryDumpDeterminism::kNone));
}
} // namespace trace_event

@ -12,11 +12,11 @@ namespace trace_event {
// static
const char* MemoryDumpTypeToString(const MemoryDumpType& dump_type) {
switch (dump_type) {
case MemoryDumpType::PERIODIC_INTERVAL:
case MemoryDumpType::kPeriodicInterval:
return "periodic_interval";
case MemoryDumpType::EXPLICITLY_TRIGGERED:
case MemoryDumpType::kExplicitlyTriggered:
return "explicitly_triggered";
case MemoryDumpType::SUMMARY_ONLY:
case MemoryDumpType::kSummaryOnly:
return "summary_only";
}
NOTREACHED();
@ -24,24 +24,25 @@ const char* MemoryDumpTypeToString(const MemoryDumpType& dump_type) {
}
MemoryDumpType StringToMemoryDumpType(const std::string& str) {
if (str == "periodic_interval")
return MemoryDumpType::PERIODIC_INTERVAL;
if (str == "periodic_interval") {
return MemoryDumpType::kPeriodicInterval;
}
if (str == "explicitly_triggered")
return MemoryDumpType::EXPLICITLY_TRIGGERED;
return MemoryDumpType::kExplicitlyTriggered;
if (str == "summary_only")
return MemoryDumpType::SUMMARY_ONLY;
return MemoryDumpType::kSummaryOnly;
NOTREACHED();
return MemoryDumpType::LAST;
return MemoryDumpType::kLast;
}
const char* MemoryDumpLevelOfDetailToString(
const MemoryDumpLevelOfDetail& level_of_detail) {
switch (level_of_detail) {
case MemoryDumpLevelOfDetail::BACKGROUND:
case MemoryDumpLevelOfDetail::kBackground:
return "background";
case MemoryDumpLevelOfDetail::LIGHT:
case MemoryDumpLevelOfDetail::kLight:
return "light";
case MemoryDumpLevelOfDetail::DETAILED:
case MemoryDumpLevelOfDetail::kDetailed:
return "detailed";
}
NOTREACHED();
@ -51,13 +52,13 @@ const char* MemoryDumpLevelOfDetailToString(
MemoryDumpLevelOfDetail StringToMemoryDumpLevelOfDetail(
const std::string& str) {
if (str == "background")
return MemoryDumpLevelOfDetail::BACKGROUND;
return MemoryDumpLevelOfDetail::kBackground;
if (str == "light")
return MemoryDumpLevelOfDetail::LIGHT;
return MemoryDumpLevelOfDetail::kLight;
if (str == "detailed")
return MemoryDumpLevelOfDetail::DETAILED;
return MemoryDumpLevelOfDetail::kDetailed;
NOTREACHED();
return MemoryDumpLevelOfDetail::LAST;
return MemoryDumpLevelOfDetail::kLast;
}
} // namespace trace_event

@ -27,41 +27,41 @@ class ProcessMemoryDump;
// consistent with memory_instrumentation.mojo and
// memory_instrumentation_struct_traits.{h,cc}
enum class MemoryDumpType {
PERIODIC_INTERVAL, // Dumping memory at periodic intervals.
EXPLICITLY_TRIGGERED, // Non maskable dump request.
SUMMARY_ONLY, // Calculate just the summary & don't add to the trace.
LAST = SUMMARY_ONLY
kPeriodicInterval, // Dumping memory at periodic intervals.
kExplicitlyTriggered, // Non maskable dump request.
kSummaryOnly, // Calculate just the summary & don't add to the trace.
kLast = kSummaryOnly
};
// Tells the MemoryDumpProvider(s) how much detailed their dumps should be.
// Keep this consistent with memory_instrumentation.mojo and
// memory_instrumentation_struct_traits.{h,cc}
enum class MemoryDumpLevelOfDetail : uint32_t {
FIRST,
kFirst,
// For background tracing mode. The dump time is quick, and typically just the
// totals are expected. Suballocations need not be specified. Dump name must
// contain only pre-defined strings and string arguments cannot be added.
BACKGROUND = FIRST,
kBackground = kFirst,
// For the levels below, MemoryDumpProvider instances must guarantee that the
// total size reported in the root node is consistent. Only the granularity of
// the child MemoryAllocatorDump(s) differs with the levels.
// Few entries, typically a fixed number, per dump.
LIGHT,
kLight,
// Unrestricted amount of entries per dump.
DETAILED,
kDetailed,
LAST = DETAILED
kLast = kDetailed
};
// Tells the MemoryDumpProvider(s) if they should try to make the result
// more deterministic by forcing garbage collection.
// Keep this consistent with memory_instrumentation.mojo and
// memory_instrumentation_struct_traits.{h,cc}
enum class MemoryDumpDeterminism : uint32_t { NONE, FORCE_GC };
enum class MemoryDumpDeterminism : uint32_t { kNone, kForceGc };
// Keep this consistent with memory_instrumentation.mojo and
// memory_instrumentation_struct_traits.{h,cc}

@ -51,13 +51,13 @@ void MemoryDumpScheduler::StartInternal(MemoryDumpScheduler::Config config) {
for (const Config::Trigger& trigger : config.triggers) {
DCHECK_GT(trigger.period_ms, 0u);
switch (trigger.level_of_detail) {
case MemoryDumpLevelOfDetail::BACKGROUND:
case MemoryDumpLevelOfDetail::kBackground:
break;
case MemoryDumpLevelOfDetail::LIGHT:
case MemoryDumpLevelOfDetail::kLight:
DCHECK_EQ(0u, light_dump_period_ms);
light_dump_period_ms = trigger.period_ms;
break;
case MemoryDumpLevelOfDetail::DETAILED:
case MemoryDumpLevelOfDetail::kDetailed:
DCHECK_EQ(0u, heavy_dump_period_ms);
heavy_dump_period_ms = trigger.period_ms;
break;
@ -94,11 +94,12 @@ void MemoryDumpScheduler::Tick(uint32_t expected_generation) {
if (period_ms_ == 0 || generation_ != expected_generation)
return;
MemoryDumpLevelOfDetail level_of_detail = MemoryDumpLevelOfDetail::BACKGROUND;
MemoryDumpLevelOfDetail level_of_detail =
MemoryDumpLevelOfDetail::kBackground;
if (light_dump_rate_ > 0 && tick_count_ % light_dump_rate_ == 0)
level_of_detail = MemoryDumpLevelOfDetail::LIGHT;
level_of_detail = MemoryDumpLevelOfDetail::kLight;
if (heavy_dump_rate_ > 0 && tick_count_ % heavy_dump_rate_ == 0)
level_of_detail = MemoryDumpLevelOfDetail::DETAILED;
level_of_detail = MemoryDumpLevelOfDetail::kDetailed;
tick_count_++;
callback_.Run(level_of_detail);

@ -48,7 +48,7 @@ class MemoryDumpSchedulerTest : public testing::Test {
TEST_F(MemoryDumpSchedulerTest, SingleTrigger) {
const uint32_t kPeriodMs = 1;
const auto kLevelOfDetail = MemoryDumpLevelOfDetail::DETAILED;
const auto kLevelOfDetail = MemoryDumpLevelOfDetail::kDetailed;
const uint32_t kTicks = 5;
MemoryDumpScheduler::Config config;
config.triggers.push_back({kLevelOfDetail, kPeriodMs});
@ -84,8 +84,8 @@ TEST_F(MemoryDumpSchedulerTest, MultipleTriggers) {
const uint32_t kPeriodLightMs = 3;
const uint32_t kPeriodDetailedMs = 9;
MemoryDumpScheduler::Config config;
const MemoryDumpLevelOfDetail kLight = MemoryDumpLevelOfDetail::LIGHT;
const MemoryDumpLevelOfDetail kDetailed = MemoryDumpLevelOfDetail::DETAILED;
const MemoryDumpLevelOfDetail kLight = MemoryDumpLevelOfDetail::kLight;
const MemoryDumpLevelOfDetail kDetailed = MemoryDumpLevelOfDetail::kDetailed;
config.triggers.push_back({kLight, kPeriodLightMs});
config.triggers.push_back({kDetailed, kPeriodDetailedMs});
config.callback =
@ -126,22 +126,22 @@ TEST_F(MemoryDumpSchedulerTest, StartStopQuickly) {
const uint32_t kDetailedTicks = 10;
MemoryDumpScheduler::Config light_config;
light_config.triggers.push_back({MemoryDumpLevelOfDetail::LIGHT, kPeriodMs});
light_config.triggers.push_back({MemoryDumpLevelOfDetail::kLight, kPeriodMs});
light_config.callback =
BindRepeating(&CallbackWrapper::OnTick, Unretained(&on_tick_));
MemoryDumpScheduler::Config detailed_config;
detailed_config.triggers.push_back(
{MemoryDumpLevelOfDetail::DETAILED, kPeriodMs});
{MemoryDumpLevelOfDetail::kDetailed, kPeriodMs});
detailed_config.callback =
BindRepeating(&CallbackWrapper::OnTick, Unretained(&on_tick_));
testing::InSequence sequence;
EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::LIGHT))
EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::kLight))
.Times(AtMost(kQuickIterations));
EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::DETAILED))
EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::kDetailed))
.Times(kDetailedTicks - 1);
EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::DETAILED))
EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::kDetailed))
.WillRepeatedly(
Invoke([this](MemoryDumpLevelOfDetail) { this->evt_.Signal(); }));
@ -165,7 +165,7 @@ TEST_F(MemoryDumpSchedulerTest, StopAndStartOnAnotherThread) {
const uint32_t kPeriodMs = 1;
const uint32_t kTicks = 3;
MemoryDumpScheduler::Config config;
config.triggers.push_back({MemoryDumpLevelOfDetail::DETAILED, kPeriodMs});
config.triggers.push_back({MemoryDumpLevelOfDetail::kDetailed, kPeriodMs});
config.callback =
BindRepeating(&CallbackWrapper::OnTick, Unretained(&on_tick_));

@ -289,7 +289,7 @@ MemoryAllocatorDump* ProcessMemoryDump::AddAllocatorDumpInternal(
std::unique_ptr<MemoryAllocatorDump> mad) {
// In background mode return the black hole dump, if invalid dump name is
// given.
if (dump_args_.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND &&
if (dump_args_.level_of_detail == MemoryDumpLevelOfDetail::kBackground &&
!IsMemoryAllocatorDumpNameInAllowlist(mad->absolute_name())) {
return GetBlackHoleMad(mad->absolute_name());
}
@ -532,8 +532,9 @@ void ProcessMemoryDump::CreateSharedMemoryOwnershipEdgeInternal(
void ProcessMemoryDump::AddSuballocation(const MemoryAllocatorDumpGuid& source,
const std::string& target_node_name) {
// Do not create new dumps for suballocations in background mode.
if (dump_args_.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND)
if (dump_args_.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
return;
}
std::string child_mad_name = target_node_name + "/__" + source.ToString();
MemoryAllocatorDump* target_child_mad = CreateAllocatorDump(child_mad_name);

@ -33,7 +33,7 @@ namespace trace_event {
namespace {
const MemoryDumpArgs kDetailedDumpArgs = {MemoryDumpLevelOfDetail::DETAILED};
const MemoryDumpArgs kDetailedDumpArgs = {MemoryDumpLevelOfDetail::kDetailed};
const char* const kTestDumpNameAllowlist[] = {
"Allowlisted/TestName", "Allowlisted/TestName_0x?",
"Allowlisted/0x?/TestName", "Allowlisted/0x?", nullptr};
@ -71,7 +71,7 @@ TEST(ProcessMemoryDumpTest, MoveConstructor) {
EXPECT_EQ(1u, pmd2.allocator_dumps().count("mad1"));
EXPECT_EQ(1u, pmd2.allocator_dumps().count("mad2"));
EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
EXPECT_EQ(MemoryDumpLevelOfDetail::kDetailed,
pmd2.dump_args().level_of_detail);
EXPECT_EQ(1u, pmd2.allocator_dumps_edges().size());
@ -87,14 +87,14 @@ TEST(ProcessMemoryDumpTest, MoveAssignment) {
pmd1.AddOwnershipEdge(MemoryAllocatorDumpGuid(42),
MemoryAllocatorDumpGuid(4242));
ProcessMemoryDump pmd2({MemoryDumpLevelOfDetail::BACKGROUND});
ProcessMemoryDump pmd2({MemoryDumpLevelOfDetail::kBackground});
pmd2.CreateAllocatorDump("malloc");
pmd2 = std::move(pmd1);
EXPECT_EQ(1u, pmd2.allocator_dumps().count("mad1"));
EXPECT_EQ(1u, pmd2.allocator_dumps().count("mad2"));
EXPECT_EQ(0u, pmd2.allocator_dumps().count("mad3"));
EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
EXPECT_EQ(MemoryDumpLevelOfDetail::kDetailed,
pmd2.dump_args().level_of_detail);
EXPECT_EQ(1u, pmd2.allocator_dumps_edges().size());
@ -379,7 +379,7 @@ TEST(ProcessMemoryDumpTest, SharedMemoryOwnershipTest) {
}
TEST(ProcessMemoryDumpTest, BackgroundModeTest) {
MemoryDumpArgs background_args = {MemoryDumpLevelOfDetail::BACKGROUND};
MemoryDumpArgs background_args = {MemoryDumpLevelOfDetail::kBackground};
std::unique_ptr<ProcessMemoryDump> pmd(
new ProcessMemoryDump(background_args));
ProcessMemoryDump::is_black_hole_non_fatal_for_testing_ = true;
@ -443,7 +443,7 @@ TEST(ProcessMemoryDumpTest, BackgroundModeTest) {
}
TEST(ProcessMemoryDumpTest, GuidsTest) {
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::kDetailed};
const auto process_token_one = UnguessableToken::Create();
const auto process_token_two = UnguessableToken::Create();

@ -87,8 +87,8 @@ class ConvertableTraceConfigToTraceFormat
std::set<MemoryDumpLevelOfDetail> GetDefaultAllowedMemoryDumpModes() {
std::set<MemoryDumpLevelOfDetail> all_modes;
for (uint32_t mode = static_cast<uint32_t>(MemoryDumpLevelOfDetail::FIRST);
mode <= static_cast<uint32_t>(MemoryDumpLevelOfDetail::LAST); mode++) {
for (uint32_t mode = static_cast<uint32_t>(MemoryDumpLevelOfDetail::kFirst);
mode <= static_cast<uint32_t>(MemoryDumpLevelOfDetail::kLast); mode++) {
all_modes.insert(static_cast<MemoryDumpLevelOfDetail>(mode));
}
return all_modes;
@ -576,7 +576,7 @@ void TraceConfig::SetMemoryDumpConfigFromConfigDict(
// If "min_time_between_dumps_ms" param was not given, then the trace
// config uses old format where only periodic dumps are supported.
interval = trigger_dict.FindInt(kPeriodicIntervalLegacyParam);
dump_config.trigger_type = MemoryDumpType::PERIODIC_INTERVAL;
dump_config.trigger_type = MemoryDumpType::kPeriodicInterval;
} else {
const std::string* trigger_type_str =
trigger_dict.FindString(kTriggerTypeParam);

@ -665,12 +665,12 @@ TEST(TraceConfigTest, TraceConfigFromMemoryConfigString) {
EXPECT_EQ(200u,
tc1.memory_dump_config().triggers[0].min_time_between_dumps_ms);
EXPECT_EQ(MemoryDumpLevelOfDetail::LIGHT,
EXPECT_EQ(MemoryDumpLevelOfDetail::kLight,
tc1.memory_dump_config().triggers[0].level_of_detail);
EXPECT_EQ(2000u,
tc1.memory_dump_config().triggers[1].min_time_between_dumps_ms);
EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
EXPECT_EQ(MemoryDumpLevelOfDetail::kDetailed,
tc1.memory_dump_config().triggers[1].level_of_detail);
EXPECT_EQ(
2048u,
@ -684,7 +684,7 @@ TEST(TraceConfigTest, TraceConfigFromMemoryConfigString) {
EXPECT_TRUE(tc3.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
ASSERT_EQ(1u, tc3.memory_dump_config().triggers.size());
EXPECT_EQ(1u, tc3.memory_dump_config().triggers[0].min_time_between_dumps_ms);
EXPECT_EQ(MemoryDumpLevelOfDetail::BACKGROUND,
EXPECT_EQ(MemoryDumpLevelOfDetail::kBackground,
tc3.memory_dump_config().triggers[0].level_of_detail);
}

@ -178,7 +178,7 @@ bool StagingBufferPool::OnMemoryDump(
base::trace_event::ProcessMemoryDump* pmd) {
base::AutoLock lock(lock_);
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name("cc/one_copy/staging_memory");
MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
dump->AddScalar(MemoryAllocatorDump::kNameSize,

@ -570,7 +570,7 @@ void ResourcePool::FlushEvictedResources() {
bool ResourcePool::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name =
base::StringPrintf("cc/tile_memory/provider_0x%x", tracing_id_);
MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);

@ -1872,7 +1872,7 @@ bool GpuImageDecodeCache::OnMemoryDump(
std::string dump_name = base::StringPrintf(
"cc/image_memory/cache_0x%" PRIXPTR, reinterpret_cast<uintptr_t>(this));
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
dump->AddScalar(MemoryAllocatorDump::kNameSize,
MemoryAllocatorDump::kUnitsBytes, working_set_bytes_);

@ -683,7 +683,7 @@ bool SoftwareImageDecodeCache::OnMemoryDump(
base::trace_event::ProcessMemoryDump* pmd) {
base::AutoLock lock(lock_);
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name = base::StringPrintf(
"cc/image_memory/cache_0x%" PRIXPTR, reinterpret_cast<uintptr_t>(this));
MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);

@ -2035,7 +2035,7 @@ void TileManager::SetOverridesForTesting(
bool TileManager::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) {
if (args.level_of_detail !=
base::trace_event::MemoryDumpLevelOfDetail::DETAILED ||
base::trace_event::MemoryDumpLevelOfDetail::kDetailed ||
!resource_pool_) {
return true;
}

@ -1018,7 +1018,7 @@ TEST_F(TileManagerTilePriorityQueueTest, DebugNameAppearsInMemoryDump) {
host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
base::trace_event::ProcessMemoryDump memory_dump(dump_args);
host_impl()->resource_pool()->OnMemoryDump(dump_args, &memory_dump);
bool found_debug_name = false;

@ -378,8 +378,8 @@ IN_PROC_BROWSER_TEST_F(AutocompleteBrowserTest, MemoryTracing) {
base::RunLoop run_loop;
base::trace_event::MemoryDumpRequestArgs args{
1 /* dump_guid*/, base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED,
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND};
1 /* dump_guid*/, base::trace_event::MemoryDumpType::kExplicitlyTriggered,
base::trace_event::MemoryDumpLevelOfDetail::kBackground};
base::trace_event::MemoryDumpManager::GetInstance()->CreateProcessDump(
args,

@ -93,8 +93,8 @@ void OnStartTracingDoneCallback(
base::OnceClosure quit_closure) {
memory_instrumentation::MemoryInstrumentation::GetInstance()
->RequestGlobalDumpAndAppendToTrace(
MemoryDumpType::PERIODIC_INTERVAL, dump_type,
MemoryDumpDeterminism::NONE,
MemoryDumpType::kPeriodicInterval, dump_type,
MemoryDumpDeterminism::kNone,
BindOnce(&RequestGlobalDumpCallback, std::move(quit_closure)));
}
@ -728,7 +728,7 @@ IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
ASSERT_TRUE(tracing::BeginTracingWithTraceConfig(
trace_config,
BindOnce(&OnStartTracingDoneCallback,
base::trace_event::MemoryDumpLevelOfDetail::DETAILED,
base::trace_event::MemoryDumpLevelOfDetail::kDetailed,
run_loop.QuitClosure())));
run_loop.Run();
}
@ -756,7 +756,7 @@ IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
ASSERT_GT(events.size(), 1u);
ASSERT_TRUE(trace_analyzer::CountMatches(
events, trace_analyzer::Query::EventNameIs(
MemoryDumpTypeToString(MemoryDumpType::PERIODIC_INTERVAL))));
MemoryDumpTypeToString(MemoryDumpType::kPeriodicInterval))));
constexpr int kNumRenderers = 2;
EXPECT_EQ(kNumRenderers, GetNumRenderers(browser()));

@ -45,8 +45,8 @@ void OnStartTracingDoneCallback(
base::OnceClosure quit_closure) {
memory_instrumentation::MemoryInstrumentation::GetInstance()
->RequestGlobalDumpAndAppendToTrace(
MemoryDumpType::EXPLICITLY_TRIGGERED, explicit_dump_type,
MemoryDumpDeterminism::NONE,
MemoryDumpType::kExplicitlyTriggered, explicit_dump_type,
MemoryDumpDeterminism::kNone,
BindOnce(&RequestGlobalDumpCallback, std::move(quit_closure)));
}
@ -131,7 +131,7 @@ IN_PROC_BROWSER_TEST_F(MemoryTracingBrowserTest, MAYBE_TestMemoryInfra) {
base::trace_event::TraceConfig(
base::trace_event::TraceConfigMemoryTestUtil::
GetTraceConfig_EmptyTriggers()),
base::trace_event::MemoryDumpLevelOfDetail::DETAILED, &json_events);
base::trace_event::MemoryDumpLevelOfDetail::kDetailed, &json_events);
}
// crbug.com/808152: This test is flakily failing on LSAN. This test also
@ -152,7 +152,7 @@ IN_PROC_BROWSER_TEST_F(MemoryTracingBrowserTest,
base::trace_event::TraceConfig(
base::trace_event::TraceConfigMemoryTestUtil::
GetTraceConfig_BackgroundTrigger(200)),
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND, &json_events);
base::trace_event::MemoryDumpLevelOfDetail::kBackground, &json_events);
}
} // namespace

@ -341,7 +341,7 @@ bool DiscardableSharedMemoryHeap::OnMemoryDump(
base::trace_event::MemoryAllocatorDump::kUnitsBytes,
dirty_freed_memory_page_count_ * base::GetPageSize());
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
// These metrics (size and virtual size) are also reported by each
// individual segment. If we report both, then the counts are artificially
// inflated in detailed dumps, depending on aggregation (for instance, in

@ -329,7 +329,7 @@ TEST(DiscardableSharedMemoryHeapTest, CreateMemoryAllocatorDumpTest) {
// Check if allocator dump is created when span exists.
std::unique_ptr<base::trace_event::ProcessMemoryDump> pmd(
new base::trace_event::ProcessMemoryDump(
{base::trace_event::MemoryDumpLevelOfDetail::DETAILED}));
{base::trace_event::MemoryDumpLevelOfDetail::kDetailed}));
EXPECT_TRUE(heap.CreateMemoryAllocatorDump(span.get(), "discardable/test1",
pmd.get()));
@ -354,7 +354,7 @@ TEST(DiscardableSharedMemoryHeapTest, OnMemoryDumpTest) {
int next_discardable_shared_memory_id = 0;
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND};
base::trace_event::MemoryDumpLevelOfDetail::kBackground};
{
base::trace_event::ProcessMemoryDump pmd(args);
heap.OnMemoryDump(args, &pmd);
@ -423,7 +423,7 @@ TEST(DiscardableSharedMemoryHeapTest, DetailedDumpsDontContainRedundantData) {
DiscardableSharedMemoryHeap heap;
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
size_t block_size = base::GetPageSize();
auto memory = std::make_unique<base::DiscardableSharedMemory>();

@ -336,7 +336,7 @@ bool DiscardableSharedMemoryManager::OnMemoryDump(
const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) {
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
base::trace_event::MemoryAllocatorDump* total_dump =
pmd->CreateAllocatorDump("discardable");
total_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,

@ -170,9 +170,9 @@ void Supervisor::RequestTraceWithHeapDump(TraceFinishedCallback callback,
finished_dump_callback) {
memory_instrumentation::MemoryInstrumentation::GetInstance()
->RequestGlobalDumpAndAppendToTrace(
base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED,
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND,
base::trace_event::MemoryDumpDeterminism::NONE,
base::trace_event::MemoryDumpType::kExplicitlyTriggered,
base::trace_event::MemoryDumpLevelOfDetail::kBackground,
base::trace_event::MemoryDumpDeterminism::kNone,
std::move(finished_dump_callback));
},
std::move(finished_dump_callback));

@ -121,7 +121,7 @@ void InitAllocationRecorder(mojom::ProfilingParamsPtr params) {
case mojom::StackMode::NATIVE_WITH_THREAD_NAMES:
case mojom::StackMode::NATIVE_WITHOUT_THREAD_NAMES:
// This would track task contexts only.
AllocationContextTracker::SetCaptureMode(CaptureMode::NATIVE_STACK);
AllocationContextTracker::SetCaptureMode(CaptureMode::kNativeStack);
break;
}
}

@ -465,7 +465,7 @@ bool LocalStorageImpl::OnMemoryDump(
pmd->AddOwnershipEdge(leveldb_mad->guid(), global_dump->guid(), kImportance);
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
size_t total_cache_size, unused_area_count;
GetStatistics(&total_cache_size, &unused_area_count);
auto* mad = pmd->CreateAllocatorDump(context_name + "/cache_size");

@ -531,7 +531,7 @@ bool SessionStorageImpl::OnMemoryDump(
pmd->AddOwnershipEdge(leveldb_mad->guid(), global_dump->guid(), kImportance);
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
size_t total_cache_size, unused_area_count;
GetStatistics(&total_cache_size, &unused_area_count);
auto* mad = pmd->CreateAllocatorDump(context_name + "/cache_size");

@ -259,7 +259,7 @@ bool TransactionalLevelDBDatabase::OnMemoryDump(
// Dumps in BACKGROUND mode can only have whitelisted strings (and there are
// currently none) so return early.
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
return true;
}

@ -41,8 +41,9 @@ bool GraphicsMemoryDumpProvider::OnMemoryDump(
const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) {
if (args.level_of_detail !=
base::trace_event::MemoryDumpLevelOfDetail::DETAILED)
base::trace_event::MemoryDumpLevelOfDetail::kDetailed) {
return true; // Dump on detailed memory dumps only.
}
const char kAbstractSocketName[] = "chrome_tracing_memtrack_helper";
struct sockaddr_un addr;

@ -20,7 +20,7 @@ TEST(GraphicsMemoryDumpProviderTest, ParseResponse) {
const char* kDumpBaseName = GraphicsMemoryDumpProvider::kDumpBaseName;
base::trace_event::ProcessMemoryDump pmd(
{base::trace_event::MemoryDumpLevelOfDetail::DETAILED});
{base::trace_event::MemoryDumpLevelOfDetail::kDetailed});
auto* instance = GraphicsMemoryDumpProvider::GetInstance();
char buf[] = "graphics_total 12\ngraphics_pss 34\ngl_total 56\ngl_pss 78";
instance->ParseResponseAndAddToDump(buf, strlen(buf), &pmd);

@ -206,10 +206,10 @@ bool TraceStartupConfig::EnableFromCommandLine() {
base::trace_event::MemoryDumpManager::kTraceCategory)) {
base::trace_event::TraceConfig::MemoryDumpConfig memory_config;
memory_config.triggers.push_back(
{10000, base::trace_event::MemoryDumpLevelOfDetail::DETAILED,
base::trace_event::MemoryDumpType::PERIODIC_INTERVAL});
{10000, base::trace_event::MemoryDumpLevelOfDetail::kDetailed,
base::trace_event::MemoryDumpType::kPeriodicInterval});
memory_config.allowed_dump_modes.insert(
base::trace_event::MemoryDumpLevelOfDetail::DETAILED);
base::trace_event::MemoryDumpLevelOfDetail::kDetailed);
trace_config_.ResetMemoryDumpConfig(memory_config);
}

@ -220,11 +220,11 @@ void FillFrameData(base::trace_event::TracedValue* data,
absl::optional<base::trace_event::MemoryDumpLevelOfDetail>
StringToMemoryDumpLevelOfDetail(const std::string& str) {
if (str == Tracing::MemoryDumpLevelOfDetailEnum::Detailed)
return {base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
return {base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
if (str == Tracing::MemoryDumpLevelOfDetailEnum::Background)
return {base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND};
return {base::trace_event::MemoryDumpLevelOfDetail::kBackground};
if (str == Tracing::MemoryDumpLevelOfDetailEnum::Light)
return {base::trace_event::MemoryDumpLevelOfDetail::LIGHT};
return {base::trace_event::MemoryDumpLevelOfDetail::kLight};
return {};
}
@ -1017,8 +1017,8 @@ void TracingHandler::RequestMemoryDump(
}
auto determinism = deterministic.value_or(false)
? base::trace_event::MemoryDumpDeterminism::FORCE_GC
: base::trace_event::MemoryDumpDeterminism::NONE;
? base::trace_event::MemoryDumpDeterminism::kForceGc
: base::trace_event::MemoryDumpDeterminism::kNone;
auto on_memory_dump_finished =
base::BindOnce(&TracingHandler::OnMemoryDumpFinished,
@ -1026,7 +1026,7 @@ void TracingHandler::RequestMemoryDump(
memory_instrumentation::MemoryInstrumentation::GetInstance()
->RequestGlobalDumpAndAppendToTrace(
base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED,
base::trace_event::MemoryDumpType::kExplicitlyTriggered,
*memory_detail, determinism, std::move(on_memory_dump_finished));
}

@ -89,12 +89,12 @@ class MemoryTracingTest : public ContentBrowserTest {
RequestGlobalDumpAndAppendToTrace,
base::Unretained(
memory_instrumentation::MemoryInstrumentation::GetInstance()),
dump_type, level_of_detail, MemoryDumpDeterminism::NONE,
dump_type, level_of_detail, MemoryDumpDeterminism::kNone,
std::move(callback)));
} else {
memory_instrumentation::MemoryInstrumentation::GetInstance()
->RequestGlobalDumpAndAppendToTrace(dump_type, level_of_detail,
MemoryDumpDeterminism::NONE,
MemoryDumpDeterminism::kNone,
std::move(callback));
}
}
@ -209,8 +209,8 @@ IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest,
EnableMemoryTracing();
RequestGlobalDumpAndWait(false /* from_renderer_thread */,
MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED);
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed);
DisableTracing();
}
@ -232,8 +232,8 @@ IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest,
EnableMemoryTracing();
RequestGlobalDumpAndWait(true /* from_renderer_thread */,
MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED);
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed);
DisableTracing();
}
@ -254,17 +254,17 @@ IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest,
EnableMemoryTracing();
RequestGlobalDumpAndWait(true /* from_renderer_thread */,
MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED);
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed);
RequestGlobalDumpAndWait(false /* from_renderer_thread */,
MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED);
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed);
RequestGlobalDumpAndWait(false /* from_renderer_thread */,
MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED);
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed);
RequestGlobalDumpAndWait(true /* from_renderer_thread */,
MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED);
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed);
DisableTracing();
}
@ -288,7 +288,7 @@ IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest, DISABLED_QueuedDumps) {
// 5 (ED) req--------->ok
// 6 (PL) req->ok
//
// where P=PERIODIC_INTERVAL, E=EXPLICITLY_TRIGGERED, D=DETAILED and L=LIGHT.
// where P=kPeriodicInterval, E=kExplicitlyTriggered, D=kDetailed and L=kLight.
EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_, _))
.Times(5)
@ -296,42 +296,42 @@ IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest, DISABLED_QueuedDumps) {
EXPECT_CALL(*this, OnMemoryDumpDone(0, true /* success */));
RequestGlobalDump(true /* from_renderer_thread */,
MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED);
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed);
// This dump should fail immediately because there's already a detailed dump
// request in the queue.
EXPECT_CALL(*this, OnMemoryDumpDone(1, false /* success */));
RequestGlobalDump(true /* from_renderer_thread */,
MemoryDumpType::PERIODIC_INTERVAL,
MemoryDumpLevelOfDetail::DETAILED);
MemoryDumpType::kPeriodicInterval,
MemoryDumpLevelOfDetail::kDetailed);
EXPECT_CALL(*this, OnMemoryDumpDone(2, true /* success */));
RequestGlobalDump(true /* from_renderer_thread */,
MemoryDumpType::PERIODIC_INTERVAL,
MemoryDumpLevelOfDetail::LIGHT);
MemoryDumpType::kPeriodicInterval,
MemoryDumpLevelOfDetail::kLight);
// This dump should fail immediately because there's already a light dump
// request in the queue.
EXPECT_CALL(*this, OnMemoryDumpDone(3, false /* success */));
RequestGlobalDump(true /* from_renderer_thread */,
MemoryDumpType::PERIODIC_INTERVAL,
MemoryDumpLevelOfDetail::LIGHT);
MemoryDumpType::kPeriodicInterval,
MemoryDumpLevelOfDetail::kLight);
EXPECT_CALL(*this, OnMemoryDumpDone(4, true /* success */));
RequestGlobalDump(true /* from_renderer_thread */,
MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::LIGHT);
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kLight);
EXPECT_CALL(*this, OnMemoryDumpDone(5, true /* success */));
RequestGlobalDumpAndWait(true /* from_renderer_thread */,
MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED);
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed);
EXPECT_CALL(*this, OnMemoryDumpDone(6, true /* success */));
RequestGlobalDumpAndWait(true /* from_renderer_thread */,
MemoryDumpType::PERIODIC_INTERVAL,
MemoryDumpLevelOfDetail::LIGHT);
MemoryDumpType::kPeriodicInterval,
MemoryDumpLevelOfDetail::kLight);
DisableTracing();
}
@ -366,8 +366,8 @@ IN_PROC_BROWSER_TEST_F(MemoryTracingTest, MAYBE_BrowserInitiatedDump) {
EnableMemoryTracing();
RequestGlobalDumpAndWait(false /* from_renderer_thread */,
MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED);
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed);
DisableTracing();
}

@ -69,7 +69,7 @@ TEST_F(TracingUITest, ConfigParsing) {
EXPECT_EQ(config.memory_dump_config().triggers[0].min_time_between_dumps_ms,
10000u);
EXPECT_EQ(config.memory_dump_config().triggers[0].level_of_detail,
base::trace_event::MemoryDumpLevelOfDetail::DETAILED);
base::trace_event::MemoryDumpLevelOfDetail::kDetailed);
}
} // namespace content

@ -134,9 +134,9 @@ WebEngineMemoryInspector::ResolveMemoryDumpPromise(fpromise::context& context) {
DCHECK(coordinator);
coordinator->RequestGlobalMemoryDump(
base::trace_event::MemoryDumpType::SUMMARY_ONLY,
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND,
base::trace_event::MemoryDumpDeterminism::NONE, AllocatorDumpNames(),
base::trace_event::MemoryDumpType::kSummaryOnly,
base::trace_event::MemoryDumpLevelOfDetail::kBackground,
base::trace_event::MemoryDumpDeterminism::kNone, AllocatorDumpNames(),
base::BindOnce(&WebEngineMemoryInspector::OnMemoryDumpComplete,
weak_this_.GetMutableWeakPtr(), base::TimeTicks::Now(),
context.suspend_task()));

@ -164,7 +164,7 @@ bool CanHaveMultipleIsolates(IsolateHolder::IsolateType isolate_type) {
void V8IsolateMemoryDumpProvider::DumpHeapStatistics(
const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* process_memory_dump) {
if (args.determinism == base::trace_event::MemoryDumpDeterminism::FORCE_GC) {
if (args.determinism == base::trace_event::MemoryDumpDeterminism::kForceGc) {
// Force GC in V8 using the same API as DevTools uses in "collectGarbage".
isolate_holder_->isolate()->LowMemoryNotification();
}
@ -282,7 +282,7 @@ void V8IsolateMemoryDumpProvider::DumpHeapStatistics(
// Dump object statistics only for detailed dumps.
if (args.level_of_detail !=
base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {
base::trace_event::MemoryDumpLevelOfDetail::kDetailed) {
return;
}

@ -41,7 +41,7 @@ class V8MemoryDumpProviderWorkerTest : public V8MemoryDumpProviderTest {
// Checks if the dump provider runs without crashing and dumps root objects.
TEST_F(V8MemoryDumpProviderTest, DumpStatistics) {
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
new base::trace_event::ProcessMemoryDump(dump_args));
instance_->isolate_memory_dump_provider_for_testing()->OnMemoryDump(
@ -72,7 +72,7 @@ TEST_F(V8MemoryDumpProviderTest, DumpStatistics) {
TEST_F(V8MemoryDumpProviderTest, DumpGlobalHandlesSize) {
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND};
base::trace_event::MemoryDumpLevelOfDetail::kBackground};
std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
new base::trace_event::ProcessMemoryDump(dump_args));
instance_->isolate_memory_dump_provider_for_testing()->OnMemoryDump(
@ -93,7 +93,7 @@ TEST_F(V8MemoryDumpProviderTest, DumpGlobalHandlesSize) {
TEST_F(V8MemoryDumpProviderTest, DumpContextStatistics) {
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::LIGHT};
base::trace_event::MemoryDumpLevelOfDetail::kLight};
std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
new base::trace_event::ProcessMemoryDump(dump_args));
instance_->isolate_memory_dump_provider_for_testing()->OnMemoryDump(
@ -119,7 +119,7 @@ TEST_F(V8MemoryDumpProviderTest, DumpContextStatistics) {
TEST_F(V8MemoryDumpProviderWorkerTest, DumpContextStatistics) {
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::LIGHT};
base::trace_event::MemoryDumpLevelOfDetail::kLight};
std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
new base::trace_event::ProcessMemoryDump(dump_args));
instance_->isolate_memory_dump_provider_for_testing()->OnMemoryDump(
@ -151,7 +151,7 @@ TEST_F(V8MemoryDumpProviderTest, DumpCodeStatistics) {
base::trace_event::TraceLog::RECORDING_MODE);
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::LIGHT};
base::trace_event::MemoryDumpLevelOfDetail::kLight};
std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
new base::trace_event::ProcessMemoryDump(dump_args));
instance_->isolate_memory_dump_provider_for_testing()->OnMemoryDump(
@ -192,8 +192,8 @@ TEST_F(V8MemoryDumpProviderTest, DumpCodeStatistics) {
// Tests that a deterministic memory dump request performs a GC.
TEST_F(V8MemoryDumpProviderTest, Deterministic) {
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::LIGHT,
base::trace_event::MemoryDumpDeterminism::FORCE_GC};
base::trace_event::MemoryDumpLevelOfDetail::kLight,
base::trace_event::MemoryDumpDeterminism::kForceGc};
std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
new base::trace_event::ProcessMemoryDump(dump_args));

@ -20,7 +20,7 @@ TEST_F(V8SharedMemoryDumpProviderTest, DumpStatistics) {
V8SharedMemoryDumpProvider provider;
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
new base::trace_event::ProcessMemoryDump(dump_args));
provider.OnMemoryDump(dump_args, process_memory_dump.get());

@ -386,7 +386,7 @@ bool CommandBufferHelper::OnMemoryDump(
dump->AddScalar(MemoryAllocatorDump::kNameSize,
MemoryAllocatorDump::kUnitsBytes, ring_buffer_size_);
if (args.level_of_detail != MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail != MemoryDumpLevelOfDetail::kBackground) {
dump->AddScalar(
"free_size", MemoryAllocatorDump::kUnitsBytes,
GetTotalFreeEntriesNoWaiting() * sizeof(CommandBufferEntry));

@ -209,7 +209,7 @@ bool ImplementationBase::OnMemoryDump(
MemoryAllocatorDump::kUnitsBytes,
transfer_buffer_->GetSize());
if (args.level_of_detail != MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail != MemoryDumpLevelOfDetail::kBackground) {
dump->AddScalar("free_size", MemoryAllocatorDump::kUnitsBytes,
transfer_buffer_->GetFragmentedFreeSize());
auto shared_memory_guid = transfer_buffer_->shared_memory_guid();

@ -171,7 +171,7 @@ bool MappedMemoryManager::OnMemoryDump(
using base::trace_event::MemoryAllocatorDump;
using base::trace_event::MemoryDumpLevelOfDetail;
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name =
base::StringPrintf("gpu/mapped_memory/manager_%d", tracing_id_);
MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);

@ -757,7 +757,7 @@ bool BufferManager::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
using base::trace_event::MemoryAllocatorDump;
using base::trace_event::MemoryDumpLevelOfDetail;
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name =
base::StringPrintf("gpu/gl/buffers/context_group_0x%" PRIX64 "",
memory_tracker_->ContextGroupTracingId());

@ -54,7 +54,7 @@ bool PassthroughDiscardableManager::OnMemoryDump(
using base::trace_event::MemoryAllocatorDump;
using base::trace_event::MemoryDumpLevelOfDetail;
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name =
base::StringPrintf("gpu/discardable_cache/cache_0x%" PRIXPTR,
reinterpret_cast<uintptr_t>(this));

@ -330,7 +330,7 @@ bool RenderbufferManager::OnMemoryDump(
const uint64_t context_group_tracing_id =
memory_tracker_->ContextGroupTracingId();
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name =
base::StringPrintf("gpu/gl/renderbuffers/context_group_0x%" PRIX64,
context_group_tracing_id);

@ -113,7 +113,7 @@ bool ServiceDiscardableManager::OnMemoryDump(
using base::trace_event::MemoryAllocatorDump;
using base::trace_event::MemoryDumpLevelOfDetail;
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name =
base::StringPrintf("gpu/discardable_cache/cache_0x%" PRIXPTR,
reinterpret_cast<uintptr_t>(this));

@ -351,7 +351,7 @@ bool ServiceTransferCache::OnMemoryDump(
using base::trace_event::MemoryAllocatorDump;
using base::trace_event::MemoryDumpLevelOfDetail;
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name =
base::StringPrintf("gpu/transfer_cache/cache_0x%" PRIXPTR,
reinterpret_cast<uintptr_t>(this));

@ -682,7 +682,7 @@ bool SharedContextState::OnMemoryDump(
return true;
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
raster::DumpBackgroundGrMemoryStatistics(gr_context_, pmd);
} else {
raster::DumpGrMemoryStatistics(gr_context_, pmd, absl::nullopt);

@ -447,7 +447,7 @@ bool SharedImageManager::OnMemoryDump(
const char* base_dump_name = "gpu/shared_images";
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
size_t total_size = 0;
size_t total_purgeable_size = 0;
for (auto& backing : images_) {

@ -89,7 +89,7 @@ TEST(SharedImageManagerTest, MemoryDumps) {
manager.Register(CreateImageBacking(kSizeBytes2), tracker.get());
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND};
base::trace_event::MemoryDumpLevelOfDetail::kBackground};
base::trace_event::ProcessMemoryDump pmd(args);
manager.OnMemoryDump(args, &pmd);

@ -3552,7 +3552,7 @@ bool TextureManager::CombineAdjacentRects(const gfx::Rect& rect1,
bool TextureManager::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name =
base::StringPrintf("gpu/gl/textures/context_group_0x%" PRIX64,
memory_tracker_->ContextGroupTracingId());

@ -102,7 +102,7 @@ bool TransferBufferManager::OnMemoryDump(
using base::trace_event::MemoryAllocatorDump;
using base::trace_event::MemoryDumpLevelOfDetail;
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
if (args.level_of_detail == MemoryDumpLevelOfDetail::kBackground) {
std::string dump_name = base::StringPrintf("gpu/transfer_memory/client_%d",
memory_tracker_->ClientId());
MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);

@ -569,9 +569,9 @@ class ImageDecodeAcceleratorStubTest
base::trace_event::MemoryDumpRequestArgs dump_args{};
dump_args.dump_guid = 1234u;
dump_args.dump_type =
base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED;
base::trace_event::MemoryDumpType::kExplicitlyTriggered;
dump_args.level_of_detail = detail_level;
dump_args.determinism = base::trace_event::MemoryDumpDeterminism::FORCE_GC;
dump_args.determinism = base::trace_event::MemoryDumpDeterminism::kForceGc;
std::unique_ptr<base::trace_event::ProcessMemoryDump> dump;
base::RunLoop run_loop;
base::trace_event::MemoryDumpManager::GetInstance()->CreateProcessDump(
@ -604,7 +604,7 @@ class ImageDecodeAcceleratorStubTest
base::StringPrintf("gpu/transfer_cache/cache_0x%" PRIXPTR,
reinterpret_cast<uintptr_t>(cache));
if (detail_level ==
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
auto transfer_cache_dump_it =
dump->allocator_dumps().find(transfer_cache_dump_name);
ASSERT_NE(dump->allocator_dumps().end(), transfer_cache_dump_it);
@ -622,7 +622,7 @@ class ImageDecodeAcceleratorStubTest
GetMemoryDumpByteSize(avg_image_size_dump_it->second.get(),
"average_size"));
} else {
DCHECK_EQ(base::trace_event::MemoryDumpLevelOfDetail::DETAILED,
DCHECK_EQ(base::trace_event::MemoryDumpLevelOfDetail::kDetailed,
detail_level);
base::CheckedNumeric<uint64_t> safe_actual_transfer_cache_total_size(0u);
std::string entry_dump_prefix =
@ -1008,7 +1008,7 @@ TEST_P(ImageDecodeAcceleratorStubTest, MemoryReportDetailedForUnmippedDecode) {
RunSimpleDecode(false /* needs_mips */);
ASSERT_TRUE(decode_entry);
ExpectProcessMemoryDump(
base::trace_event::MemoryDumpLevelOfDetail::DETAILED,
base::trace_event::MemoryDumpLevelOfDetail::kDetailed,
base::strict_cast<uint64_t>(
kDecodedBufferByteSize) /* expected_total_transfer_cache_size */,
0u /* expected_total_skia_gpu_resources_size */,
@ -1021,7 +1021,7 @@ TEST_P(ImageDecodeAcceleratorStubTest,
RunSimpleDecode(false /* needs_mips */);
ASSERT_TRUE(decode_entry);
ExpectProcessMemoryDump(
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND,
base::trace_event::MemoryDumpLevelOfDetail::kBackground,
base::strict_cast<uint64_t>(
kDecodedBufferByteSize) /* expected_total_transfer_cache_size */,
0u /* expected_total_skia_gpu_resources_size */,
@ -1039,7 +1039,7 @@ TEST_P(ImageDecodeAcceleratorStubTest, MemoryReportDetailedForMippedDecode) {
GetExpectedTotalMippedSizeForPlanarImage(decode_entry);
ASSERT_TRUE(safe_expected_total_transfer_cache_size.IsValid());
ExpectProcessMemoryDump(
base::trace_event::MemoryDumpLevelOfDetail::DETAILED,
base::trace_event::MemoryDumpLevelOfDetail::kDetailed,
safe_expected_total_transfer_cache_size.ValueOrDie(),
kSkiaBufferObjectSize /* expected_total_skia_gpu_resources_size */,
0u /* expected_avg_image_size */);
@ -1055,7 +1055,7 @@ TEST_P(ImageDecodeAcceleratorStubTest, MemoryReportBackgroundForMippedDecode) {
GetExpectedTotalMippedSizeForPlanarImage(decode_entry);
ASSERT_TRUE(safe_expected_total_transfer_cache_size.IsValid());
ExpectProcessMemoryDump(
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND,
base::trace_event::MemoryDumpLevelOfDetail::kBackground,
safe_expected_total_transfer_cache_size.ValueOrDie(),
kSkiaBufferObjectSize,
safe_expected_total_transfer_cache_size
@ -1074,7 +1074,7 @@ TEST_P(ImageDecodeAcceleratorStubTest,
GetExpectedTotalMippedSizeForPlanarImage(decode_entry);
ASSERT_TRUE(safe_expected_total_transfer_cache_size.IsValid());
ExpectProcessMemoryDump(
base::trace_event::MemoryDumpLevelOfDetail::DETAILED,
base::trace_event::MemoryDumpLevelOfDetail::kDetailed,
safe_expected_total_transfer_cache_size.ValueOrDie(),
kSkiaBufferObjectSize /* expected_total_skia_gpu_resources_size */,
0u /* expected_avg_image_size */);
@ -1091,7 +1091,7 @@ TEST_P(ImageDecodeAcceleratorStubTest,
// For a deferred mip request, the transfer cache doesn't update its size
// computation, so it reports memory as if no mips had been generated.
ExpectProcessMemoryDump(
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND,
base::trace_event::MemoryDumpLevelOfDetail::kBackground,
base::strict_cast<uint64_t>(
kDecodedBufferByteSize) /* expected_total_transfer_cache_size */,
kSkiaBufferObjectSize,

@ -290,7 +290,7 @@ TEST(HandleTableTest, OnMemoryDump) {
}
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
base::trace_event::ProcessMemoryDump pmd(args);
ht.OnMemoryDump(args, &pmd);

@ -247,8 +247,8 @@ TEST_F(URLRequestQuicPerfTest, MAYBE_TestGetRequest) {
base::RunLoop run_loop;
base::trace_event::MemoryDumpRequestArgs args{
1 /* dump_guid*/, base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED,
base::trace_event::MemoryDumpLevelOfDetail::LIGHT};
1 /* dump_guid*/, base::trace_event::MemoryDumpType::kExplicitlyTriggered,
base::trace_event::MemoryDumpLevelOfDetail::kLight};
auto on_memory_dump_done =
[](base::OnceClosure quit_closure, const URLRequestContext* context,

@ -16,7 +16,7 @@ TEST(ChromeGraphProcessorTest, CreateMemoryGraphWithNoneOperation) {
ChromeGraphProcessor::MemoryDumpMap process_dumps;
base::trace_event::MemoryDumpArgs dump_args = {
.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
base::trace_event::ProcessMemoryDump pmd(dump_args);
auto* source = pmd.CreateAllocatorDump("test1/test2/test3");
@ -74,7 +74,7 @@ TEST(ChromeGraphProcessorTest, CreateMemoryGraphWithAllOperations) {
ChromeGraphProcessor::MemoryDumpMap process_dumps;
base::trace_event::MemoryDumpArgs dump_args = {
.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
base::trace_event::ProcessMemoryDump pmd(dump_args);
auto* source = pmd.CreateAllocatorDump("test1/test2/test3");

@ -152,9 +152,9 @@ void CoordinatorImpl::RequestGlobalMemoryDumpForPid(
};
QueuedRequest::Args args(
base::trace_event::MemoryDumpType::SUMMARY_ONLY,
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND,
base::trace_event::MemoryDumpDeterminism::NONE, allocator_dump_names,
base::trace_event::MemoryDumpType::kSummaryOnly,
base::trace_event::MemoryDumpLevelOfDetail::kBackground,
base::trace_event::MemoryDumpDeterminism::kNone, allocator_dump_names,
false /* add_to_trace */, pid,
/*memory_footprint_only=*/false);
RequestGlobalMemoryDumpInternal(args,
@ -173,9 +173,9 @@ void CoordinatorImpl::RequestPrivateMemoryFootprint(
};
QueuedRequest::Args args(
base::trace_event::MemoryDumpType::SUMMARY_ONLY,
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND,
base::trace_event::MemoryDumpDeterminism::NONE, {},
base::trace_event::MemoryDumpType::kSummaryOnly,
base::trace_event::MemoryDumpLevelOfDetail::kBackground,
base::trace_event::MemoryDumpDeterminism::kNone, {},
false /* add_to_trace */, pid, /*memory_footprint_only=*/true);
RequestGlobalMemoryDumpInternal(args,
base::BindOnce(adapter, std::move(callback)));
@ -286,7 +286,7 @@ void CoordinatorImpl::RequestGlobalMemoryDumpInternal(
// another request in the queue with the same level of detail, there's no
// point in enqueuing this request.
if (another_dump_is_queued &&
args.dump_type == MemoryDumpType::PERIODIC_INTERVAL) {
args.dump_type == MemoryDumpType::kPeriodicInterval) {
for (const auto& request : queued_memory_dump_requests_) {
if (request.args.level_of_detail == args.level_of_detail) {
VLOG(1) << "RequestGlobalMemoryDump("

@ -96,8 +96,8 @@ class CoordinatorImplTest : public testing::Test {
void RequestGlobalMemoryDump(RequestGlobalMemoryDumpCallback callback) {
RequestGlobalMemoryDump(
MemoryDumpType::SUMMARY_ONLY, MemoryDumpLevelOfDetail::BACKGROUND,
MemoryDumpDeterminism::NONE, {}, std::move(callback));
MemoryDumpType::kSummaryOnly, MemoryDumpLevelOfDetail::kBackground,
MemoryDumpDeterminism::kNone, {}, std::move(callback));
}
void RequestGlobalMemoryDump(
@ -122,8 +122,9 @@ class CoordinatorImplTest : public testing::Test {
void RequestGlobalMemoryDumpAndAppendToTrace(
RequestGlobalMemoryDumpAndAppendToTraceCallback callback) {
coordinator_->RequestGlobalMemoryDumpAndAppendToTrace(
MemoryDumpType::EXPLICITLY_TRIGGERED, MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE, std::move(callback));
MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed, MemoryDumpDeterminism::kNone,
std::move(callback));
}
void GetVmRegionsForHeapProfiler(
@ -167,7 +168,7 @@ class MockClientProcess : public mojom::ClientProcess {
ON_CALL(*this, RequestChromeMemoryDumpMock(_, _))
.WillByDefault(Invoke([pid](const MemoryDumpRequestArgs& args,
RequestChromeMemoryDumpCallback& callback) {
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::kDetailed};
auto pmd = std::make_unique<ProcessMemoryDump>(dump_args);
auto* mad = pmd->CreateAllocatorDump(
"malloc", base::trace_event::MemoryAllocatorDumpGuid(pid));
@ -329,7 +330,7 @@ TEST_F(CoordinatorImplTest, QueuedRequest) {
// Skip the wall clock time-ticks forward to make sure start_time
// is strictly increasing.
task_environment->FastForwardBy(base::Milliseconds(10));
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::kDetailed};
auto pmd = std::make_unique<ProcessMemoryDump>(dump_args);
std::move(callback).Run(true, args.dump_guid, std::move(pmd));
}));
@ -367,7 +368,7 @@ TEST_F(CoordinatorImplTest, MissingChromeDump) {
.WillOnce(Invoke(
[](const MemoryDumpRequestArgs& args,
MockClientProcess::RequestChromeMemoryDumpCallback& callback) {
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::kDetailed};
auto pmd = std::make_unique<ProcessMemoryDump>(dump_args);
std::move(callback).Run(true, args.dump_guid, std::move(pmd));
}));
@ -582,7 +583,7 @@ TEST_F(CoordinatorImplTest, GlobalMemoryDumpStruct) {
.WillOnce(Invoke([](const MemoryDumpRequestArgs& args,
MockClientProcess::RequestChromeMemoryDumpCallback&
callback) {
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::kDetailed};
auto pmd = std::make_unique<ProcessMemoryDump>(dump_args);
auto* size = MemoryAllocatorDump::kNameSize;
auto* bytes = MemoryAllocatorDump::kUnitsBytes;
@ -622,7 +623,7 @@ TEST_F(CoordinatorImplTest, GlobalMemoryDumpStruct) {
.WillOnce(Invoke(
[](const MemoryDumpRequestArgs& args,
MockClientProcess::RequestChromeMemoryDumpCallback& callback) {
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::kDetailed};
auto pmd = std::make_unique<ProcessMemoryDump>(dump_args);
auto* mad = pmd->CreateAllocatorDump(
"malloc", base::trace_event::MemoryAllocatorDumpGuid(2));
@ -800,7 +801,7 @@ TEST_F(CoordinatorImplTest, DumpsArentAddedToTraceUnlessRequested) {
.WillOnce(Invoke(
[](const MemoryDumpRequestArgs& args,
MockClientProcess::RequestChromeMemoryDumpCallback& callback) {
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::kDetailed};
auto pmd = std::make_unique<ProcessMemoryDump>(dump_args);
std::move(callback).Run(true, args.dump_guid, std::move(pmd));
}));
@ -816,9 +817,9 @@ TEST_F(CoordinatorImplTest, DumpsArentAddedToTraceUnlessRequested) {
std::string(MemoryDumpManager::kTraceCategory) + ",-*",
base::trace_event::RECORD_UNTIL_FULL);
data_source_tester.BeginTrace(trace_config);
RequestGlobalMemoryDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED,
MemoryDumpDeterminism::NONE, {}, callback.Get());
RequestGlobalMemoryDump(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed,
MemoryDumpDeterminism::kNone, {}, callback.Get());
run_loop.Run();
data_source_tester.EndTracing();
@ -841,7 +842,7 @@ TEST_F(CoordinatorImplTest, DISABLED_DumpsAreAddedToTraceWhenRequested) {
.WillOnce(Invoke(
[](const MemoryDumpRequestArgs& args,
MockClientProcess::RequestChromeMemoryDumpCallback& callback) {
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::kDetailed};
auto pmd = std::make_unique<ProcessMemoryDump>(dump_args);
std::move(callback).Run(true, args.dump_guid, std::move(pmd));
}));
@ -979,7 +980,7 @@ TEST_F(CoordinatorImplTest, GlobalDumpWithSubTrees) {
.WillOnce(Invoke(
[](const MemoryDumpRequestArgs& args,
MockClientProcess::RequestChromeMemoryDumpCallback& callback) {
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args{MemoryDumpLevelOfDetail::kDetailed};
auto pmd = std::make_unique<ProcessMemoryDump>(dump_args);
auto* size = MemoryAllocatorDump::kNameSize;
auto* bytes = MemoryAllocatorDump::kUnitsBytes;
@ -1036,9 +1037,10 @@ TEST_F(CoordinatorImplTest, GlobalDumpWithSubTrees) {
base::test::TestFuture<bool,
memory_instrumentation::mojom::GlobalMemoryDumpPtr>
result;
RequestGlobalMemoryDump(
MemoryDumpType::SUMMARY_ONLY, MemoryDumpLevelOfDetail::BACKGROUND,
MemoryDumpDeterminism::NONE, {"partition_alloc/*"}, result.GetCallback());
RequestGlobalMemoryDump(MemoryDumpType::kSummaryOnly,
MemoryDumpLevelOfDetail::kBackground,
MemoryDumpDeterminism::kNone, {"partition_alloc/*"},
result.GetCallback());
// Expect that the dump request succeeds.
ASSERT_TRUE(std::get<bool>(result.Get()));

@ -54,11 +54,11 @@ perfetto::trace_processor::LevelOfDetail
MemoryDumpMapConverter::ConvertLevelOfDetail(
const base::trace_event::MemoryDumpLevelOfDetail& input) const {
switch (input) {
case base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND:
case base::trace_event::MemoryDumpLevelOfDetail::kBackground:
return perfetto::trace_processor::LevelOfDetail::kBackground;
case base::trace_event::MemoryDumpLevelOfDetail::LIGHT:
case base::trace_event::MemoryDumpLevelOfDetail::kLight:
return perfetto::trace_processor::LevelOfDetail::kLight;
case base::trace_event::MemoryDumpLevelOfDetail::DETAILED:
case base::trace_event::MemoryDumpLevelOfDetail::kDetailed:
return perfetto::trace_processor::LevelOfDetail::kDetailed;
}
return perfetto::trace_processor::LevelOfDetail::kDetailed;

@ -17,7 +17,7 @@ using base::trace_event::ProcessMemoryDump;
TEST(MemoryDumpMapConverter, Convert) {
MemoryDumpMapConverter::MemoryDumpMap process_dumps;
MemoryDumpArgs dump_args1 = {MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpArgs dump_args1 = {MemoryDumpLevelOfDetail::kDetailed};
ProcessMemoryDump pmd1(dump_args1);
auto* source1 = pmd1.CreateAllocatorDump("test1/test2/test3");
@ -31,7 +31,7 @@ TEST(MemoryDumpMapConverter, Convert) {
process_dumps.emplace(1, &pmd1);
MemoryDumpArgs dump_args2 = {MemoryDumpLevelOfDetail::LIGHT};
MemoryDumpArgs dump_args2 = {MemoryDumpLevelOfDetail::kLight};
ProcessMemoryDump pmd2(dump_args2);
auto* source2 = pmd2.CreateAllocatorDump("test1/test4/test5");

@ -88,13 +88,13 @@ struct QueuedRequest {
mojom::MemoryMapOption memory_map_option() const {
return args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::DETAILED
base::trace_event::MemoryDumpLevelOfDetail::kDetailed
? mojom::MemoryMapOption::FULL
: mojom::MemoryMapOption::NONE;
}
bool should_return_summaries() const {
return args.dump_type == base::trace_event::MemoryDumpType::SUMMARY_ONLY;
return args.dump_type == base::trace_event::MemoryDumpType::kSummaryOnly;
}
const Args args;

@ -136,7 +136,7 @@ void ClientProcessImpl::RequestGlobalMemoryDump_NoCallback(
coordinator = MemoryInstrumentation::GetInstance()->GetCoordinator();
coordinator->RequestGlobalMemoryDumpAndAppendToTrace(
dump_type, level_of_detail,
base::trace_event::MemoryDumpDeterminism::NONE,
base::trace_event::MemoryDumpDeterminism::kNone,
mojom::Coordinator::RequestGlobalMemoryDumpAndAppendToTraceCallback());
}

@ -48,8 +48,8 @@ void MemoryInstrumentation::RequestGlobalDump(
RequestGlobalDumpCallback callback) {
CHECK(is_browser_process_);
coordinator_->RequestGlobalMemoryDump(
MemoryDumpType::SUMMARY_ONLY, MemoryDumpLevelOfDetail::BACKGROUND,
MemoryDumpDeterminism::NONE, allocator_dump_names,
MemoryDumpType::kSummaryOnly, MemoryDumpLevelOfDetail::kBackground,
MemoryDumpDeterminism::kNone, allocator_dump_names,
base::BindOnce(&WrapGlobalMemoryDump, std::move(callback)));
}

@ -14,11 +14,11 @@ EnumTraits<memory_instrumentation::mojom::DumpType,
base::trace_event::MemoryDumpType>::
ToMojom(base::trace_event::MemoryDumpType type) {
switch (type) {
case base::trace_event::MemoryDumpType::PERIODIC_INTERVAL:
case base::trace_event::MemoryDumpType::kPeriodicInterval:
return memory_instrumentation::mojom::DumpType::PERIODIC_INTERVAL;
case base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED:
case base::trace_event::MemoryDumpType::kExplicitlyTriggered:
return memory_instrumentation::mojom::DumpType::EXPLICITLY_TRIGGERED;
case base::trace_event::MemoryDumpType::SUMMARY_ONLY:
case base::trace_event::MemoryDumpType::kSummaryOnly:
return memory_instrumentation::mojom::DumpType::SUMMARY_ONLY;
default:
CHECK(false) << "Invalid type: " << static_cast<uint8_t>(type);
@ -34,13 +34,13 @@ bool EnumTraits<memory_instrumentation::mojom::DumpType,
base::trace_event::MemoryDumpType* out) {
switch (input) {
case memory_instrumentation::mojom::DumpType::PERIODIC_INTERVAL:
*out = base::trace_event::MemoryDumpType::PERIODIC_INTERVAL;
*out = base::trace_event::MemoryDumpType::kPeriodicInterval;
break;
case memory_instrumentation::mojom::DumpType::EXPLICITLY_TRIGGERED:
*out = base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED;
*out = base::trace_event::MemoryDumpType::kExplicitlyTriggered;
break;
case memory_instrumentation::mojom::DumpType::SUMMARY_ONLY:
*out = base::trace_event::MemoryDumpType::SUMMARY_ONLY;
*out = base::trace_event::MemoryDumpType::kSummaryOnly;
break;
default:
NOTREACHED() << "Invalid type: " << static_cast<uint8_t>(input);
@ -55,11 +55,11 @@ EnumTraits<memory_instrumentation::mojom::LevelOfDetail,
base::trace_event::MemoryDumpLevelOfDetail>::
ToMojom(base::trace_event::MemoryDumpLevelOfDetail level_of_detail) {
switch (level_of_detail) {
case base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND:
case base::trace_event::MemoryDumpLevelOfDetail::kBackground:
return memory_instrumentation::mojom::LevelOfDetail::BACKGROUND;
case base::trace_event::MemoryDumpLevelOfDetail::LIGHT:
case base::trace_event::MemoryDumpLevelOfDetail::kLight:
return memory_instrumentation::mojom::LevelOfDetail::LIGHT;
case base::trace_event::MemoryDumpLevelOfDetail::DETAILED:
case base::trace_event::MemoryDumpLevelOfDetail::kDetailed:
return memory_instrumentation::mojom::LevelOfDetail::DETAILED;
default:
CHECK(false) << "Invalid type: " << static_cast<uint8_t>(level_of_detail);
@ -75,13 +75,13 @@ bool EnumTraits<memory_instrumentation::mojom::LevelOfDetail,
base::trace_event::MemoryDumpLevelOfDetail* out) {
switch (input) {
case memory_instrumentation::mojom::LevelOfDetail::BACKGROUND:
*out = base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND;
*out = base::trace_event::MemoryDumpLevelOfDetail::kBackground;
break;
case memory_instrumentation::mojom::LevelOfDetail::LIGHT:
*out = base::trace_event::MemoryDumpLevelOfDetail::LIGHT;
*out = base::trace_event::MemoryDumpLevelOfDetail::kLight;
break;
case memory_instrumentation::mojom::LevelOfDetail::DETAILED:
*out = base::trace_event::MemoryDumpLevelOfDetail::DETAILED;
*out = base::trace_event::MemoryDumpLevelOfDetail::kDetailed;
break;
default:
NOTREACHED() << "Invalid type: " << static_cast<uint8_t>(input);
@ -96,9 +96,9 @@ EnumTraits<memory_instrumentation::mojom::Determinism,
base::trace_event::MemoryDumpDeterminism>::
ToMojom(base::trace_event::MemoryDumpDeterminism determinism) {
switch (determinism) {
case base::trace_event::MemoryDumpDeterminism::NONE:
case base::trace_event::MemoryDumpDeterminism::kNone:
return memory_instrumentation::mojom::Determinism::NONE;
case base::trace_event::MemoryDumpDeterminism::FORCE_GC:
case base::trace_event::MemoryDumpDeterminism::kForceGc:
return memory_instrumentation::mojom::Determinism::FORCE_GC;
default:
CHECK(false) << "Invalid type: " << static_cast<uint8_t>(determinism);
@ -114,10 +114,10 @@ bool EnumTraits<memory_instrumentation::mojom::Determinism,
base::trace_event::MemoryDumpDeterminism* out) {
switch (input) {
case memory_instrumentation::mojom::Determinism::NONE:
*out = base::trace_event::MemoryDumpDeterminism::NONE;
*out = base::trace_event::MemoryDumpDeterminism::kNone;
break;
case memory_instrumentation::mojom::Determinism::FORCE_GC:
*out = base::trace_event::MemoryDumpDeterminism::FORCE_GC;
*out = base::trace_event::MemoryDumpDeterminism::kForceGc;
break;
default:
NOTREACHED() << "Invalid type: " << static_cast<uint8_t>(input);

@ -40,13 +40,13 @@ void SerializeAndDeserialize(const Type& input, Type* output) {
} // namespace
TEST_F(StructTraitsTest, MemoryDumpRequestArgs) {
MemoryDumpRequestArgs input{10u, MemoryDumpType::SUMMARY_ONLY,
MemoryDumpLevelOfDetail::DETAILED};
MemoryDumpRequestArgs input{10u, MemoryDumpType::kSummaryOnly,
MemoryDumpLevelOfDetail::kDetailed};
MemoryDumpRequestArgs output;
SerializeAndDeserialize<mojom::RequestArgs>(input, &output);
EXPECT_EQ(10u, output.dump_guid);
EXPECT_EQ(MemoryDumpType::SUMMARY_ONLY, output.dump_type);
EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED, output.level_of_detail);
EXPECT_EQ(MemoryDumpType::kSummaryOnly, output.dump_type);
EXPECT_EQ(MemoryDumpLevelOfDetail::kDetailed, output.level_of_detail);
}
TEST_F(StructTraitsTest, MemoryAllocatorDumpEdge) {
@ -106,7 +106,7 @@ TEST_F(StructTraitsTest, MemoryAllocatorDumpEntry) {
TEST_F(StructTraitsTest, MemoryAllocatorDump) {
auto input = std::make_unique<MemoryAllocatorDump>(
"absolute/name", MemoryDumpLevelOfDetail::DETAILED,
"absolute/name", MemoryDumpLevelOfDetail::kDetailed,
MemoryAllocatorDumpGuid(42));
std::unique_ptr<MemoryAllocatorDump> output;
input->AddScalar("size", "bytes", 10);
@ -118,7 +118,7 @@ TEST_F(StructTraitsTest, MemoryAllocatorDump) {
EXPECT_EQ("absolute/name", output->absolute_name());
EXPECT_EQ(MemoryAllocatorDump::WEAK, output->flags());
EXPECT_EQ(10u, output->GetSizeInternal());
EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED, output->level_of_detail());
EXPECT_EQ(MemoryDumpLevelOfDetail::kDetailed, output->level_of_detail());
MemoryAllocatorDump::Entry expected_entry1("size", "bytes", 10);
EXPECT_THAT(output->entries(), Contains(Eq(ByRef(expected_entry1))));
MemoryAllocatorDump::Entry expected_entry2("count", "number", 20);
@ -127,7 +127,7 @@ TEST_F(StructTraitsTest, MemoryAllocatorDump) {
TEST_F(StructTraitsTest, ProcessMemoryDump) {
auto input = std::make_unique<ProcessMemoryDump>(
MemoryDumpArgs{MemoryDumpLevelOfDetail::DETAILED});
MemoryDumpArgs{MemoryDumpLevelOfDetail::kDetailed});
std::unique_ptr<ProcessMemoryDump> output;
MemoryAllocatorDump* mad1 = input->CreateAllocatorDump("mad/1");
MemoryAllocatorDumpGuid mad1_id = mad1->guid();
@ -151,7 +151,7 @@ TEST_F(StructTraitsTest, ProcessMemoryDump) {
mad_wshg->AddString("shared_weak_name", "url", ".");
SerializeAndDeserialize<mojom::RawProcessMemoryDump>(input, &output);
EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
EXPECT_EQ(MemoryDumpLevelOfDetail::kDetailed,
output->dump_args().level_of_detail);
const auto& dumps = output->allocator_dumps();
{

@ -62,15 +62,15 @@ const char* const kTestMDPWhitelist[] = {
// GTest matchers for MemoryDumpRequestArgs arguments.
MATCHER(IsDetailedDump, "") {
return arg.level_of_detail == MemoryDumpLevelOfDetail::DETAILED;
return arg.level_of_detail == MemoryDumpLevelOfDetail::kDetailed;
}
MATCHER(IsLightDump, "") {
return arg.level_of_detail == MemoryDumpLevelOfDetail::LIGHT;
return arg.level_of_detail == MemoryDumpLevelOfDetail::kLight;
}
MATCHER(IsBackgroundDump, "") {
return arg.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND;
return arg.level_of_detail == MemoryDumpLevelOfDetail::kBackground;
}
// TODO(ssid): This class is replicated in memory_dump_manager_unittest. Move
@ -299,8 +299,8 @@ TEST_F(MemoryTracingIntegrationTest, InitializedAfterStartOfTracing) {
MockMemoryDumpProvider mdp;
RegisterDumpProvider(&mdp, nullptr, MemoryDumpProvider::Options());
EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(1);
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED));
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed));
DisableTracing();
}
@ -341,12 +341,12 @@ TEST_F(MemoryTracingIntegrationTest, TestBackgroundTracingSetup) {
// When requesting non-BACKGROUND dumps the MDP will be invoked.
EXPECT_CALL(*mdp, OnMemoryDump(IsLightDump(), _));
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::LIGHT));
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kLight));
EXPECT_CALL(*mdp, OnMemoryDump(IsDetailedDump(), _));
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED));
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed));
ASSERT_TRUE(IsPeriodicDumpingEnabled());
DisableTracing();
@ -474,8 +474,8 @@ TEST_F(MemoryTracingIntegrationTest, TestWhitelistingMDP) {
EnableMemoryInfraTracing();
EXPECT_FALSE(IsPeriodicDumpingEnabled());
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::BACKGROUND));
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kBackground));
DisableTracing();
}
@ -514,8 +514,8 @@ TEST_F(MemoryTracingIntegrationTest, GenerationChangeDoesntReenterMDM) {
run_loop.QuitClosure()));
run_loop.Run();
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED));
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed));
DisableTracing();
// Now enable tracing again with a different RECORD_ mode. This will cause
@ -529,8 +529,8 @@ TEST_F(MemoryTracingIntegrationTest, GenerationChangeDoesntReenterMDM) {
TraceConfig(kMemoryInfraTracingOnly,
base::trace_event::RECORD_CONTINUOUSLY),
TraceLog::RECORDING_MODE);
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
MemoryDumpLevelOfDetail::DETAILED));
EXPECT_TRUE(RequestChromeDumpAndWait(MemoryDumpType::kExplicitlyTriggered,
MemoryDumpLevelOfDetail::kDetailed));
DisableTracing();
}

@ -33,11 +33,11 @@ perfetto::protos::pbzero::MemoryTrackerSnapshot::LevelOfDetail
MemoryDumpLevelOfDetailToProto(
const base::trace_event::MemoryDumpLevelOfDetail& level_of_detail) {
switch (level_of_detail) {
case base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND:
case base::trace_event::MemoryDumpLevelOfDetail::kBackground:
return perfetto::protos::pbzero::MemoryTrackerSnapshot::DETAIL_BACKGROUND;
case base::trace_event::MemoryDumpLevelOfDetail::LIGHT:
case base::trace_event::MemoryDumpLevelOfDetail::kLight:
return perfetto::protos::pbzero::MemoryTrackerSnapshot::DETAIL_LIGHT;
case base::trace_event::MemoryDumpLevelOfDetail::DETAILED:
case base::trace_event::MemoryDumpLevelOfDetail::kDetailed:
return perfetto::protos::pbzero::MemoryTrackerSnapshot::DETAIL_FULL;
}
NOTREACHED();

@ -65,16 +65,17 @@ class TracingObserverProtoTest : public testing::Test {
base::trace_event::MemoryDumpRequestArgs FillMemoryDumpRequestArgs() {
base::trace_event::MemoryDumpRequestArgs args;
args.dump_guid = 1;
args.dump_type = base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED;
args.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::DETAILED;
args.determinism = base::trace_event::MemoryDumpDeterminism::FORCE_GC;
args.dump_type = base::trace_event::MemoryDumpType::kExplicitlyTriggered;
args.level_of_detail =
base::trace_event::MemoryDumpLevelOfDetail::kDetailed;
args.determinism = base::trace_event::MemoryDumpDeterminism::kForceGc;
return args;
}
base::trace_event::ProcessMemoryDump FillSamplePmd() {
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
base::trace_event::ProcessMemoryDump pmd =
base::trace_event::ProcessMemoryDump(dump_args);
pmd.CreateAllocatorDump("mad1",
@ -350,7 +351,7 @@ TEST_F(TracingObserverProtoTest, AsProtoInto) {
data_source_tester.BeginTrace(GetTraceConfig());
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
base::trace_event::ProcessMemoryDump pmd =
base::trace_event::ProcessMemoryDump(dump_args);

@ -45,7 +45,7 @@ void TracingObserverTracedValue::AddToTrace(
const base::trace_event::MemoryDumpRequestArgs& args,
const base::ProcessId pid,
std::unique_ptr<TracedValue> traced_value) {
CHECK_NE(base::trace_event::MemoryDumpType::SUMMARY_ONLY, args.dump_type);
CHECK_NE(base::trace_event::MemoryDumpType::kSummaryOnly, args.dump_type);
traced_value->SetString(
"level_of_detail",

@ -27,7 +27,7 @@ bool SkiaMemoryDumpProvider::OnMemoryDump(
const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* process_memory_dump) {
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
auto* glyph_cache_dump =
process_memory_dump->CreateAllocatorDump("skia/sk_glyph_cache");
glyph_cache_dump->AddScalar(

@ -14,7 +14,7 @@ namespace skia {
// Tests if the skia dump provider dumps without crashing.
TEST(SkiaMemoryDumpProviderTest, OnMemoryDump) {
base::trace_event::MemoryDumpArgs dump_args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
new base::trace_event::ProcessMemoryDump(dump_args));
SkiaMemoryDumpProvider::GetInstance()->OnMemoryDump(

@ -27,7 +27,7 @@ SkiaTraceMemoryDumpImpl::SkiaTraceMemoryDumpImpl(
: dump_name_prefix_(dump_name_prefix),
process_memory_dump_(process_memory_dump),
request_level_(
level_of_detail == base::trace_event::MemoryDumpLevelOfDetail::LIGHT
level_of_detail == base::trace_event::MemoryDumpLevelOfDetail::kLight
? SkTraceMemoryDump::kLight_LevelOfDetail
: SkTraceMemoryDump::kObjectsBreakdowns_LevelOfDetail) {}

@ -33,8 +33,10 @@ void DatabaseMemoryDumpProvider::ResetDatabase() {
bool DatabaseMemoryDumpProvider::OnMemoryDump(
const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) {
if (args.level_of_detail == base::trace_event::MemoryDumpLevelOfDetail::LIGHT)
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::kLight) {
return true;
}
MemoryUsageResult memory_usage = GetDbMemoryUsage();
if (!memory_usage.is_valid)

@ -1583,7 +1583,7 @@ TEST_P(SQLDatabaseTest, FullIntegrityCheck) {
TEST_P(SQLDatabaseTest, OnMemoryDump) {
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
base::trace_event::ProcessMemoryDump pmd(args);
ASSERT_TRUE(db_->memory_dump_provider_->OnMemoryDump(args, &pmd));
EXPECT_GE(pmd.allocator_dumps().size(), 1u);

@ -33,7 +33,7 @@ class SQLMemoryDumpProviderTest : public testing::Test {
TEST_F(SQLMemoryDumpProviderTest, OnMemoryDump) {
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
base::trace_event::ProcessMemoryDump pmd(args);
ASSERT_TRUE(SqlMemoryDumpProvider::GetInstance()->OnMemoryDump(args, &pmd));
ASSERT_TRUE(pmd.GetAllocatorDump("sqlite"));

@ -2420,8 +2420,8 @@ TEST_F(WebMediaPlayerImplTest, MemDumpReporting) {
CycleThreads();
base::trace_event::MemoryDumpRequestArgs args = {
1 /* dump_guid*/, base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED,
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
1 /* dump_guid*/, base::trace_event::MemoryDumpType::kExplicitlyTriggered,
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
int32_t id = media::GetNextMediaPlayerLoggingID() - 1;
int dump_count = 0;
@ -2454,7 +2454,7 @@ TEST_F(WebMediaPlayerImplTest, MemDumpReporting) {
}));
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {
base::trace_event::MemoryDumpLevelOfDetail::kDetailed) {
ASSERT_TRUE(base::ranges::any_of(entries, [](const auto& e) {
return e.name == "player_state" && !e.value_string.empty();
}));
@ -2466,11 +2466,12 @@ TEST_F(WebMediaPlayerImplTest, MemDumpReporting) {
dump_manager->CreateProcessDump(args, on_memory_dump_done);
args.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND;
args.level_of_detail =
base::trace_event::MemoryDumpLevelOfDetail::kBackground;
args.dump_guid++;
dump_manager->CreateProcessDump(args, on_memory_dump_done);
args.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::LIGHT;
args.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::kLight;
args.dump_guid++;
dump_manager->CreateProcessDump(args, on_memory_dump_done);

@ -944,7 +944,7 @@ TEST_P(ParkableStringTest, ReportMemoryDump) {
parkable1.ToString();
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
base::trace_event::ProcessMemoryDump pmd(args);
manager.OnMemoryDump(&pmd);
base::trace_event::MemoryAllocatorDump* dump =

@ -300,7 +300,7 @@ bool HibernatedCanvasMemoryDumpProvider::OnMemoryDump(
total_hibernated_size += handler->memory_size();
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {
base::trace_event::MemoryDumpLevelOfDetail::kDetailed) {
auto* canvas_dump = pmd->CreateAllocatorDump(
base::StringPrintf("canvas/hibernated/canvas_%d", index));
canvas_dump->AddScalar("memory_size", "bytes", handler->memory_size());

@ -1418,7 +1418,7 @@ TEST_F(Canvas2DLayerBridgeTest, HibernationMemoryMetrics) {
SetIsInHiddenPage(bridge.get(), platform, true);
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
{
base::trace_event::ProcessMemoryDump pmd(args);
EXPECT_TRUE(HibernatedCanvasMemoryDumpProvider::GetInstance().OnMemoryDump(

@ -94,7 +94,7 @@ bool BlinkGCMemoryDumpProvider::OnMemoryDump(
base::trace_event::ProcessMemoryDump* process_memory_dump) {
::cppgc::HeapStatistics::DetailLevel detail_level =
args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::DETAILED
base::trace_event::MemoryDumpLevelOfDetail::kDetailed
? ::cppgc::HeapStatistics::kDetailed
: ::cppgc::HeapStatistics::kBrief;

@ -63,7 +63,7 @@ void CheckSpacesInDump(base::trace_event::ProcessMemoryDump& dump,
TEST_F(BlinkGCMemoryDumpProviderTest, MainThreadLightDump) {
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::LIGHT};
base::trace_event::MemoryDumpLevelOfDetail::kLight};
std::unique_ptr<base::trace_event::ProcessMemoryDump> dump(
new base::trace_event::ProcessMemoryDump(args));
std::unique_ptr<BlinkGCMemoryDumpProvider> dump_provider(
@ -79,7 +79,7 @@ TEST_F(BlinkGCMemoryDumpProviderTest, MainThreadLightDump) {
TEST_F(BlinkGCMemoryDumpProviderTest, MainThreadDetailedDump) {
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
std::unique_ptr<base::trace_event::ProcessMemoryDump> dump(
new base::trace_event::ProcessMemoryDump(args));
std::unique_ptr<BlinkGCMemoryDumpProvider> dump_provider(
@ -95,7 +95,7 @@ TEST_F(BlinkGCMemoryDumpProviderTest, MainThreadDetailedDump) {
TEST_F(BlinkGCMemoryDumpProviderTest, WorkerLightDump) {
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::LIGHT};
base::trace_event::MemoryDumpLevelOfDetail::kLight};
std::unique_ptr<base::trace_event::ProcessMemoryDump> dump(
new base::trace_event::ProcessMemoryDump(args));
std::unique_ptr<BlinkGCMemoryDumpProvider> dump_provider(
@ -120,7 +120,7 @@ TEST_F(BlinkGCMemoryDumpProviderTest, WorkerLightDump) {
TEST_F(BlinkGCMemoryDumpProviderTest, WorkerDetailedDump) {
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
std::unique_ptr<base::trace_event::ProcessMemoryDump> dump(
new base::trace_event::ProcessMemoryDump(args));
std::unique_ptr<BlinkGCMemoryDumpProvider> dump_provider(

@ -20,7 +20,7 @@ bool CanvasMemoryDumpProvider::OnMemoryDump(
const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* memory_dump) {
if (args.level_of_detail ==
base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {
base::trace_event::MemoryDumpLevelOfDetail::kDetailed) {
base::AutoLock auto_lock(lock_);
for (auto* it : clients_)
it->OnMemoryDump(memory_dump);

@ -39,7 +39,7 @@ bool PartitionAllocMemoryDumpProvider::OnMemoryDump(
// This method calls memoryStats.partitionsDumpBucketStats with memory
// statistics.
WTF::Partitions::DumpMemoryStats(
level_of_detail != MemoryDumpLevelOfDetail::DETAILED,
level_of_detail != MemoryDumpLevelOfDetail::kDetailed,
&partition_stats_dumper);
base::trace_event::MemoryAllocatorDump* allocated_objects_dump =

@ -21,7 +21,7 @@ TEST(PartitionAllocMemoryDumpProviderTest, Simple) {
base::HistogramTester histogram_tester;
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
base::trace_event::MemoryDumpLevelOfDetail::kDetailed};
base::trace_event::ProcessMemoryDump pmd(args);
PartitionAllocMemoryDumpProvider::Instance()->OnMemoryDump(args, &pmd);

@ -22,13 +22,13 @@ bool MemoryCacheDumpProvider::OnMemoryDump(
WebMemoryDumpLevelOfDetail level;
switch (args.level_of_detail) {
case base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND:
case base::trace_event::MemoryDumpLevelOfDetail::kBackground:
level = blink::WebMemoryDumpLevelOfDetail::kBackground;
break;
case base::trace_event::MemoryDumpLevelOfDetail::LIGHT:
case base::trace_event::MemoryDumpLevelOfDetail::kLight:
level = blink::WebMemoryDumpLevelOfDetail::kLight;
break;
case base::trace_event::MemoryDumpLevelOfDetail::DETAILED:
case base::trace_event::MemoryDumpLevelOfDetail::kDetailed:
level = blink::WebMemoryDumpLevelOfDetail::kDetailed;
break;
default:

@ -20,9 +20,9 @@ namespace blink {
WebProcessMemoryDump::WebProcessMemoryDump()
: owned_process_memory_dump_(new base::trace_event::ProcessMemoryDump(
{base::trace_event::MemoryDumpLevelOfDetail::DETAILED})),
{base::trace_event::MemoryDumpLevelOfDetail::kDetailed})),
process_memory_dump_(owned_process_memory_dump_.get()),
level_of_detail_(base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {}
level_of_detail_(base::trace_event::MemoryDumpLevelOfDetail::kDetailed) {}
WebProcessMemoryDump::WebProcessMemoryDump(
base::trace_event::MemoryDumpLevelOfDetail level_of_detail,

@ -3288,7 +3288,7 @@ void WebMediaPlayerImpl::OnMainThreadMemoryDump(
base::trace_event::MemoryAllocatorDump::kUnitsObjects, 1);
if (args.level_of_detail !=
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
bool suspended = pipeline_controller_->IsPipelineSuspended();
auto player_state =
base::StringPrintf("Paused: %d Ended: %d ReadyState: %d Suspended: %d",

@ -1279,7 +1279,7 @@ void DBTracker::MemoryDumpProvider::DumpVisitor(ProcessMemoryDump* pmd,
total_usage - cache_usage + cache_usage_pss);
if (pmd->dump_args().level_of_detail !=
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
base::trace_event::MemoryDumpLevelOfDetail::kBackground) {
db_dump->AddString("name", "", db->name());
}
}

@ -475,7 +475,7 @@ TEST_F(ChromiumEnvDBTrackerTest, MemoryDumpCreation) {
DBTracker::GetInstance()->VisitDatabases(base::BindRepeating(db_visitor));
ASSERT_EQ(browser_cache->TotalCharge() * 2, web_cache->TotalCharge());
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::BACKGROUND};
MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::kBackground};
base::trace_event::ProcessMemoryDump pmd(dump_args);
auto* mad1 = DBTracker::GetOrCreateAllocatorDump(&pmd, db1.get());
auto* mad2 = DBTracker::GetOrCreateAllocatorDump(&pmd, db2.get());
@ -500,7 +500,7 @@ TEST_F(ChromiumEnvDBTrackerTest, MemEnvMemoryDumpCreation) {
writable_file->Append(Slice(kValue));
delete writable_file;
const MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::BACKGROUND};
const MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::kBackground};
base::trace_event::ProcessMemoryDump dump1(dump_args);
auto* mad = DBTracker::GetOrCreateAllocatorDump(&dump1, memenv.get());

Some files were not shown because too many files have changed in this diff Show More