OLD | NEW |
1 // Copyright (c) 2014 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/trace_event/trace_event_argument.h" | 5 #include "base/trace_event/trace_event_argument.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
(...skipping 226 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
237 | 237 |
238 void TracedValue::SetValue(const char* name, | 238 void TracedValue::SetValue(const char* name, |
239 std::unique_ptr<base::Value> value) { | 239 std::unique_ptr<base::Value> value) { |
240 SetBaseValueWithCopiedName(name, *value); | 240 SetBaseValueWithCopiedName(name, *value); |
241 } | 241 } |
242 | 242 |
243 void TracedValue::SetBaseValueWithCopiedName(base::StringPiece name, | 243 void TracedValue::SetBaseValueWithCopiedName(base::StringPiece name, |
244 const base::Value& value) { | 244 const base::Value& value) { |
245 DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict); | 245 DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict); |
246 switch (value.GetType()) { | 246 switch (value.GetType()) { |
247 case base::Value::TYPE_NULL: | 247 case base::Value::Type::NONE: |
248 case base::Value::TYPE_BINARY: | 248 case base::Value::Type::BINARY: |
249 NOTREACHED(); | 249 NOTREACHED(); |
250 break; | 250 break; |
251 | 251 |
252 case base::Value::TYPE_BOOLEAN: { | 252 case base::Value::Type::BOOLEAN: { |
253 bool bool_value; | 253 bool bool_value; |
254 value.GetAsBoolean(&bool_value); | 254 value.GetAsBoolean(&bool_value); |
255 SetBooleanWithCopiedName(name, bool_value); | 255 SetBooleanWithCopiedName(name, bool_value); |
256 } break; | 256 } break; |
257 | 257 |
258 case base::Value::TYPE_INTEGER: { | 258 case base::Value::Type::INTEGER: { |
259 int int_value; | 259 int int_value; |
260 value.GetAsInteger(&int_value); | 260 value.GetAsInteger(&int_value); |
261 SetIntegerWithCopiedName(name, int_value); | 261 SetIntegerWithCopiedName(name, int_value); |
262 } break; | 262 } break; |
263 | 263 |
264 case base::Value::TYPE_DOUBLE: { | 264 case base::Value::Type::DOUBLE: { |
265 double double_value; | 265 double double_value; |
266 value.GetAsDouble(&double_value); | 266 value.GetAsDouble(&double_value); |
267 SetDoubleWithCopiedName(name, double_value); | 267 SetDoubleWithCopiedName(name, double_value); |
268 } break; | 268 } break; |
269 | 269 |
270 case base::Value::TYPE_STRING: { | 270 case base::Value::Type::STRING: { |
271 const StringValue* string_value; | 271 const StringValue* string_value; |
272 value.GetAsString(&string_value); | 272 value.GetAsString(&string_value); |
273 SetStringWithCopiedName(name, string_value->GetString()); | 273 SetStringWithCopiedName(name, string_value->GetString()); |
274 } break; | 274 } break; |
275 | 275 |
276 case base::Value::TYPE_DICTIONARY: { | 276 case base::Value::Type::DICTIONARY: { |
277 const DictionaryValue* dict_value; | 277 const DictionaryValue* dict_value; |
278 value.GetAsDictionary(&dict_value); | 278 value.GetAsDictionary(&dict_value); |
279 BeginDictionaryWithCopiedName(name); | 279 BeginDictionaryWithCopiedName(name); |
280 for (DictionaryValue::Iterator it(*dict_value); !it.IsAtEnd(); | 280 for (DictionaryValue::Iterator it(*dict_value); !it.IsAtEnd(); |
281 it.Advance()) { | 281 it.Advance()) { |
282 SetBaseValueWithCopiedName(it.key(), it.value()); | 282 SetBaseValueWithCopiedName(it.key(), it.value()); |
283 } | 283 } |
284 EndDictionary(); | 284 EndDictionary(); |
285 } break; | 285 } break; |
286 | 286 |
287 case base::Value::TYPE_LIST: { | 287 case base::Value::Type::LIST: { |
288 const ListValue* list_value; | 288 const ListValue* list_value; |
289 value.GetAsList(&list_value); | 289 value.GetAsList(&list_value); |
290 BeginArrayWithCopiedName(name); | 290 BeginArrayWithCopiedName(name); |
291 for (const auto& base_value : *list_value) | 291 for (const auto& base_value : *list_value) |
292 AppendBaseValue(*base_value); | 292 AppendBaseValue(*base_value); |
293 EndArray(); | 293 EndArray(); |
294 } break; | 294 } break; |
295 } | 295 } |
296 } | 296 } |
297 | 297 |
298 void TracedValue::AppendBaseValue(const base::Value& value) { | 298 void TracedValue::AppendBaseValue(const base::Value& value) { |
299 DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray); | 299 DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray); |
300 switch (value.GetType()) { | 300 switch (value.GetType()) { |
301 case base::Value::TYPE_NULL: | 301 case base::Value::Type::NONE: |
302 case base::Value::TYPE_BINARY: | 302 case base::Value::Type::BINARY: |
303 NOTREACHED(); | 303 NOTREACHED(); |
304 break; | 304 break; |
305 | 305 |
306 case base::Value::TYPE_BOOLEAN: { | 306 case base::Value::Type::BOOLEAN: { |
307 bool bool_value; | 307 bool bool_value; |
308 value.GetAsBoolean(&bool_value); | 308 value.GetAsBoolean(&bool_value); |
309 AppendBoolean(bool_value); | 309 AppendBoolean(bool_value); |
310 } break; | 310 } break; |
311 | 311 |
312 case base::Value::TYPE_INTEGER: { | 312 case base::Value::Type::INTEGER: { |
313 int int_value; | 313 int int_value; |
314 value.GetAsInteger(&int_value); | 314 value.GetAsInteger(&int_value); |
315 AppendInteger(int_value); | 315 AppendInteger(int_value); |
316 } break; | 316 } break; |
317 | 317 |
318 case base::Value::TYPE_DOUBLE: { | 318 case base::Value::Type::DOUBLE: { |
319 double double_value; | 319 double double_value; |
320 value.GetAsDouble(&double_value); | 320 value.GetAsDouble(&double_value); |
321 AppendDouble(double_value); | 321 AppendDouble(double_value); |
322 } break; | 322 } break; |
323 | 323 |
324 case base::Value::TYPE_STRING: { | 324 case base::Value::Type::STRING: { |
325 const StringValue* string_value; | 325 const StringValue* string_value; |
326 value.GetAsString(&string_value); | 326 value.GetAsString(&string_value); |
327 AppendString(string_value->GetString()); | 327 AppendString(string_value->GetString()); |
328 } break; | 328 } break; |
329 | 329 |
330 case base::Value::TYPE_DICTIONARY: { | 330 case base::Value::Type::DICTIONARY: { |
331 const DictionaryValue* dict_value; | 331 const DictionaryValue* dict_value; |
332 value.GetAsDictionary(&dict_value); | 332 value.GetAsDictionary(&dict_value); |
333 BeginDictionary(); | 333 BeginDictionary(); |
334 for (DictionaryValue::Iterator it(*dict_value); !it.IsAtEnd(); | 334 for (DictionaryValue::Iterator it(*dict_value); !it.IsAtEnd(); |
335 it.Advance()) { | 335 it.Advance()) { |
336 SetBaseValueWithCopiedName(it.key(), it.value()); | 336 SetBaseValueWithCopiedName(it.key(), it.value()); |
337 } | 337 } |
338 EndDictionary(); | 338 EndDictionary(); |
339 } break; | 339 } break; |
340 | 340 |
341 case base::Value::TYPE_LIST: { | 341 case base::Value::Type::LIST: { |
342 const ListValue* list_value; | 342 const ListValue* list_value; |
343 value.GetAsList(&list_value); | 343 value.GetAsList(&list_value); |
344 BeginArray(); | 344 BeginArray(); |
345 for (const auto& base_value : *list_value) | 345 for (const auto& base_value : *list_value) |
346 AppendBaseValue(*base_value); | 346 AppendBaseValue(*base_value); |
347 EndArray(); | 347 EndArray(); |
348 } break; | 348 } break; |
349 } | 349 } |
350 } | 350 } |
351 | 351 |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
464 TraceEventMemoryOverhead* overhead) { | 464 TraceEventMemoryOverhead* overhead) { |
465 overhead->Add("TracedValue", | 465 overhead->Add("TracedValue", |
466 /* allocated size */ | 466 /* allocated size */ |
467 pickle_.GetTotalAllocatedSize(), | 467 pickle_.GetTotalAllocatedSize(), |
468 /* resident size */ | 468 /* resident size */ |
469 pickle_.size()); | 469 pickle_.size()); |
470 } | 470 } |
471 | 471 |
472 } // namespace trace_event | 472 } // namespace trace_event |
473 } // namespace base | 473 } // namespace base |
OLD | NEW |