OLD | NEW |
1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2015 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_config.h" | 5 #include "base/trace_event/trace_config.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
(...skipping 29 matching lines...) Expand all Loading... |
40 const char kEnableArgumentFilterParam[] = "enable_argument_filter"; | 40 const char kEnableArgumentFilterParam[] = "enable_argument_filter"; |
41 const char kIncludedCategoriesParam[] = "included_categories"; | 41 const char kIncludedCategoriesParam[] = "included_categories"; |
42 const char kExcludedCategoriesParam[] = "excluded_categories"; | 42 const char kExcludedCategoriesParam[] = "excluded_categories"; |
43 const char kSyntheticDelaysParam[] = "synthetic_delays"; | 43 const char kSyntheticDelaysParam[] = "synthetic_delays"; |
44 | 44 |
45 const char kSyntheticDelayCategoryFilterPrefix[] = "DELAY("; | 45 const char kSyntheticDelayCategoryFilterPrefix[] = "DELAY("; |
46 | 46 |
47 // String parameters that is used to parse memory dump config in trace config | 47 // String parameters that is used to parse memory dump config in trace config |
48 // string. | 48 // string. |
49 const char kMemoryDumpConfigParam[] = "memory_dump_config"; | 49 const char kMemoryDumpConfigParam[] = "memory_dump_config"; |
| 50 const char kAllowedDumpModesParam[] = "allowed_dump_modes"; |
50 const char kTriggersParam[] = "triggers"; | 51 const char kTriggersParam[] = "triggers"; |
51 const char kPeriodicIntervalParam[] = "periodic_interval_ms"; | 52 const char kPeriodicIntervalParam[] = "periodic_interval_ms"; |
52 const char kModeParam[] = "mode"; | 53 const char kModeParam[] = "mode"; |
53 const char kHeapProfilerOptions[] = "heap_profiler_options"; | 54 const char kHeapProfilerOptions[] = "heap_profiler_options"; |
54 const char kBreakdownThresholdBytes[] = "breakdown_threshold_bytes"; | 55 const char kBreakdownThresholdBytes[] = "breakdown_threshold_bytes"; |
55 | 56 |
56 // Default configuration of memory dumps. | 57 // Default configuration of memory dumps. |
57 const TraceConfig::MemoryDumpConfig::Trigger kDefaultHeavyMemoryDumpTrigger = { | 58 const TraceConfig::MemoryDumpConfig::Trigger kDefaultHeavyMemoryDumpTrigger = { |
58 2000, // periodic_interval_ms | 59 2000, // periodic_interval_ms |
59 MemoryDumpLevelOfDetail::DETAILED}; | 60 MemoryDumpLevelOfDetail::DETAILED}; |
60 const TraceConfig::MemoryDumpConfig::Trigger kDefaultLightMemoryDumpTrigger = { | 61 const TraceConfig::MemoryDumpConfig::Trigger kDefaultLightMemoryDumpTrigger = { |
61 250, // periodic_interval_ms | 62 250, // periodic_interval_ms |
62 MemoryDumpLevelOfDetail::LIGHT}; | 63 MemoryDumpLevelOfDetail::LIGHT}; |
63 | 64 |
64 class ConvertableTraceConfigToTraceFormat | 65 class ConvertableTraceConfigToTraceFormat |
65 : public base::trace_event::ConvertableToTraceFormat { | 66 : public base::trace_event::ConvertableToTraceFormat { |
66 public: | 67 public: |
67 explicit ConvertableTraceConfigToTraceFormat(const TraceConfig& trace_config) | 68 explicit ConvertableTraceConfigToTraceFormat(const TraceConfig& trace_config) |
68 : trace_config_(trace_config) {} | 69 : trace_config_(trace_config) {} |
69 ~ConvertableTraceConfigToTraceFormat() override {} | 70 ~ConvertableTraceConfigToTraceFormat() override {} |
70 void AppendAsTraceFormat(std::string* out) const override { | 71 void AppendAsTraceFormat(std::string* out) const override { |
71 out->append(trace_config_.ToString()); | 72 out->append(trace_config_.ToString()); |
72 } | 73 } |
73 | 74 |
74 private: | 75 private: |
75 const TraceConfig trace_config_; | 76 const TraceConfig trace_config_; |
76 }; | 77 }; |
77 | 78 |
| 79 std::set<MemoryDumpLevelOfDetail> GetDefaultAllowedMemoryDumpModes() { |
| 80 std::set<MemoryDumpLevelOfDetail> all_modes; |
| 81 for (auto mode = MemoryDumpLevelOfDetail::FIRST; |
| 82 mode <= MemoryDumpLevelOfDetail::LAST; |
| 83 mode = static_cast<MemoryDumpLevelOfDetail>(static_cast<uint32_t>(mode) + |
| 84 1)) { |
| 85 all_modes.insert(mode); |
| 86 } |
| 87 return all_modes; |
| 88 } |
| 89 |
78 } // namespace | 90 } // namespace |
79 | 91 |
80 | 92 |
81 TraceConfig::MemoryDumpConfig::HeapProfiler::HeapProfiler() : | 93 TraceConfig::MemoryDumpConfig::HeapProfiler::HeapProfiler() : |
82 breakdown_threshold_bytes(kDefaultBreakdownThresholdBytes) {}; | 94 breakdown_threshold_bytes(kDefaultBreakdownThresholdBytes) {}; |
83 | 95 |
84 void TraceConfig::MemoryDumpConfig::HeapProfiler::Clear() { | 96 void TraceConfig::MemoryDumpConfig::HeapProfiler::Clear() { |
85 breakdown_threshold_bytes = kDefaultBreakdownThresholdBytes; | 97 breakdown_threshold_bytes = kDefaultBreakdownThresholdBytes; |
86 } | 98 } |
87 | 99 |
88 void TraceConfig::ResetMemoryDumpConfig( | 100 void TraceConfig::ResetMemoryDumpConfig( |
89 const TraceConfig::MemoryDumpConfig& memory_dump_config) { | 101 const TraceConfig::MemoryDumpConfig& memory_dump_config) { |
90 memory_dump_config_.Clear(); | 102 memory_dump_config_.Clear(); |
91 memory_dump_config_ = memory_dump_config; | 103 memory_dump_config_ = memory_dump_config; |
92 } | 104 } |
93 | 105 |
94 TraceConfig::MemoryDumpConfig::MemoryDumpConfig() {}; | 106 TraceConfig::MemoryDumpConfig::MemoryDumpConfig() {}; |
95 | 107 |
96 TraceConfig::MemoryDumpConfig::MemoryDumpConfig( | 108 TraceConfig::MemoryDumpConfig::MemoryDumpConfig( |
97 const MemoryDumpConfig& other) = default; | 109 const MemoryDumpConfig& other) = default; |
98 | 110 |
99 TraceConfig::MemoryDumpConfig::~MemoryDumpConfig() {}; | 111 TraceConfig::MemoryDumpConfig::~MemoryDumpConfig() {}; |
100 | 112 |
101 void TraceConfig::MemoryDumpConfig::Clear() { | 113 void TraceConfig::MemoryDumpConfig::Clear() { |
| 114 allowed_dump_modes.clear(); |
102 triggers.clear(); | 115 triggers.clear(); |
103 heap_profiler_options.Clear(); | 116 heap_profiler_options.Clear(); |
104 } | 117 } |
105 | 118 |
106 TraceConfig::TraceConfig() { | 119 TraceConfig::TraceConfig() { |
107 InitializeDefault(); | 120 InitializeDefault(); |
108 } | 121 } |
109 | 122 |
110 TraceConfig::TraceConfig(const std::string& category_filter_string, | 123 TraceConfig::TraceConfig(const std::string& category_filter_string, |
111 const std::string& trace_options_string) { | 124 const std::string& trace_options_string) { |
(...skipping 398 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
510 ci != categories.end(); | 523 ci != categories.end(); |
511 ++ci) { | 524 ++ci) { |
512 list->AppendString(*ci); | 525 list->AppendString(*ci); |
513 } | 526 } |
514 | 527 |
515 dict.Set(param, std::move(list)); | 528 dict.Set(param, std::move(list)); |
516 } | 529 } |
517 | 530 |
518 void TraceConfig::SetMemoryDumpConfigFromConfigDict( | 531 void TraceConfig::SetMemoryDumpConfigFromConfigDict( |
519 const base::DictionaryValue& memory_dump_config) { | 532 const base::DictionaryValue& memory_dump_config) { |
| 533 // Set allowed dump modes. |
| 534 memory_dump_config_.allowed_dump_modes.clear(); |
| 535 const base::ListValue* allowed_modes_list; |
| 536 if (memory_dump_config.GetList(kAllowedDumpModesParam, &allowed_modes_list)) { |
| 537 for (size_t i = 0; i < allowed_modes_list->GetSize(); ++i) { |
| 538 std::string level_of_detail_str; |
| 539 allowed_modes_list->GetString(i, &level_of_detail_str); |
| 540 memory_dump_config_.allowed_dump_modes.insert( |
| 541 StringToMemoryDumpLevelOfDetail(level_of_detail_str)); |
| 542 } |
| 543 } else { |
| 544 // If allowed modes param is not given then allow all modes by default. |
| 545 memory_dump_config_.allowed_dump_modes = GetDefaultAllowedMemoryDumpModes(); |
| 546 } |
| 547 |
520 // Set triggers | 548 // Set triggers |
521 memory_dump_config_.triggers.clear(); | 549 memory_dump_config_.triggers.clear(); |
522 | |
523 const base::ListValue* trigger_list = nullptr; | 550 const base::ListValue* trigger_list = nullptr; |
524 if (memory_dump_config.GetList(kTriggersParam, &trigger_list) && | 551 if (memory_dump_config.GetList(kTriggersParam, &trigger_list) && |
525 trigger_list->GetSize() > 0) { | 552 trigger_list->GetSize() > 0) { |
526 for (size_t i = 0; i < trigger_list->GetSize(); ++i) { | 553 for (size_t i = 0; i < trigger_list->GetSize(); ++i) { |
527 const base::DictionaryValue* trigger = nullptr; | 554 const base::DictionaryValue* trigger = nullptr; |
528 if (!trigger_list->GetDictionary(i, &trigger)) | 555 if (!trigger_list->GetDictionary(i, &trigger)) |
529 continue; | 556 continue; |
530 | 557 |
531 MemoryDumpConfig::Trigger dump_config; | 558 MemoryDumpConfig::Trigger dump_config; |
532 int interval = 0; | 559 int interval = 0; |
(...skipping 25 matching lines...) Expand all Loading... |
558 memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes = | 585 memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes = |
559 MemoryDumpConfig::HeapProfiler::kDefaultBreakdownThresholdBytes; | 586 MemoryDumpConfig::HeapProfiler::kDefaultBreakdownThresholdBytes; |
560 } | 587 } |
561 } | 588 } |
562 } | 589 } |
563 | 590 |
564 void TraceConfig::SetDefaultMemoryDumpConfig() { | 591 void TraceConfig::SetDefaultMemoryDumpConfig() { |
565 memory_dump_config_.Clear(); | 592 memory_dump_config_.Clear(); |
566 memory_dump_config_.triggers.push_back(kDefaultHeavyMemoryDumpTrigger); | 593 memory_dump_config_.triggers.push_back(kDefaultHeavyMemoryDumpTrigger); |
567 memory_dump_config_.triggers.push_back(kDefaultLightMemoryDumpTrigger); | 594 memory_dump_config_.triggers.push_back(kDefaultLightMemoryDumpTrigger); |
| 595 memory_dump_config_.allowed_dump_modes = GetDefaultAllowedMemoryDumpModes(); |
568 } | 596 } |
569 | 597 |
570 void TraceConfig::ToDict(base::DictionaryValue& dict) const { | 598 void TraceConfig::ToDict(base::DictionaryValue& dict) const { |
571 switch (record_mode_) { | 599 switch (record_mode_) { |
572 case RECORD_UNTIL_FULL: | 600 case RECORD_UNTIL_FULL: |
573 dict.SetString(kRecordModeParam, kRecordUntilFull); | 601 dict.SetString(kRecordModeParam, kRecordUntilFull); |
574 break; | 602 break; |
575 case RECORD_CONTINUOUSLY: | 603 case RECORD_CONTINUOUSLY: |
576 dict.SetString(kRecordModeParam, kRecordContinuously); | 604 dict.SetString(kRecordModeParam, kRecordContinuously); |
577 break; | 605 break; |
(...skipping 26 matching lines...) Expand all Loading... |
604 categories.insert(categories.end(), | 632 categories.insert(categories.end(), |
605 disabled_categories_.begin(), | 633 disabled_categories_.begin(), |
606 disabled_categories_.end()); | 634 disabled_categories_.end()); |
607 AddCategoryToDict(dict, kIncludedCategoriesParam, categories); | 635 AddCategoryToDict(dict, kIncludedCategoriesParam, categories); |
608 AddCategoryToDict(dict, kExcludedCategoriesParam, excluded_categories_); | 636 AddCategoryToDict(dict, kExcludedCategoriesParam, excluded_categories_); |
609 AddCategoryToDict(dict, kSyntheticDelaysParam, synthetic_delays_); | 637 AddCategoryToDict(dict, kSyntheticDelaysParam, synthetic_delays_); |
610 | 638 |
611 if (IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) { | 639 if (IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) { |
612 std::unique_ptr<base::DictionaryValue> memory_dump_config( | 640 std::unique_ptr<base::DictionaryValue> memory_dump_config( |
613 new base::DictionaryValue()); | 641 new base::DictionaryValue()); |
| 642 std::unique_ptr<base::ListValue> allowed_modes_list(new base::ListValue()); |
| 643 for (MemoryDumpLevelOfDetail dump_mode : |
| 644 memory_dump_config_.allowed_dump_modes) { |
| 645 allowed_modes_list->AppendString( |
| 646 MemoryDumpLevelOfDetailToString(dump_mode)); |
| 647 } |
| 648 memory_dump_config->Set(kAllowedDumpModesParam, |
| 649 std::move(allowed_modes_list)); |
| 650 |
614 std::unique_ptr<base::ListValue> triggers_list(new base::ListValue()); | 651 std::unique_ptr<base::ListValue> triggers_list(new base::ListValue()); |
615 for (const MemoryDumpConfig::Trigger& config | 652 for (const MemoryDumpConfig::Trigger& config |
616 : memory_dump_config_.triggers) { | 653 : memory_dump_config_.triggers) { |
617 std::unique_ptr<base::DictionaryValue> trigger_dict( | 654 std::unique_ptr<base::DictionaryValue> trigger_dict( |
618 new base::DictionaryValue()); | 655 new base::DictionaryValue()); |
619 trigger_dict->SetInteger(kPeriodicIntervalParam, | 656 trigger_dict->SetInteger(kPeriodicIntervalParam, |
620 static_cast<int>(config.periodic_interval_ms)); | 657 static_cast<int>(config.periodic_interval_ms)); |
621 trigger_dict->SetString( | 658 trigger_dict->SetString( |
622 kModeParam, MemoryDumpLevelOfDetailToString(config.level_of_detail)); | 659 kModeParam, MemoryDumpLevelOfDetailToString(config.level_of_detail)); |
623 triggers_list->Append(std::move(trigger_dict)); | 660 triggers_list->Append(std::move(trigger_dict)); |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
727 str.at(0) == ' ' || | 764 str.at(0) == ' ' || |
728 str.at(str.length() - 1) == ' '; | 765 str.at(str.length() - 1) == ' '; |
729 } | 766 } |
730 | 767 |
731 bool TraceConfig::HasIncludedPatterns() const { | 768 bool TraceConfig::HasIncludedPatterns() const { |
732 return !included_categories_.empty(); | 769 return !included_categories_.empty(); |
733 } | 770 } |
734 | 771 |
735 } // namespace trace_event | 772 } // namespace trace_event |
736 } // namespace base | 773 } // namespace base |
OLD | NEW |