File: skia_trace_memory_dump_impl.cc

package info (click to toggle)
chromium 139.0.7258.127-1
  • links: PTS, VCS
  • area: main
  • in suites:
  • size: 6,122,068 kB
  • sloc: cpp: 35,100,771; ansic: 7,163,530; javascript: 4,103,002; python: 1,436,920; asm: 946,517; xml: 746,709; pascal: 187,653; perl: 88,691; sh: 88,436; objc: 79,953; sql: 51,488; cs: 44,583; fortran: 24,137; makefile: 22,147; tcl: 15,277; php: 13,980; yacc: 8,984; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (113 lines) | stat: -rw-r--r-- 4,369 bytes parent folder | download | duplicates (6)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/390223051): Remove C-library calls to fix the errors.
#pragma allow_unsafe_libc_calls
#endif

#include "skia/ext/skia_trace_memory_dump_impl.h"

#include "base/trace_event/memory_allocator_dump.h"
#include "base/trace_event/memory_dump_manager.h"
#include "base/trace_event/process_memory_dump.h"
#include "skia/ext/SkDiscardableMemory_chrome.h"

namespace skia {

namespace {
const char kMallocBackingType[] = "malloc";
}

SkiaTraceMemoryDumpImpl::SkiaTraceMemoryDumpImpl(
    base::trace_event::MemoryDumpLevelOfDetail level_of_detail,
    base::trace_event::ProcessMemoryDump* process_memory_dump)
    : SkiaTraceMemoryDumpImpl("", level_of_detail, process_memory_dump) {}

SkiaTraceMemoryDumpImpl::SkiaTraceMemoryDumpImpl(
    const std::string& dump_name_prefix,
    base::trace_event::MemoryDumpLevelOfDetail level_of_detail,
    base::trace_event::ProcessMemoryDump* process_memory_dump)
    : dump_name_prefix_(dump_name_prefix),
      process_memory_dump_(process_memory_dump),
      request_level_(
          level_of_detail == base::trace_event::MemoryDumpLevelOfDetail::kLight
              ? SkTraceMemoryDump::kLight_LevelOfDetail
              : SkTraceMemoryDump::kObjectsBreakdowns_LevelOfDetail) {}

SkiaTraceMemoryDumpImpl::~SkiaTraceMemoryDumpImpl() = default;

void SkiaTraceMemoryDumpImpl::dumpNumericValue(const char* dump_name,
                                               const char* value_name,
                                               const char* units,
                                               uint64_t value) {
  auto* dump = process_memory_dump_->GetOrCreateAllocatorDump(dump_name);
  dump->AddScalar(value_name, units, value);
}

void SkiaTraceMemoryDumpImpl::dumpStringValue(const char* dump_name,
                                              const char* value_name,
                                              const char* value) {
  auto* dump = process_memory_dump_->GetOrCreateAllocatorDump(dump_name);
  dump->AddString(value_name, "", value);
}

void SkiaTraceMemoryDumpImpl::setMemoryBacking(const char* dump_name,
                                               const char* backing_type,
                                               const char* backing_object_id) {
  if (strcmp(backing_type, kMallocBackingType) == 0) {
    auto* dump = process_memory_dump_->GetOrCreateAllocatorDump(dump_name);
    const char* system_allocator_name =
        base::trace_event::MemoryDumpManager::GetInstance()
            ->system_allocator_pool_name();
    if (system_allocator_name) {
      process_memory_dump_->AddSuballocation(dump->guid(),
                                             system_allocator_name);
    }
  } else {
    NOTREACHED();
  }
}

void SkiaTraceMemoryDumpImpl::setDiscardableMemoryBacking(
    const char* dump_name,
    const SkDiscardableMemory& discardable_memory) {
  std::string name = dump_name_prefix_ + dump_name;
  DCHECK(!process_memory_dump_->GetAllocatorDump(name));
  const SkDiscardableMemoryChrome& discardable_memory_chrome =
      static_cast<const SkDiscardableMemoryChrome&>(discardable_memory);
  auto* dump = discardable_memory_chrome.CreateMemoryAllocatorDump(
      name.c_str(), process_memory_dump_);
  DCHECK(dump);
}

SkTraceMemoryDump::LevelOfDetail SkiaTraceMemoryDumpImpl::getRequestedDetails()
    const {
  return request_level_;
}

bool SkiaTraceMemoryDumpImpl::shouldDumpWrappedObjects() const {
  // Chrome already dumps objects it imports into Skia. Avoid duplicate dumps
  // by asking Skia not to dump them.
  return false;
}

void SkiaTraceMemoryDumpImpl::dumpWrappedState(const char* dump_name,
                                               bool wrapped) {
  NOTREACHED();
}

bool SkiaTraceMemoryDumpImpl::shouldDumpUnbudgetedObjects() const {
  // Only used on Graphite - we should dump unbudgeted items from SkImages or
  // SkSurfaces the client creates.
  return true;
}

void SkiaTraceMemoryDumpImpl::dumpBudgetedState(const char* dump_name,
                                                bool budgeted) {
  auto* dump = process_memory_dump_->GetOrCreateAllocatorDump(dump_name);
  dump->AddString("budgeted", "", budgeted ? "1" : "0");
}

}  // namespace skia