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
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "platform/network/NetworkInstrumentation.h"
#include "base/trace_event/trace_event.h"
#include "platform/instrumentation/tracing/TracedValue.h"
#include "platform/network/ResourceLoadPriority.h"
#include "platform/network/ResourceRequest.h"
namespace network_instrumentation {
using network_instrumentation::RequestOutcome;
using blink::TracedValue;
const char kBlinkResourceID[] = "BlinkResourceID";
const char kResourceLoadTitle[] = "ResourceLoad";
const char kResourcePrioritySetTitle[] = "ResourcePrioritySet";
const char kNetInstrumentationCategory[] = TRACE_DISABLED_BY_DEFAULT("network");
const char* RequestOutcomeToString(RequestOutcome outcome) {
switch (outcome) {
case RequestOutcome::Success:
return "Success";
case RequestOutcome::Fail:
return "Fail";
default:
NOTREACHED();
// We need to return something to avoid compiler warning.
return "This should never happen";
}
}
// Note: network_instrumentation code should do as much work as possible inside
// the arguments of trace macros so that very little instrumentation overhead is
// incurred if the trace category is disabled. See https://crbug.com/669666.
namespace {
std::unique_ptr<TracedValue> scopedResourceTrackerBeginData(
const blink::ResourceRequest& request) {
std::unique_ptr<TracedValue> data = TracedValue::create();
data->setString("url", request.url().getString());
return data;
}
std::unique_ptr<TracedValue> resourcePrioritySetData(
blink::ResourceLoadPriority priority) {
std::unique_ptr<TracedValue> data = TracedValue::create();
data->setInteger("priority", priority);
return data;
}
std::unique_ptr<TracedValue> endResourceLoadData(RequestOutcome outcome) {
std::unique_ptr<TracedValue> data = TracedValue::create();
data->setString("outcome", RequestOutcomeToString(outcome));
return data;
}
} // namespace
ScopedResourceLoadTracker::ScopedResourceLoadTracker(
unsigned long resourceID,
const blink::ResourceRequest& request)
: m_resourceLoadContinuesBeyondScope(false), m_resourceID(resourceID) {
TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(
kNetInstrumentationCategory, kResourceLoadTitle,
TRACE_ID_WITH_SCOPE(kBlinkResourceID, TRACE_ID_LOCAL(resourceID)),
"beginData", scopedResourceTrackerBeginData(request));
}
ScopedResourceLoadTracker::~ScopedResourceLoadTracker() {
if (!m_resourceLoadContinuesBeyondScope)
endResourceLoad(m_resourceID, RequestOutcome::Fail);
}
void ScopedResourceLoadTracker::resourceLoadContinuesBeyondScope() {
m_resourceLoadContinuesBeyondScope = true;
}
void resourcePrioritySet(unsigned long resourceID,
blink::ResourceLoadPriority priority) {
TRACE_EVENT_NESTABLE_ASYNC_INSTANT1(
kNetInstrumentationCategory, kResourcePrioritySetTitle,
TRACE_ID_WITH_SCOPE(kBlinkResourceID, TRACE_ID_LOCAL(resourceID)), "data",
resourcePrioritySetData(priority));
}
void endResourceLoad(unsigned long resourceID, RequestOutcome outcome) {
TRACE_EVENT_NESTABLE_ASYNC_END1(
kNetInstrumentationCategory, kResourceLoadTitle,
TRACE_ID_WITH_SCOPE(kBlinkResourceID, TRACE_ID_LOCAL(resourceID)),
"endData", endResourceLoadData(outcome));
}
} // namespace network_instrumentation
|
