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
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/autofill/core/browser/logging/text_log_receiver.h"
#include <algorithm>
#include "base/logging.h"
#include "base/notreached.h"
#include "base/strings/strcat.h"
namespace autofill {
namespace {
std::vector<std::string> RenderEntries(const base::Value::List& entries);
// Renders an HTML element to text at a best effort basis.
// This is a bit like calling Element.textContent on a DOM node and not super
// fancy but sufficient for debugging.
std::vector<std::string> RenderElement(const base::Value::Dict& entry) {
const std::string* type = entry.FindString("type");
DCHECK(type && *type == "element");
const std::string* value = entry.FindString("value");
DCHECK(value);
std::vector<std::string> result;
if (const base::Value::List* children = entry.FindList("children"))
result = RenderEntries(*children);
// Elements that should cause line wrapping.
if (*value == "br" || *value == "div" || *value == "tr")
result.push_back("\n");
// Elements that should cause horizontal separation (may lead to pending
// whitespace, which should be ok given that this is just for debugging.)
if (*value == "td")
result.push_back(" ");
return result;
}
// Returns a text node to a vector with a single element representing the text.
std::vector<std::string> RenderText(const base::Value::Dict& entry) {
const std::string* type = entry.FindString("type");
DCHECK(type && *type == "text");
const std::string* value = entry.FindString("value");
DCHECK(value);
return {*value};
}
// Concatenates the rendered contents of a document fragment into a vector of
// strings.
std::vector<std::string> RenderFragment(const base::Value::Dict& entry) {
const std::string* type = entry.FindString("type");
DCHECK(type && *type == "fragment");
DCHECK(!entry.FindString("value"));
const base::Value::List* children = entry.FindList("children");
DCHECK(children);
return RenderEntries(*children);
}
// Entry point into the rendering, you can pass any json object generated
// by the log buffer and it will dispatch the rendering to the correct
// functions.
// The output is a vector of strings that can be concatenated.
std::vector<std::string> RenderEntry(const base::Value::Dict& entry) {
const std::string* type = entry.FindString("type");
if (!type) {
NOTREACHED();
} else if (*type == "element") {
return RenderElement(entry);
} else if (*type == "text") {
return RenderText(entry);
} else if (*type == "fragment") {
return RenderFragment(entry);
} else {
NOTREACHED();
}
}
// Concatenates the rendered contents of a list of log entries.
std::vector<std::string> RenderEntries(const base::Value::List& entries) {
std::vector<std::string> result;
for (const base::Value& entry : entries) {
DCHECK(entry.is_dict());
std::vector<std::string> rendered_entry = RenderEntry(entry.GetDict());
std::ranges::move(rendered_entry, std::back_inserter(result));
}
return result;
}
} // namespace
std::string TextLogReceiver::LogEntryToText(
const base::Value::Dict& entry) const {
return base::StrCat(RenderEntry(entry));
}
void TextLogReceiver::LogEntry(const base::Value::Dict& entry) {
LOG(ERROR) << LogEntryToText(entry);
}
} // namespace autofill
|
