[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:

committed by
Chromium LUCI CQ

parent
00a18d3032
commit
adbf3fb72a
base
android
memory
discardable_shared_memory_unittest.ccmadv_free_discardable_memory_allocator_posix.ccmadv_free_discardable_memory_allocator_posix_unittest.cc
trace_event
heap_profiler.hheap_profiler_allocation_context.hheap_profiler_allocation_context_tracker.ccheap_profiler_allocation_context_tracker.hjava_heap_dump_provider_android_unittest.ccmalloc_dump_provider.ccmemory_allocator_dump.ccmemory_allocator_dump_unittest.ccmemory_dump_manager.ccmemory_dump_manager_unittest.ccmemory_dump_request_args.ccmemory_dump_request_args.hmemory_dump_scheduler.ccmemory_dump_scheduler_unittest.ccprocess_memory_dump.ccprocess_memory_dump_unittest.cctrace_config.cctrace_config_unittest.cc
cc
raster
resources
tiles
chrome
browser
test
components
discardable_memory
common
service
heap_profiling
multi_process
services
heap_profiling
public
storage
dom_storage
indexed_db
transactional_leveldb
tracing
content/browser
fuchsia_web/webengine/browser
gin
v8_isolate_memory_dump_provider.ccv8_isolate_memory_dump_provider_unittest.ccv8_shared_memory_dump_provider_unittest.cc
gpu
command_buffer
client
service
ipc
mojo/core
net/url_request
services/resource_coordinator
memory_instrumentation
chrome_graph_processor_unittest.cccoordinator_impl.cccoordinator_impl_unittest.ccmemory_dump_map_converter.ccmemory_dump_map_converter_unittest.ccqueued_request.h
public
skia/ext
sql
third_party
blink
renderer
core
platform
bindings
graphics
heap
instrumentation
canvas_memory_dump_provider.ccpartition_alloc_memory_dump_provider.ccpartition_alloc_memory_dump_provider_test.cc
tracing
media
leveldatabase
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();
|
||||
|
11
services/resource_coordinator/public/cpp/memory_instrumentation/tracing_observer_proto_unittest.cc
11
services/resource_coordinator/public/cpp/memory_instrumentation/tracing_observer_proto_unittest.cc
@ -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);
|
||||
|
2
third_party/blink/renderer/platform/instrumentation/partition_alloc_memory_dump_provider.cc
vendored
2
third_party/blink/renderer/platform/instrumentation/partition_alloc_memory_dump_provider.cc
vendored
@ -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 =
|
||||
|
2
third_party/blink/renderer/platform/instrumentation/partition_alloc_memory_dump_provider_test.cc
vendored
2
third_party/blink/renderer/platform/instrumentation/partition_alloc_memory_dump_provider_test.cc
vendored
@ -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);
|
||||
|
||||
|
6
third_party/blink/renderer/platform/instrumentation/tracing/memory_cache_dump_provider.cc
vendored
6
third_party/blink/renderer/platform/instrumentation/tracing/memory_cache_dump_provider.cc
vendored
@ -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",
|
||||
|
2
third_party/leveldatabase/env_chromium.cc
vendored
2
third_party/leveldatabase/env_chromium.cc
vendored
@ -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
Reference in New Issue
Block a user