Line data Source code
1 : // Copyright 2016 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 : #include <limits>
5 :
6 : #include "include/libplatform/v8-tracing.h"
7 : #include "src/libplatform/default-platform.h"
8 : #include "src/tracing/trace-event.h"
9 : #include "test/cctest/cctest.h"
10 :
11 : namespace v8 {
12 : namespace platform {
13 : namespace tracing {
14 :
15 28342 : TEST(TestTraceConfig) {
16 5 : LocalContext env;
17 5 : TraceConfig* trace_config = new TraceConfig();
18 5 : trace_config->AddIncludedCategory("v8");
19 5 : trace_config->AddIncludedCategory(TRACE_DISABLED_BY_DEFAULT("v8.runtime"));
20 :
21 5 : CHECK_EQ(trace_config->IsSystraceEnabled(), false);
22 5 : CHECK_EQ(trace_config->IsArgumentFilterEnabled(), false);
23 5 : CHECK_EQ(trace_config->IsCategoryGroupEnabled("v8"), true);
24 10 : CHECK_EQ(trace_config->IsCategoryGroupEnabled("v8.cpu_profile"), false);
25 10 : CHECK_EQ(trace_config->IsCategoryGroupEnabled("v8.cpu_profile.hires"), false);
26 5 : CHECK_EQ(trace_config->IsCategoryGroupEnabled(
27 : TRACE_DISABLED_BY_DEFAULT("v8.runtime")),
28 : true);
29 5 : CHECK_EQ(trace_config->IsCategoryGroupEnabled("v8,v8.cpu_profile"), true);
30 5 : CHECK_EQ(
31 : trace_config->IsCategoryGroupEnabled("v8,disabled-by-default-v8.runtime"),
32 : true);
33 10 : CHECK_EQ(trace_config->IsCategoryGroupEnabled(
34 : "v8_cpu_profile,v8.cpu_profile.hires"),
35 : false);
36 :
37 10 : delete trace_config;
38 5 : }
39 :
40 28342 : TEST(TestTraceObject) {
41 : TraceObject trace_object;
42 5 : uint8_t category_enabled_flag = 41;
43 : trace_object.Initialize('X', &category_enabled_flag, "Test.Trace",
44 : "Test.Scope", 42, 123, 0, nullptr, nullptr, nullptr,
45 5 : nullptr, 0, 1729, 4104);
46 5 : CHECK_EQ('X', trace_object.phase());
47 5 : CHECK_EQ(category_enabled_flag, *trace_object.category_enabled_flag());
48 15 : CHECK_EQ(std::string("Test.Trace"), std::string(trace_object.name()));
49 15 : CHECK_EQ(std::string("Test.Scope"), std::string(trace_object.scope()));
50 5 : CHECK_EQ(0u, trace_object.duration());
51 5 : CHECK_EQ(0u, trace_object.cpu_duration());
52 5 : }
53 :
54 30 : class ConvertableToTraceFormatMock : public v8::ConvertableToTraceFormat {
55 : public:
56 15 : explicit ConvertableToTraceFormatMock(int value) : value_(value) {}
57 15 : void AppendAsTraceFormat(std::string* out) const override {
58 135 : *out += "[" + std::to_string(value_) + "," + std::to_string(value_) + "]";
59 15 : }
60 :
61 : private:
62 : int value_;
63 :
64 : DISALLOW_COPY_AND_ASSIGN(ConvertableToTraceFormatMock);
65 : };
66 :
67 45 : class MockTraceWriter : public TraceWriter {
68 : public:
69 335 : void AppendTraceEvent(TraceObject* trace_event) override {
70 670 : events_.push_back(trace_event->name());
71 335 : }
72 :
73 20 : void Flush() override {}
74 :
75 20 : std::vector<std::string> events() { return events_; }
76 :
77 : private:
78 : std::vector<std::string> events_;
79 : };
80 :
81 28342 : TEST(TestTraceBufferRingBuffer) {
82 : // We should be able to add kChunkSize * 2 + 1 trace events.
83 : const int HANDLES_COUNT = TraceBufferChunk::kChunkSize * 2 + 1;
84 5 : MockTraceWriter* writer = new MockTraceWriter();
85 : TraceBuffer* ring_buffer =
86 5 : TraceBuffer::CreateTraceBufferRingBuffer(2, writer);
87 650 : std::string names[HANDLES_COUNT];
88 645 : for (int i = 0; i < HANDLES_COUNT; ++i) {
89 1935 : names[i] = "Test.EventNo" + std::to_string(i);
90 : }
91 :
92 5 : std::vector<uint64_t> handles(HANDLES_COUNT);
93 5 : uint8_t category_enabled_flag = 41;
94 1300 : for (size_t i = 0; i < handles.size(); ++i) {
95 3225 : TraceObject* trace_object = ring_buffer->AddTraceEvent(&handles[i]);
96 645 : CHECK_NOT_NULL(trace_object);
97 : trace_object->Initialize('X', &category_enabled_flag, names[i].c_str(),
98 : "Test.Scope", 42, 123, 0, nullptr, nullptr,
99 1290 : nullptr, nullptr, 0, 1729, 4104);
100 1290 : trace_object = ring_buffer->GetEventByHandle(handles[i]);
101 645 : CHECK_NOT_NULL(trace_object);
102 645 : CHECK_EQ('X', trace_object->phase());
103 1290 : CHECK_EQ(names[i], std::string(trace_object->name()));
104 645 : CHECK_EQ(category_enabled_flag, *trace_object->category_enabled_flag());
105 : }
106 :
107 : // We should only be able to retrieve the last kChunkSize + 1.
108 320 : for (size_t i = 0; i < TraceBufferChunk::kChunkSize; ++i) {
109 640 : CHECK_NULL(ring_buffer->GetEventByHandle(handles[i]));
110 : }
111 :
112 655 : for (size_t i = TraceBufferChunk::kChunkSize; i < handles.size(); ++i) {
113 1625 : TraceObject* trace_object = ring_buffer->GetEventByHandle(handles[i]);
114 325 : CHECK_NOT_NULL(trace_object);
115 : // The object properties should be correct.
116 325 : CHECK_EQ('X', trace_object->phase());
117 650 : CHECK_EQ(names[i], std::string(trace_object->name()));
118 325 : CHECK_EQ(category_enabled_flag, *trace_object->category_enabled_flag());
119 : }
120 :
121 : // Check Flush(), that the writer wrote the last kChunkSize 1 event names.
122 5 : ring_buffer->Flush();
123 5 : auto events = writer->events();
124 10 : CHECK_EQ(TraceBufferChunk::kChunkSize + 1, events.size());
125 655 : for (size_t i = TraceBufferChunk::kChunkSize; i < handles.size(); ++i) {
126 975 : CHECK_EQ(names[i], events[i - TraceBufferChunk::kChunkSize]);
127 : }
128 655 : delete ring_buffer;
129 5 : }
130 :
131 10 : void PopulateJSONWriter(TraceWriter* writer) {
132 10 : v8::Platform* old_platform = i::V8::GetCurrentPlatform();
133 : std::unique_ptr<v8::Platform> default_platform(
134 20 : v8::platform::NewDefaultPlatform());
135 10 : i::V8::SetPlatformForTesting(default_platform.get());
136 10 : auto tracing = base::make_unique<v8::platform::tracing::TracingController>();
137 : v8::platform::tracing::TracingController* tracing_controller = tracing.get();
138 : static_cast<v8::platform::DefaultPlatform*>(default_platform.get())
139 20 : ->SetTracingController(std::move(tracing));
140 :
141 : TraceBuffer* ring_buffer =
142 10 : TraceBuffer::CreateTraceBufferRingBuffer(1, writer);
143 10 : tracing_controller->Initialize(ring_buffer);
144 10 : TraceConfig* trace_config = new TraceConfig();
145 10 : trace_config->AddIncludedCategory("v8-cat");
146 10 : tracing_controller->StartTracing(trace_config);
147 :
148 10 : TraceObject trace_object;
149 : trace_object.InitializeForTesting(
150 10 : 'X', tracing_controller->GetCategoryGroupEnabled("v8-cat"), "Test0",
151 : v8::internal::tracing::kGlobalScope, 42, 123, 0, nullptr, nullptr,
152 10 : nullptr, nullptr, TRACE_EVENT_FLAG_HAS_ID, 11, 22, 100, 50, 33, 44);
153 10 : writer->AppendTraceEvent(&trace_object);
154 : trace_object.InitializeForTesting(
155 10 : 'Y', tracing_controller->GetCategoryGroupEnabled("v8-cat"), "Test1",
156 : v8::internal::tracing::kGlobalScope, 43, 456, 0, nullptr, nullptr,
157 10 : nullptr, nullptr, 0, 55, 66, 110, 55, 77, 88);
158 10 : writer->AppendTraceEvent(&trace_object);
159 10 : tracing_controller->StopTracing();
160 10 : i::V8::SetPlatformForTesting(old_platform);
161 10 : }
162 :
163 28342 : TEST(TestJSONTraceWriter) {
164 5 : std::ostringstream stream;
165 5 : TraceWriter* writer = TraceWriter::CreateJSONTraceWriter(stream);
166 5 : PopulateJSONWriter(writer);
167 : std::string trace_str = stream.str();
168 : std::string expected_trace_str =
169 : "{\"traceEvents\":[{\"pid\":11,\"tid\":22,\"ts\":100,\"tts\":50,"
170 : "\"ph\":\"X\",\"cat\":\"v8-cat\",\"name\":\"Test0\",\"dur\":33,"
171 : "\"tdur\":44,\"id\":\"0x2a\",\"args\":{}},{\"pid\":55,\"tid\":66,"
172 : "\"ts\":110,\"tts\":55,\"ph\":\"Y\",\"cat\":\"v8-cat\",\"name\":"
173 5 : "\"Test1\",\"dur\":77,\"tdur\":88,\"args\":{}}]}";
174 :
175 10 : CHECK_EQ(expected_trace_str, trace_str);
176 5 : }
177 :
178 28342 : TEST(TestJSONTraceWriterWithCustomtag) {
179 5 : std::ostringstream stream;
180 10 : TraceWriter* writer = TraceWriter::CreateJSONTraceWriter(stream, "customTag");
181 5 : PopulateJSONWriter(writer);
182 : std::string trace_str = stream.str();
183 : std::string expected_trace_str =
184 : "{\"customTag\":[{\"pid\":11,\"tid\":22,\"ts\":100,\"tts\":50,"
185 : "\"ph\":\"X\",\"cat\":\"v8-cat\",\"name\":\"Test0\",\"dur\":33,"
186 : "\"tdur\":44,\"id\":\"0x2a\",\"args\":{}},{\"pid\":55,\"tid\":66,"
187 : "\"ts\":110,\"tts\":55,\"ph\":\"Y\",\"cat\":\"v8-cat\",\"name\":"
188 5 : "\"Test1\",\"dur\":77,\"tdur\":88,\"args\":{}}]}";
189 :
190 10 : CHECK_EQ(expected_trace_str, trace_str);
191 5 : }
192 :
193 28342 : TEST(TestTracingController) {
194 5 : v8::Platform* old_platform = i::V8::GetCurrentPlatform();
195 : std::unique_ptr<v8::Platform> default_platform(
196 10 : v8::platform::NewDefaultPlatform());
197 5 : i::V8::SetPlatformForTesting(default_platform.get());
198 :
199 5 : auto tracing = base::make_unique<v8::platform::tracing::TracingController>();
200 : v8::platform::tracing::TracingController* tracing_controller = tracing.get();
201 : static_cast<v8::platform::DefaultPlatform*>(default_platform.get())
202 10 : ->SetTracingController(std::move(tracing));
203 :
204 5 : MockTraceWriter* writer = new MockTraceWriter();
205 : TraceBuffer* ring_buffer =
206 5 : TraceBuffer::CreateTraceBufferRingBuffer(1, writer);
207 5 : tracing_controller->Initialize(ring_buffer);
208 5 : TraceConfig* trace_config = new TraceConfig();
209 5 : trace_config->AddIncludedCategory("v8");
210 5 : tracing_controller->StartTracing(trace_config);
211 :
212 15 : TRACE_EVENT0("v8", "v8.Test");
213 : // cat category is not included in default config
214 15 : TRACE_EVENT0("cat", "v8.Test2");
215 15 : TRACE_EVENT0("v8", "v8.Test3");
216 5 : tracing_controller->StopTracing();
217 :
218 10 : CHECK_EQ(2u, writer->events().size());
219 10 : CHECK_EQ(std::string("v8.Test"), writer->events()[0]);
220 10 : CHECK_EQ(std::string("v8.Test3"), writer->events()[1]);
221 :
222 5 : i::V8::SetPlatformForTesting(old_platform);
223 5 : }
224 :
225 15 : void GetJSONStrings(std::vector<std::string>& ret, std::string str,
226 : std::string param, std::string start_delim,
227 : std::string end_delim) {
228 : size_t pos = str.find(param);
229 390 : while (pos != std::string::npos) {
230 360 : size_t start_pos = str.find(start_delim, pos + param.length());
231 360 : size_t end_pos = str.find(end_delim, start_pos + 1);
232 360 : CHECK_NE(start_pos, std::string::npos);
233 360 : CHECK_NE(end_pos, std::string::npos);
234 720 : ret.push_back(str.substr(start_pos + 1, end_pos - start_pos - 1));
235 360 : pos = str.find(param, pos + 1);
236 : }
237 15 : }
238 :
239 28342 : TEST(TestTracingControllerMultipleArgsAndCopy) {
240 5 : std::ostringstream stream;
241 5 : uint64_t aa = 11;
242 5 : unsigned int bb = 22;
243 5 : uint16_t cc = 33;
244 5 : unsigned char dd = 44;
245 5 : int64_t ee = -55;
246 5 : int ff = -66;
247 5 : int16_t gg = -77;
248 5 : signed char hh = -88;
249 5 : bool ii1 = true;
250 5 : bool ii2 = false;
251 5 : double jj1 = 99.0;
252 5 : double jj2 = 1e100;
253 5 : double jj3 = std::numeric_limits<double>::quiet_NaN();
254 5 : double jj4 = std::numeric_limits<double>::infinity();
255 5 : double jj5 = -std::numeric_limits<double>::infinity();
256 5 : void* kk = &aa;
257 5 : const char* ll = "100";
258 5 : std::string mm = "INIT";
259 5 : std::string mmm = "\"INIT\"";
260 :
261 : // Create a scope for the tracing controller to terminate the trace writer.
262 : {
263 5 : v8::Platform* old_platform = i::V8::GetCurrentPlatform();
264 : std::unique_ptr<v8::Platform> default_platform(
265 10 : v8::platform::NewDefaultPlatform());
266 5 : i::V8::SetPlatformForTesting(default_platform.get());
267 :
268 : auto tracing =
269 5 : base::make_unique<v8::platform::tracing::TracingController>();
270 : v8::platform::tracing::TracingController* tracing_controller =
271 : tracing.get();
272 : static_cast<v8::platform::DefaultPlatform*>(default_platform.get())
273 10 : ->SetTracingController(std::move(tracing));
274 5 : TraceWriter* writer = TraceWriter::CreateJSONTraceWriter(stream);
275 :
276 : TraceBuffer* ring_buffer =
277 5 : TraceBuffer::CreateTraceBufferRingBuffer(1, writer);
278 5 : tracing_controller->Initialize(ring_buffer);
279 5 : TraceConfig* trace_config = new TraceConfig();
280 5 : trace_config->AddIncludedCategory("v8");
281 5 : tracing_controller->StartTracing(trace_config);
282 :
283 15 : TRACE_EVENT1("v8", "v8.Test.aa", "aa", aa);
284 15 : TRACE_EVENT1("v8", "v8.Test.bb", "bb", bb);
285 15 : TRACE_EVENT1("v8", "v8.Test.cc", "cc", cc);
286 15 : TRACE_EVENT1("v8", "v8.Test.dd", "dd", dd);
287 15 : TRACE_EVENT1("v8", "v8.Test.ee", "ee", ee);
288 15 : TRACE_EVENT1("v8", "v8.Test.ff", "ff", ff);
289 15 : TRACE_EVENT1("v8", "v8.Test.gg", "gg", gg);
290 15 : TRACE_EVENT1("v8", "v8.Test.hh", "hh", hh);
291 15 : TRACE_EVENT1("v8", "v8.Test.ii", "ii1", ii1);
292 15 : TRACE_EVENT1("v8", "v8.Test.ii", "ii2", ii2);
293 15 : TRACE_EVENT1("v8", "v8.Test.jj1", "jj1", jj1);
294 15 : TRACE_EVENT1("v8", "v8.Test.jj2", "jj2", jj2);
295 15 : TRACE_EVENT1("v8", "v8.Test.jj3", "jj3", jj3);
296 15 : TRACE_EVENT1("v8", "v8.Test.jj4", "jj4", jj4);
297 15 : TRACE_EVENT1("v8", "v8.Test.jj5", "jj5", jj5);
298 15 : TRACE_EVENT1("v8", "v8.Test.kk", "kk", kk);
299 15 : TRACE_EVENT1("v8", "v8.Test.ll", "ll", ll);
300 20 : TRACE_EVENT1("v8", "v8.Test.mm", "mm", TRACE_STR_COPY(mmm.c_str()));
301 :
302 15 : TRACE_EVENT2("v8", "v8.Test2.1", "aa", aa, "ll", ll);
303 20 : TRACE_EVENT2("v8", "v8.Test2.2", "mm1", TRACE_STR_COPY(mm.c_str()), "mm2",
304 : TRACE_STR_COPY(mmm.c_str()));
305 :
306 : // Check copies are correct.
307 10 : TRACE_EVENT_COPY_INSTANT0("v8", mm.c_str(), TRACE_EVENT_SCOPE_THREAD);
308 25 : TRACE_EVENT_COPY_INSTANT2("v8", mm.c_str(), TRACE_EVENT_SCOPE_THREAD, "mm1",
309 : mm.c_str(), "mm2", mmm.c_str());
310 : mm = "CHANGED";
311 : mmm = "CHANGED";
312 :
313 20 : TRACE_EVENT_INSTANT1("v8", "v8.Test", TRACE_EVENT_SCOPE_THREAD, "a1",
314 : new ConvertableToTraceFormatMock(42));
315 : std::unique_ptr<ConvertableToTraceFormatMock> trace_event_arg(
316 5 : new ConvertableToTraceFormatMock(42));
317 20 : TRACE_EVENT_INSTANT2("v8", "v8.Test", TRACE_EVENT_SCOPE_THREAD, "a1",
318 : std::move(trace_event_arg), "a2",
319 : new ConvertableToTraceFormatMock(123));
320 :
321 5 : tracing_controller->StopTracing();
322 :
323 5 : i::V8::SetPlatformForTesting(old_platform);
324 : }
325 :
326 : std::string trace_str = stream.str();
327 :
328 5 : std::vector<std::string> all_args, all_names, all_cats;
329 25 : GetJSONStrings(all_args, trace_str, "\"args\"", "{", "}");
330 25 : GetJSONStrings(all_names, trace_str, "\"name\"", "\"", "\"");
331 25 : GetJSONStrings(all_cats, trace_str, "\"cat\"", "\"", "\"");
332 :
333 10 : CHECK_EQ(all_args.size(), 24u);
334 5 : CHECK_EQ(all_args[0], "\"aa\":11");
335 10 : CHECK_EQ(all_args[1], "\"bb\":22");
336 10 : CHECK_EQ(all_args[2], "\"cc\":33");
337 10 : CHECK_EQ(all_args[3], "\"dd\":44");
338 10 : CHECK_EQ(all_args[4], "\"ee\":-55");
339 10 : CHECK_EQ(all_args[5], "\"ff\":-66");
340 10 : CHECK_EQ(all_args[6], "\"gg\":-77");
341 10 : CHECK_EQ(all_args[7], "\"hh\":-88");
342 10 : CHECK_EQ(all_args[8], "\"ii1\":true");
343 10 : CHECK_EQ(all_args[9], "\"ii2\":false");
344 10 : CHECK_EQ(all_args[10], "\"jj1\":99.0");
345 10 : CHECK_EQ(all_args[11], "\"jj2\":1e+100");
346 10 : CHECK_EQ(all_args[12], "\"jj3\":\"NaN\"");
347 10 : CHECK_EQ(all_args[13], "\"jj4\":\"Infinity\"");
348 10 : CHECK_EQ(all_args[14], "\"jj5\":\"-Infinity\"");
349 10 : std::ostringstream pointer_stream;
350 10 : pointer_stream << "\"kk\":\"" << &aa << "\"";
351 10 : CHECK_EQ(all_args[15], pointer_stream.str());
352 10 : CHECK_EQ(all_args[16], "\"ll\":\"100\"");
353 10 : CHECK_EQ(all_args[17], "\"mm\":\"\\\"INIT\\\"\"");
354 :
355 10 : CHECK_EQ(all_names[18], "v8.Test2.1");
356 10 : CHECK_EQ(all_args[18], "\"aa\":11,\"ll\":\"100\"");
357 10 : CHECK_EQ(all_args[19], "\"mm1\":\"INIT\",\"mm2\":\"\\\"INIT\\\"\"");
358 :
359 10 : CHECK_EQ(all_names[20], "INIT");
360 10 : CHECK_EQ(all_names[21], "INIT");
361 10 : CHECK_EQ(all_args[21], "\"mm1\":\"INIT\",\"mm2\":\"\\\"INIT\\\"\"");
362 10 : CHECK_EQ(all_args[22], "\"a1\":[42,42]");
363 15 : CHECK_EQ(all_args[23], "\"a1\":[42,42],\"a2\":[123,123]");
364 5 : }
365 :
366 : namespace {
367 :
368 10 : class TraceStateObserverImpl : public TracingController::TraceStateObserver {
369 : public:
370 10 : void OnTraceEnabled() override { ++enabled_count; }
371 5 : void OnTraceDisabled() override { ++disabled_count; }
372 :
373 : int enabled_count = 0;
374 : int disabled_count = 0;
375 : };
376 :
377 : } // namespace
378 :
379 28342 : TEST(TracingObservers) {
380 5 : v8::Platform* old_platform = i::V8::GetCurrentPlatform();
381 : std::unique_ptr<v8::Platform> default_platform(
382 10 : v8::platform::NewDefaultPlatform());
383 5 : i::V8::SetPlatformForTesting(default_platform.get());
384 :
385 5 : auto tracing = base::make_unique<v8::platform::tracing::TracingController>();
386 : v8::platform::tracing::TracingController* tracing_controller = tracing.get();
387 : static_cast<v8::platform::DefaultPlatform*>(default_platform.get())
388 10 : ->SetTracingController(std::move(tracing));
389 5 : MockTraceWriter* writer = new MockTraceWriter();
390 : v8::platform::tracing::TraceBuffer* ring_buffer =
391 : v8::platform::tracing::TraceBuffer::CreateTraceBufferRingBuffer(1,
392 5 : writer);
393 5 : tracing_controller->Initialize(ring_buffer);
394 : v8::platform::tracing::TraceConfig* trace_config =
395 5 : new v8::platform::tracing::TraceConfig();
396 5 : trace_config->AddIncludedCategory("v8");
397 :
398 5 : TraceStateObserverImpl observer;
399 5 : tracing_controller->AddTraceStateObserver(&observer);
400 :
401 5 : CHECK_EQ(0, observer.enabled_count);
402 5 : CHECK_EQ(0, observer.disabled_count);
403 :
404 5 : tracing_controller->StartTracing(trace_config);
405 :
406 5 : CHECK_EQ(1, observer.enabled_count);
407 5 : CHECK_EQ(0, observer.disabled_count);
408 :
409 5 : TraceStateObserverImpl observer2;
410 5 : tracing_controller->AddTraceStateObserver(&observer2);
411 :
412 5 : CHECK_EQ(1, observer2.enabled_count);
413 5 : CHECK_EQ(0, observer2.disabled_count);
414 :
415 5 : tracing_controller->RemoveTraceStateObserver(&observer2);
416 :
417 5 : CHECK_EQ(1, observer2.enabled_count);
418 5 : CHECK_EQ(0, observer2.disabled_count);
419 :
420 5 : tracing_controller->StopTracing();
421 :
422 5 : CHECK_EQ(1, observer.enabled_count);
423 5 : CHECK_EQ(1, observer.disabled_count);
424 5 : CHECK_EQ(1, observer2.enabled_count);
425 5 : CHECK_EQ(0, observer2.disabled_count);
426 :
427 5 : tracing_controller->RemoveTraceStateObserver(&observer);
428 :
429 5 : CHECK_EQ(1, observer.enabled_count);
430 5 : CHECK_EQ(1, observer.disabled_count);
431 :
432 5 : trace_config = new v8::platform::tracing::TraceConfig();
433 5 : tracing_controller->StartTracing(trace_config);
434 5 : tracing_controller->StopTracing();
435 :
436 5 : CHECK_EQ(1, observer.enabled_count);
437 5 : CHECK_EQ(1, observer.disabled_count);
438 :
439 5 : i::V8::SetPlatformForTesting(old_platform);
440 5 : }
441 :
442 : } // namespace tracing
443 : } // namespace platform
444 85011 : } // namespace v8
|
