Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(116)

Side by Side Diff: base/trace_event/trace_event_unittest.cc

Issue 1165673002: [Startup Tracing] Hook up TraceConfig and remove CategoryFilter & TraceOptions (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 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 <math.h> 5 #include <math.h>
6 #include <cstdlib> 6 #include <cstdlib>
7 7
8 #include "base/bind.h" 8 #include "base/bind.h"
9 #include "base/command_line.h" 9 #include "base/command_line.h"
10 #include "base/json/json_reader.h" 10 #include "base/json/json_reader.h"
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after
72 trace_parsed_.Clear(); 72 trace_parsed_.Clear();
73 json_output_.json_output.clear(); 73 json_output_.json_output.clear();
74 } 74 }
75 75
76 void BeginTrace() { 76 void BeginTrace() {
77 BeginSpecificTrace("*"); 77 BeginSpecificTrace("*");
78 } 78 }
79 79
80 void BeginSpecificTrace(const std::string& filter) { 80 void BeginSpecificTrace(const std::string& filter) {
81 event_watch_notification_ = 0; 81 event_watch_notification_ = 0;
82 TraceLog::GetInstance()->SetEnabled( 82 TraceLog::GetInstance()->SetEnabled(TraceConfig(filter, ""),
83 CategoryFilter(filter), 83 TraceLog::RECORDING_MODE);
84 TraceLog::RECORDING_MODE,
85 TraceOptions());
86 } 84 }
87 85
88 void EndTraceAndFlush() { 86 void EndTraceAndFlush() {
89 WaitableEvent flush_complete_event(false, false); 87 WaitableEvent flush_complete_event(false, false);
90 EndTraceAndFlushAsync(&flush_complete_event); 88 EndTraceAndFlushAsync(&flush_complete_event);
91 flush_complete_event.Wait(); 89 flush_complete_event.Wait();
92 } 90 }
93 91
94 // Used when testing thread-local buffers which requires the thread initiating 92 // Used when testing thread-local buffers which requires the thread initiating
95 // flush to have a message loop. 93 // flush to have a message loop.
(...skipping 769 matching lines...) Expand 10 before | Expand all | Expand 10 after
865 for (int event = 0; event < num_events; event++) { 863 for (int event = 0; event < num_events; event++) {
866 EXPECT_TRUE(results[thread][event]); 864 EXPECT_TRUE(results[thread][event]);
867 } 865 }
868 } 866 }
869 } 867 }
870 868
871 } // namespace 869 } // namespace
872 870
873 // Simple Test for emitting data and validating it was received. 871 // Simple Test for emitting data and validating it was received.
874 TEST_F(TraceEventTestFixture, DataCaptured) { 872 TEST_F(TraceEventTestFixture, DataCaptured) {
875 TraceLog::GetInstance()->SetEnabled( 873 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
876 CategoryFilter("*"), 874 TraceLog::RECORDING_MODE);
877 TraceLog::RECORDING_MODE,
878 TraceOptions());
879 875
880 TraceWithAllMacroVariants(NULL); 876 TraceWithAllMacroVariants(NULL);
881 877
882 EndTraceAndFlush(); 878 EndTraceAndFlush();
883 879
884 ValidateAllTraceMacrosCreatedData(trace_parsed_); 880 ValidateAllTraceMacrosCreatedData(trace_parsed_);
885 } 881 }
886 882
887 class MockEnabledStateChangedObserver : 883 class MockEnabledStateChangedObserver :
888 public TraceLog::EnabledStateObserver { 884 public TraceLog::EnabledStateObserver {
889 public: 885 public:
890 MOCK_METHOD0(OnTraceLogEnabled, void()); 886 MOCK_METHOD0(OnTraceLogEnabled, void());
891 MOCK_METHOD0(OnTraceLogDisabled, void()); 887 MOCK_METHOD0(OnTraceLogDisabled, void());
892 }; 888 };
893 889
894 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnEnable) { 890 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnEnable) {
895 MockEnabledStateChangedObserver observer; 891 MockEnabledStateChangedObserver observer;
896 TraceLog::GetInstance()->AddEnabledStateObserver(&observer); 892 TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
897 893
898 EXPECT_CALL(observer, OnTraceLogEnabled()) 894 EXPECT_CALL(observer, OnTraceLogEnabled())
899 .Times(1); 895 .Times(1);
900 TraceLog::GetInstance()->SetEnabled( 896 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
901 CategoryFilter("*"), 897 TraceLog::RECORDING_MODE);
902 TraceLog::RECORDING_MODE,
903 TraceOptions());
904 testing::Mock::VerifyAndClear(&observer); 898 testing::Mock::VerifyAndClear(&observer);
905 EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled()); 899 EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
906 900
907 // Cleanup. 901 // Cleanup.
908 TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer); 902 TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
909 TraceLog::GetInstance()->SetDisabled(); 903 TraceLog::GetInstance()->SetDisabled();
910 } 904 }
911 905
912 TEST_F(TraceEventTestFixture, EnabledObserverDoesntFireOnSecondEnable) { 906 TEST_F(TraceEventTestFixture, EnabledObserverDoesntFireOnSecondEnable) {
913 TraceLog::GetInstance()->SetEnabled( 907 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
914 CategoryFilter("*"), 908 TraceLog::RECORDING_MODE);
915 TraceLog::RECORDING_MODE,
916 TraceOptions());
917 909
918 testing::StrictMock<MockEnabledStateChangedObserver> observer; 910 testing::StrictMock<MockEnabledStateChangedObserver> observer;
919 TraceLog::GetInstance()->AddEnabledStateObserver(&observer); 911 TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
920 912
921 EXPECT_CALL(observer, OnTraceLogEnabled()) 913 EXPECT_CALL(observer, OnTraceLogEnabled())
922 .Times(0); 914 .Times(0);
923 EXPECT_CALL(observer, OnTraceLogDisabled()) 915 EXPECT_CALL(observer, OnTraceLogDisabled())
924 .Times(0); 916 .Times(0);
925 TraceLog::GetInstance()->SetEnabled( 917 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
dsinclair 2015/06/02 13:56:55 What about defining a TraceLog::kRecordAll = "*" o
Zhen Wang 2015/06/02 16:24:42 Done.
926 CategoryFilter("*"), 918 TraceLog::RECORDING_MODE);
927 TraceLog::RECORDING_MODE,
928 TraceOptions());
929 testing::Mock::VerifyAndClear(&observer); 919 testing::Mock::VerifyAndClear(&observer);
930 EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled()); 920 EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
931 921
932 // Cleanup. 922 // Cleanup.
933 TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer); 923 TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
934 TraceLog::GetInstance()->SetDisabled(); 924 TraceLog::GetInstance()->SetDisabled();
935 TraceLog::GetInstance()->SetDisabled(); 925 TraceLog::GetInstance()->SetDisabled();
936 } 926 }
937 927
938 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnFirstDisable) { 928 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnFirstDisable) {
939 CategoryFilter cf_inc_all("*"); 929 TraceConfig tc_inc_all("*", "");
940 TraceLog::GetInstance()->SetEnabled( 930 TraceLog::GetInstance()->SetEnabled(tc_inc_all, TraceLog::RECORDING_MODE);
941 cf_inc_all, 931 TraceLog::GetInstance()->SetEnabled(tc_inc_all, TraceLog::RECORDING_MODE);
942 TraceLog::RECORDING_MODE,
943 TraceOptions());
944 TraceLog::GetInstance()->SetEnabled(
945 cf_inc_all,
946 TraceLog::RECORDING_MODE,
947 TraceOptions());
948 932
949 testing::StrictMock<MockEnabledStateChangedObserver> observer; 933 testing::StrictMock<MockEnabledStateChangedObserver> observer;
950 TraceLog::GetInstance()->AddEnabledStateObserver(&observer); 934 TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
951 935
952 EXPECT_CALL(observer, OnTraceLogEnabled()) 936 EXPECT_CALL(observer, OnTraceLogEnabled())
953 .Times(0); 937 .Times(0);
954 EXPECT_CALL(observer, OnTraceLogDisabled()) 938 EXPECT_CALL(observer, OnTraceLogDisabled())
955 .Times(1); 939 .Times(1);
956 TraceLog::GetInstance()->SetDisabled(); 940 TraceLog::GetInstance()->SetDisabled();
957 testing::Mock::VerifyAndClear(&observer); 941 testing::Mock::VerifyAndClear(&observer);
958 942
959 // Cleanup. 943 // Cleanup.
960 TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer); 944 TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
961 TraceLog::GetInstance()->SetDisabled(); 945 TraceLog::GetInstance()->SetDisabled();
962 } 946 }
963 947
964 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnDisable) { 948 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnDisable) {
965 TraceLog::GetInstance()->SetEnabled( 949 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
966 CategoryFilter("*"), 950 TraceLog::RECORDING_MODE);
967 TraceLog::RECORDING_MODE,
968 TraceOptions());
969 951
970 MockEnabledStateChangedObserver observer; 952 MockEnabledStateChangedObserver observer;
971 TraceLog::GetInstance()->AddEnabledStateObserver(&observer); 953 TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
972 954
973 EXPECT_CALL(observer, OnTraceLogDisabled()) 955 EXPECT_CALL(observer, OnTraceLogDisabled())
974 .Times(1); 956 .Times(1);
975 TraceLog::GetInstance()->SetDisabled(); 957 TraceLog::GetInstance()->SetDisabled();
976 testing::Mock::VerifyAndClear(&observer); 958 testing::Mock::VerifyAndClear(&observer);
977 959
978 // Cleanup. 960 // Cleanup.
(...skipping 14 matching lines...) Expand all
993 975
994 void OnTraceLogDisabled() override { 976 void OnTraceLogDisabled() override {
995 EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled()); 977 EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
996 } 978 }
997 }; 979 };
998 980
999 TEST_F(TraceEventTestFixture, ObserversFireAfterStateChange) { 981 TEST_F(TraceEventTestFixture, ObserversFireAfterStateChange) {
1000 AfterStateChangeEnabledStateObserver observer; 982 AfterStateChangeEnabledStateObserver observer;
1001 TraceLog::GetInstance()->AddEnabledStateObserver(&observer); 983 TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
1002 984
1003 TraceLog::GetInstance()->SetEnabled( 985 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
1004 CategoryFilter("*"), 986 TraceLog::RECORDING_MODE);
1005 TraceLog::RECORDING_MODE,
1006 TraceOptions());
1007 EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled()); 987 EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
1008 988
1009 TraceLog::GetInstance()->SetDisabled(); 989 TraceLog::GetInstance()->SetDisabled();
1010 EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled()); 990 EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
1011 991
1012 TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer); 992 TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
1013 } 993 }
1014 994
1015 // Tests that a state observer can remove itself during a callback. 995 // Tests that a state observer can remove itself during a callback.
1016 class SelfRemovingEnabledStateObserver 996 class SelfRemovingEnabledStateObserver
(...skipping 10 matching lines...) Expand all
1027 } 1007 }
1028 }; 1008 };
1029 1009
1030 TEST_F(TraceEventTestFixture, SelfRemovingObserver) { 1010 TEST_F(TraceEventTestFixture, SelfRemovingObserver) {
1031 ASSERT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest()); 1011 ASSERT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
1032 1012
1033 SelfRemovingEnabledStateObserver observer; 1013 SelfRemovingEnabledStateObserver observer;
1034 TraceLog::GetInstance()->AddEnabledStateObserver(&observer); 1014 TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
1035 EXPECT_EQ(1u, TraceLog::GetInstance()->GetObserverCountForTest()); 1015 EXPECT_EQ(1u, TraceLog::GetInstance()->GetObserverCountForTest());
1036 1016
1037 TraceLog::GetInstance()->SetEnabled( 1017 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
1038 CategoryFilter("*"), 1018 TraceLog::RECORDING_MODE);
1039 TraceLog::RECORDING_MODE,
1040 TraceOptions());
1041 TraceLog::GetInstance()->SetDisabled(); 1019 TraceLog::GetInstance()->SetDisabled();
1042 // The observer removed itself on disable. 1020 // The observer removed itself on disable.
1043 EXPECT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest()); 1021 EXPECT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
1044 } 1022 }
1045 1023
1046 bool IsNewTrace() { 1024 bool IsNewTrace() {
1047 bool is_new_trace; 1025 bool is_new_trace;
1048 TRACE_EVENT_IS_NEW_TRACE(&is_new_trace); 1026 TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
1049 return is_new_trace; 1027 return is_new_trace;
1050 } 1028 }
1051 1029
1052 TEST_F(TraceEventTestFixture, NewTraceRecording) { 1030 TEST_F(TraceEventTestFixture, NewTraceRecording) {
1053 ASSERT_FALSE(IsNewTrace()); 1031 ASSERT_FALSE(IsNewTrace());
1054 TraceLog::GetInstance()->SetEnabled( 1032 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
1055 CategoryFilter("*"), 1033 TraceLog::RECORDING_MODE);
1056 TraceLog::RECORDING_MODE,
1057 TraceOptions());
1058 // First call to IsNewTrace() should succeed. But, the second shouldn't. 1034 // First call to IsNewTrace() should succeed. But, the second shouldn't.
1059 ASSERT_TRUE(IsNewTrace()); 1035 ASSERT_TRUE(IsNewTrace());
1060 ASSERT_FALSE(IsNewTrace()); 1036 ASSERT_FALSE(IsNewTrace());
1061 EndTraceAndFlush(); 1037 EndTraceAndFlush();
1062 1038
1063 // IsNewTrace() should definitely be false now. 1039 // IsNewTrace() should definitely be false now.
1064 ASSERT_FALSE(IsNewTrace()); 1040 ASSERT_FALSE(IsNewTrace());
1065 1041
1066 // Start another trace. IsNewTrace() should become true again, briefly, as 1042 // Start another trace. IsNewTrace() should become true again, briefly, as
1067 // before. 1043 // before.
1068 TraceLog::GetInstance()->SetEnabled( 1044 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
1069 CategoryFilter("*"), 1045 TraceLog::RECORDING_MODE);
1070 TraceLog::RECORDING_MODE,
1071 TraceOptions());
1072 ASSERT_TRUE(IsNewTrace()); 1046 ASSERT_TRUE(IsNewTrace());
1073 ASSERT_FALSE(IsNewTrace()); 1047 ASSERT_FALSE(IsNewTrace());
1074 1048
1075 // Cleanup. 1049 // Cleanup.
1076 EndTraceAndFlush(); 1050 EndTraceAndFlush();
1077 } 1051 }
1078 1052
1079 1053
1080 // Test that categories work. 1054 // Test that categories work.
1081 TEST_F(TraceEventTestFixture, Categories) { 1055 TEST_F(TraceEventTestFixture, Categories) {
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
1116 1090
1117 const std::vector<std::string> empty_categories; 1091 const std::vector<std::string> empty_categories;
1118 std::vector<std::string> included_categories; 1092 std::vector<std::string> included_categories;
1119 std::vector<std::string> excluded_categories; 1093 std::vector<std::string> excluded_categories;
1120 1094
1121 // Test that category filtering works. 1095 // Test that category filtering works.
1122 1096
1123 // Include nonexistent category -> no events 1097 // Include nonexistent category -> no events
1124 Clear(); 1098 Clear();
1125 included_categories.clear(); 1099 included_categories.clear();
1126 TraceLog::GetInstance()->SetEnabled( 1100 TraceLog::GetInstance()->SetEnabled(TraceConfig("not_found823564786", ""),
1127 CategoryFilter("not_found823564786"), 1101 TraceLog::RECORDING_MODE);
1128 TraceLog::RECORDING_MODE,
1129 TraceOptions());
1130 TRACE_EVENT_INSTANT0("cat1", "name", TRACE_EVENT_SCOPE_THREAD); 1102 TRACE_EVENT_INSTANT0("cat1", "name", TRACE_EVENT_SCOPE_THREAD);
1131 TRACE_EVENT_INSTANT0("cat2", "name", TRACE_EVENT_SCOPE_THREAD); 1103 TRACE_EVENT_INSTANT0("cat2", "name", TRACE_EVENT_SCOPE_THREAD);
1132 EndTraceAndFlush(); 1104 EndTraceAndFlush();
1133 DropTracedMetadataRecords(); 1105 DropTracedMetadataRecords();
1134 EXPECT_TRUE(trace_parsed_.empty()); 1106 EXPECT_TRUE(trace_parsed_.empty());
1135 1107
1136 // Include existent category -> only events of that category 1108 // Include existent category -> only events of that category
1137 Clear(); 1109 Clear();
1138 included_categories.clear(); 1110 included_categories.clear();
1139 TraceLog::GetInstance()->SetEnabled( 1111 TraceLog::GetInstance()->SetEnabled(TraceConfig("inc", ""),
1140 CategoryFilter("inc"), 1112 TraceLog::RECORDING_MODE);
1141 TraceLog::RECORDING_MODE,
1142 TraceOptions());
1143 TRACE_EVENT_INSTANT0("inc", "name", TRACE_EVENT_SCOPE_THREAD); 1113 TRACE_EVENT_INSTANT0("inc", "name", TRACE_EVENT_SCOPE_THREAD);
1144 TRACE_EVENT_INSTANT0("inc2", "name", TRACE_EVENT_SCOPE_THREAD); 1114 TRACE_EVENT_INSTANT0("inc2", "name", TRACE_EVENT_SCOPE_THREAD);
1145 EndTraceAndFlush(); 1115 EndTraceAndFlush();
1146 DropTracedMetadataRecords(); 1116 DropTracedMetadataRecords();
1147 EXPECT_TRUE(FindMatchingValue("cat", "inc")); 1117 EXPECT_TRUE(FindMatchingValue("cat", "inc"));
1148 EXPECT_FALSE(FindNonMatchingValue("cat", "inc")); 1118 EXPECT_FALSE(FindNonMatchingValue("cat", "inc"));
1149 1119
1150 // Include existent wildcard -> all categories matching wildcard 1120 // Include existent wildcard -> all categories matching wildcard
1151 Clear(); 1121 Clear();
1152 included_categories.clear(); 1122 included_categories.clear();
1153 TraceLog::GetInstance()->SetEnabled( 1123 TraceLog::GetInstance()->SetEnabled(
1154 CategoryFilter("inc_wildcard_*,inc_wildchar_?_end"), 1124 TraceConfig("inc_wildcard_*,inc_wildchar_?_end", ""),
1155 TraceLog::RECORDING_MODE, 1125 TraceLog::RECORDING_MODE);
1156 TraceOptions());
1157 TRACE_EVENT_INSTANT0("inc_wildcard_abc", "included", 1126 TRACE_EVENT_INSTANT0("inc_wildcard_abc", "included",
1158 TRACE_EVENT_SCOPE_THREAD); 1127 TRACE_EVENT_SCOPE_THREAD);
1159 TRACE_EVENT_INSTANT0("inc_wildcard_", "included", TRACE_EVENT_SCOPE_THREAD); 1128 TRACE_EVENT_INSTANT0("inc_wildcard_", "included", TRACE_EVENT_SCOPE_THREAD);
1160 TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "included", 1129 TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "included",
1161 TRACE_EVENT_SCOPE_THREAD); 1130 TRACE_EVENT_SCOPE_THREAD);
1162 TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "not_inc", 1131 TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "not_inc",
1163 TRACE_EVENT_SCOPE_THREAD); 1132 TRACE_EVENT_SCOPE_THREAD);
1164 TRACE_EVENT_INSTANT0("cat1", "not_inc", TRACE_EVENT_SCOPE_THREAD); 1133 TRACE_EVENT_INSTANT0("cat1", "not_inc", TRACE_EVENT_SCOPE_THREAD);
1165 TRACE_EVENT_INSTANT0("cat2", "not_inc", TRACE_EVENT_SCOPE_THREAD); 1134 TRACE_EVENT_INSTANT0("cat2", "not_inc", TRACE_EVENT_SCOPE_THREAD);
1166 TRACE_EVENT_INSTANT0("inc_wildcard_category,other_category", "included", 1135 TRACE_EVENT_INSTANT0("inc_wildcard_category,other_category", "included",
1167 TRACE_EVENT_SCOPE_THREAD); 1136 TRACE_EVENT_SCOPE_THREAD);
1168 TRACE_EVENT_INSTANT0( 1137 TRACE_EVENT_INSTANT0(
1169 "non_included_category,inc_wildcard_category", "included", 1138 "non_included_category,inc_wildcard_category", "included",
1170 TRACE_EVENT_SCOPE_THREAD); 1139 TRACE_EVENT_SCOPE_THREAD);
1171 EndTraceAndFlush(); 1140 EndTraceAndFlush();
1172 EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_abc")); 1141 EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_abc"));
1173 EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_")); 1142 EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_"));
1174 EXPECT_TRUE(FindMatchingValue("cat", "inc_wildchar_x_end")); 1143 EXPECT_TRUE(FindMatchingValue("cat", "inc_wildchar_x_end"));
1175 EXPECT_FALSE(FindMatchingValue("name", "not_inc")); 1144 EXPECT_FALSE(FindMatchingValue("name", "not_inc"));
1176 EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_category,other_category")); 1145 EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_category,other_category"));
1177 EXPECT_TRUE(FindMatchingValue("cat", 1146 EXPECT_TRUE(FindMatchingValue("cat",
1178 "non_included_category,inc_wildcard_category")); 1147 "non_included_category,inc_wildcard_category"));
1179 1148
1180 included_categories.clear(); 1149 included_categories.clear();
1181 1150
1182 // Exclude nonexistent category -> all events 1151 // Exclude nonexistent category -> all events
1183 Clear(); 1152 Clear();
1184 TraceLog::GetInstance()->SetEnabled( 1153 TraceLog::GetInstance()->SetEnabled(TraceConfig("-not_found823564786", ""),
1185 CategoryFilter("-not_found823564786"), 1154 TraceLog::RECORDING_MODE);
1186 TraceLog::RECORDING_MODE,
1187 TraceOptions());
1188 TRACE_EVENT_INSTANT0("cat1", "name", TRACE_EVENT_SCOPE_THREAD); 1155 TRACE_EVENT_INSTANT0("cat1", "name", TRACE_EVENT_SCOPE_THREAD);
1189 TRACE_EVENT_INSTANT0("cat2", "name", TRACE_EVENT_SCOPE_THREAD); 1156 TRACE_EVENT_INSTANT0("cat2", "name", TRACE_EVENT_SCOPE_THREAD);
1190 TRACE_EVENT_INSTANT0("category1,category2", "name", TRACE_EVENT_SCOPE_THREAD); 1157 TRACE_EVENT_INSTANT0("category1,category2", "name", TRACE_EVENT_SCOPE_THREAD);
1191 EndTraceAndFlush(); 1158 EndTraceAndFlush();
1192 EXPECT_TRUE(FindMatchingValue("cat", "cat1")); 1159 EXPECT_TRUE(FindMatchingValue("cat", "cat1"));
1193 EXPECT_TRUE(FindMatchingValue("cat", "cat2")); 1160 EXPECT_TRUE(FindMatchingValue("cat", "cat2"));
1194 EXPECT_TRUE(FindMatchingValue("cat", "category1,category2")); 1161 EXPECT_TRUE(FindMatchingValue("cat", "category1,category2"));
1195 1162
1196 // Exclude existent category -> only events of other categories 1163 // Exclude existent category -> only events of other categories
1197 Clear(); 1164 Clear();
1198 TraceLog::GetInstance()->SetEnabled( 1165 TraceLog::GetInstance()->SetEnabled(TraceConfig("-inc", ""),
1199 CategoryFilter("-inc"), 1166 TraceLog::RECORDING_MODE);
1200 TraceLog::RECORDING_MODE,
1201 TraceOptions());
1202 TRACE_EVENT_INSTANT0("inc", "name", TRACE_EVENT_SCOPE_THREAD); 1167 TRACE_EVENT_INSTANT0("inc", "name", TRACE_EVENT_SCOPE_THREAD);
1203 TRACE_EVENT_INSTANT0("inc2", "name", TRACE_EVENT_SCOPE_THREAD); 1168 TRACE_EVENT_INSTANT0("inc2", "name", TRACE_EVENT_SCOPE_THREAD);
1204 TRACE_EVENT_INSTANT0("inc2,inc", "name", TRACE_EVENT_SCOPE_THREAD); 1169 TRACE_EVENT_INSTANT0("inc2,inc", "name", TRACE_EVENT_SCOPE_THREAD);
1205 TRACE_EVENT_INSTANT0("inc,inc2", "name", TRACE_EVENT_SCOPE_THREAD); 1170 TRACE_EVENT_INSTANT0("inc,inc2", "name", TRACE_EVENT_SCOPE_THREAD);
1206 EndTraceAndFlush(); 1171 EndTraceAndFlush();
1207 EXPECT_TRUE(FindMatchingValue("cat", "inc2")); 1172 EXPECT_TRUE(FindMatchingValue("cat", "inc2"));
1208 EXPECT_FALSE(FindMatchingValue("cat", "inc")); 1173 EXPECT_FALSE(FindMatchingValue("cat", "inc"));
1209 EXPECT_TRUE(FindMatchingValue("cat", "inc2,inc")); 1174 EXPECT_TRUE(FindMatchingValue("cat", "inc2,inc"));
1210 EXPECT_TRUE(FindMatchingValue("cat", "inc,inc2")); 1175 EXPECT_TRUE(FindMatchingValue("cat", "inc,inc2"));
1211 1176
1212 // Exclude existent wildcard -> all categories not matching wildcard 1177 // Exclude existent wildcard -> all categories not matching wildcard
1213 Clear(); 1178 Clear();
1214 TraceLog::GetInstance()->SetEnabled( 1179 TraceLog::GetInstance()->SetEnabled(
1215 CategoryFilter("-inc_wildcard_*,-inc_wildchar_?_end"), 1180 TraceConfig("-inc_wildcard_*,-inc_wildchar_?_end", ""),
1216 TraceLog::RECORDING_MODE, 1181 TraceLog::RECORDING_MODE);
1217 TraceOptions());
1218 TRACE_EVENT_INSTANT0("inc_wildcard_abc", "not_inc", 1182 TRACE_EVENT_INSTANT0("inc_wildcard_abc", "not_inc",
1219 TRACE_EVENT_SCOPE_THREAD); 1183 TRACE_EVENT_SCOPE_THREAD);
1220 TRACE_EVENT_INSTANT0("inc_wildcard_", "not_inc", 1184 TRACE_EVENT_INSTANT0("inc_wildcard_", "not_inc",
1221 TRACE_EVENT_SCOPE_THREAD); 1185 TRACE_EVENT_SCOPE_THREAD);
1222 TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "not_inc", 1186 TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "not_inc",
1223 TRACE_EVENT_SCOPE_THREAD); 1187 TRACE_EVENT_SCOPE_THREAD);
1224 TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "included", 1188 TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "included",
1225 TRACE_EVENT_SCOPE_THREAD); 1189 TRACE_EVENT_SCOPE_THREAD);
1226 TRACE_EVENT_INSTANT0("cat1", "included", TRACE_EVENT_SCOPE_THREAD); 1190 TRACE_EVENT_INSTANT0("cat1", "included", TRACE_EVENT_SCOPE_THREAD);
1227 TRACE_EVENT_INSTANT0("cat2", "included", TRACE_EVENT_SCOPE_THREAD); 1191 TRACE_EVENT_INSTANT0("cat2", "included", TRACE_EVENT_SCOPE_THREAD);
(...skipping 498 matching lines...) Expand 10 before | Expand all | Expand 10 after
1726 TraceLog::GetInstance()->SetDisabled(); 1690 TraceLog::GetInstance()->SetDisabled();
1727 1691
1728 TRACE_EVENT_INSTANT1("category", "test", TRACE_EVENT_SCOPE_THREAD, "a", a++); 1692 TRACE_EVENT_INSTANT1("category", "test", TRACE_EVENT_SCOPE_THREAD, "a", a++);
1729 EXPECT_EQ(1, a); 1693 EXPECT_EQ(1, a);
1730 1694
1731 EndTraceAndFlush(); 1695 EndTraceAndFlush();
1732 } 1696 }
1733 1697
1734 TEST_F(TraceEventTestFixture, TraceEnableDisable) { 1698 TEST_F(TraceEventTestFixture, TraceEnableDisable) {
1735 TraceLog* trace_log = TraceLog::GetInstance(); 1699 TraceLog* trace_log = TraceLog::GetInstance();
1736 CategoryFilter cf_inc_all("*"); 1700 TraceConfig tc_inc_all("*", "");
1737 trace_log->SetEnabled(cf_inc_all, 1701 trace_log->SetEnabled(tc_inc_all, TraceLog::RECORDING_MODE);
1738 TraceLog::RECORDING_MODE,
1739 TraceOptions());
1740 EXPECT_TRUE(trace_log->IsEnabled()); 1702 EXPECT_TRUE(trace_log->IsEnabled());
1741 trace_log->SetDisabled(); 1703 trace_log->SetDisabled();
1742 EXPECT_FALSE(trace_log->IsEnabled()); 1704 EXPECT_FALSE(trace_log->IsEnabled());
1743 1705
1744 trace_log->SetEnabled(cf_inc_all, 1706 trace_log->SetEnabled(tc_inc_all, TraceLog::RECORDING_MODE);
1745 TraceLog::RECORDING_MODE,
1746 TraceOptions());
1747 EXPECT_TRUE(trace_log->IsEnabled()); 1707 EXPECT_TRUE(trace_log->IsEnabled());
1748 const std::vector<std::string> empty; 1708 const std::vector<std::string> empty;
1749 trace_log->SetEnabled(CategoryFilter(), 1709 trace_log->SetEnabled(TraceConfig(), TraceLog::RECORDING_MODE);
1750 TraceLog::RECORDING_MODE,
1751 TraceOptions());
1752 EXPECT_TRUE(trace_log->IsEnabled()); 1710 EXPECT_TRUE(trace_log->IsEnabled());
1753 trace_log->SetDisabled(); 1711 trace_log->SetDisabled();
1754 EXPECT_FALSE(trace_log->IsEnabled()); 1712 EXPECT_FALSE(trace_log->IsEnabled());
1755 trace_log->SetDisabled(); 1713 trace_log->SetDisabled();
1756 EXPECT_FALSE(trace_log->IsEnabled()); 1714 EXPECT_FALSE(trace_log->IsEnabled());
1757 } 1715 }
1758 1716
1759 TEST_F(TraceEventTestFixture, TraceCategoriesAfterNestedEnable) { 1717 TEST_F(TraceEventTestFixture, TraceCategoriesAfterNestedEnable) {
1760 TraceLog* trace_log = TraceLog::GetInstance(); 1718 TraceLog* trace_log = TraceLog::GetInstance();
1761 trace_log->SetEnabled(CategoryFilter("foo,bar"), 1719 trace_log->SetEnabled(TraceConfig("foo,bar", ""), TraceLog::RECORDING_MODE);
1762 TraceLog::RECORDING_MODE,
1763 TraceOptions());
1764 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo")); 1720 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo"));
1765 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar")); 1721 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar"));
1766 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz")); 1722 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
1767 trace_log->SetEnabled(CategoryFilter("foo2"), 1723 trace_log->SetEnabled(TraceConfig("foo2", ""), TraceLog::RECORDING_MODE);
1768 TraceLog::RECORDING_MODE,
1769 TraceOptions());
1770 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo2")); 1724 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo2"));
1771 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz")); 1725 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
1772 // The "" becomes the default catergory set when applied. 1726 // The "" becomes the default catergory set when applied.
1773 trace_log->SetEnabled(CategoryFilter(), 1727 trace_log->SetEnabled(TraceConfig(), TraceLog::RECORDING_MODE);
1774 TraceLog::RECORDING_MODE,
1775 TraceOptions());
1776 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo")); 1728 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo"));
1777 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz")); 1729 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz"));
1778 EXPECT_STREQ("-*Debug,-*Test", 1730 EXPECT_STREQ(
1779 trace_log->GetCurrentCategoryFilter().ToString().c_str()); 1731 "-*Debug,-*Test",
1732 trace_log->GetCurrentTraceConfig().ToCategoryFilterString().c_str());
1780 trace_log->SetDisabled(); 1733 trace_log->SetDisabled();
1781 trace_log->SetDisabled(); 1734 trace_log->SetDisabled();
1782 trace_log->SetDisabled(); 1735 trace_log->SetDisabled();
1783 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo")); 1736 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo"));
1784 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz")); 1737 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
1785 1738
1786 trace_log->SetEnabled(CategoryFilter("-foo,-bar"), 1739 trace_log->SetEnabled(TraceConfig("-foo,-bar", ""), TraceLog::RECORDING_MODE);
1787 TraceLog::RECORDING_MODE,
1788 TraceOptions());
1789 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo")); 1740 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo"));
1790 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz")); 1741 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz"));
1791 trace_log->SetEnabled(CategoryFilter("moo"), 1742 trace_log->SetEnabled(TraceConfig("moo", ""), TraceLog::RECORDING_MODE);
1792 TraceLog::RECORDING_MODE,
1793 TraceOptions());
1794 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz")); 1743 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz"));
1795 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("moo")); 1744 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("moo"));
1796 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo")); 1745 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo"));
1797 EXPECT_STREQ("-foo,-bar", 1746 EXPECT_STREQ(
1798 trace_log->GetCurrentCategoryFilter().ToString().c_str()); 1747 "-foo,-bar",
1748 trace_log->GetCurrentTraceConfig().ToCategoryFilterString().c_str());
1799 trace_log->SetDisabled(); 1749 trace_log->SetDisabled();
1800 trace_log->SetDisabled(); 1750 trace_log->SetDisabled();
1801 1751
1802 // Make sure disabled categories aren't cleared if we set in the second. 1752 // Make sure disabled categories aren't cleared if we set in the second.
1803 trace_log->SetEnabled(CategoryFilter("disabled-by-default-cc,foo"), 1753 trace_log->SetEnabled(TraceConfig("disabled-by-default-cc,foo", ""),
1804 TraceLog::RECORDING_MODE, 1754 TraceLog::RECORDING_MODE);
1805 TraceOptions());
1806 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("bar")); 1755 EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("bar"));
1807 trace_log->SetEnabled(CategoryFilter("disabled-by-default-gpu"), 1756 trace_log->SetEnabled(TraceConfig("disabled-by-default-gpu", ""),
1808 TraceLog::RECORDING_MODE, 1757 TraceLog::RECORDING_MODE);
1809 TraceOptions());
1810 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-cc")); 1758 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-cc"));
1811 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-gpu")); 1759 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-gpu"));
1812 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar")); 1760 EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar"));
1813 EXPECT_STREQ("disabled-by-default-cc,disabled-by-default-gpu", 1761 EXPECT_STREQ(
1814 trace_log->GetCurrentCategoryFilter().ToString().c_str()); 1762 "disabled-by-default-cc,disabled-by-default-gpu",
1763 trace_log->GetCurrentTraceConfig().ToCategoryFilterString().c_str());
1815 trace_log->SetDisabled(); 1764 trace_log->SetDisabled();
1816 trace_log->SetDisabled(); 1765 trace_log->SetDisabled();
1817 } 1766 }
1818 1767
1819 TEST_F(TraceEventTestFixture, TraceSampling) { 1768 TEST_F(TraceEventTestFixture, TraceSampling) {
1820 TraceOptions trace_options(RECORD_UNTIL_FULL); 1769 TraceLog::GetInstance()->SetEnabled(
1821 trace_options.enable_sampling = true; 1770 TraceConfig("*", "record-until-full,enable-sampling"),
1822 TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"), 1771 TraceLog::RECORDING_MODE);
1823 TraceLog::RECORDING_MODE,
1824 trace_options);
1825 1772
1826 TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "cc", "Stuff"); 1773 TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "cc", "Stuff");
1827 TraceLog::GetInstance()->WaitSamplingEventForTesting(); 1774 TraceLog::GetInstance()->WaitSamplingEventForTesting();
1828 TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "cc", "Things"); 1775 TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "cc", "Things");
1829 TraceLog::GetInstance()->WaitSamplingEventForTesting(); 1776 TraceLog::GetInstance()->WaitSamplingEventForTesting();
1830 1777
1831 EndTraceAndFlush(); 1778 EndTraceAndFlush();
1832 1779
1833 // Make sure we hit at least once. 1780 // Make sure we hit at least once.
1834 EXPECT_TRUE(FindNamePhase("Stuff", "P")); 1781 EXPECT_TRUE(FindNamePhase("Stuff", "P"));
1835 EXPECT_TRUE(FindNamePhase("Things", "P")); 1782 EXPECT_TRUE(FindNamePhase("Things", "P"));
1836 } 1783 }
1837 1784
1838 TEST_F(TraceEventTestFixture, TraceSamplingScope) { 1785 TEST_F(TraceEventTestFixture, TraceSamplingScope) {
1839 TraceOptions trace_options(RECORD_UNTIL_FULL); 1786 TraceLog::GetInstance()->SetEnabled(
1840 trace_options.enable_sampling = true; 1787 TraceConfig("*", "record-until-full,enable-sampling"),
1841 TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"), 1788 TraceLog::RECORDING_MODE);
1842 TraceLog::RECORDING_MODE,
1843 trace_options);
1844 1789
1845 TRACE_EVENT_SCOPED_SAMPLING_STATE("AAA", "name"); 1790 TRACE_EVENT_SCOPED_SAMPLING_STATE("AAA", "name");
1846 TraceLog::GetInstance()->WaitSamplingEventForTesting(); 1791 TraceLog::GetInstance()->WaitSamplingEventForTesting();
1847 { 1792 {
1848 EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "AAA"); 1793 EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "AAA");
1849 TRACE_EVENT_SCOPED_SAMPLING_STATE("BBB", "name"); 1794 TRACE_EVENT_SCOPED_SAMPLING_STATE("BBB", "name");
1850 TraceLog::GetInstance()->WaitSamplingEventForTesting(); 1795 TraceLog::GetInstance()->WaitSamplingEventForTesting();
1851 EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "BBB"); 1796 EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "BBB");
1852 } 1797 }
1853 TraceLog::GetInstance()->WaitSamplingEventForTesting(); 1798 TraceLog::GetInstance()->WaitSamplingEventForTesting();
(...skipping 10 matching lines...) Expand all
1864 TraceLog::GetInstance()->WaitSamplingEventForTesting(); 1809 TraceLog::GetInstance()->WaitSamplingEventForTesting();
1865 EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "DDD"); 1810 EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "DDD");
1866 } 1811 }
1867 TraceLog::GetInstance()->WaitSamplingEventForTesting(); 1812 TraceLog::GetInstance()->WaitSamplingEventForTesting();
1868 EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "DDD"); 1813 EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "DDD");
1869 1814
1870 EndTraceAndFlush(); 1815 EndTraceAndFlush();
1871 } 1816 }
1872 1817
1873 TEST_F(TraceEventTestFixture, TraceContinuousSampling) { 1818 TEST_F(TraceEventTestFixture, TraceContinuousSampling) {
1874 TraceOptions trace_options(RECORD_UNTIL_FULL); 1819 TraceLog::GetInstance()->SetEnabled(
1875 trace_options.enable_sampling = true; 1820 TraceConfig("*", "record-until-full,enable-sampling"),
1876 1821 TraceLog::MONITORING_MODE);
1877 TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
1878 TraceLog::MONITORING_MODE,
1879 trace_options);
1880 1822
1881 TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "category", "AAA"); 1823 TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "category", "AAA");
1882 TraceLog::GetInstance()->WaitSamplingEventForTesting(); 1824 TraceLog::GetInstance()->WaitSamplingEventForTesting();
1883 TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "category", "BBB"); 1825 TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "category", "BBB");
1884 TraceLog::GetInstance()->WaitSamplingEventForTesting(); 1826 TraceLog::GetInstance()->WaitSamplingEventForTesting();
1885 1827
1886 FlushMonitoring(); 1828 FlushMonitoring();
1887 1829
1888 // Make sure we can get the profiled data. 1830 // Make sure we can get the profiled data.
1889 EXPECT_TRUE(FindNamePhase("AAA", "P")); 1831 EXPECT_TRUE(FindNamePhase("AAA", "P"));
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
1926 void AppendAsTraceFormat(std::string* out) const override { 1868 void AppendAsTraceFormat(std::string* out) const override {
1927 out->append("{\"foo\":1}"); 1869 out->append("{\"foo\":1}");
1928 } 1870 }
1929 1871
1930 private: 1872 private:
1931 ~MyData() override {} 1873 ~MyData() override {}
1932 DISALLOW_COPY_AND_ASSIGN(MyData); 1874 DISALLOW_COPY_AND_ASSIGN(MyData);
1933 }; 1875 };
1934 1876
1935 TEST_F(TraceEventTestFixture, ConvertableTypes) { 1877 TEST_F(TraceEventTestFixture, ConvertableTypes) {
1936 TraceLog::GetInstance()->SetEnabled( 1878 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
1937 CategoryFilter("*"), 1879 TraceLog::RECORDING_MODE);
1938 TraceLog::RECORDING_MODE,
1939 TraceOptions());
1940 1880
1941 scoped_refptr<ConvertableToTraceFormat> data(new MyData()); 1881 scoped_refptr<ConvertableToTraceFormat> data(new MyData());
1942 scoped_refptr<ConvertableToTraceFormat> data1(new MyData()); 1882 scoped_refptr<ConvertableToTraceFormat> data1(new MyData());
1943 scoped_refptr<ConvertableToTraceFormat> data2(new MyData()); 1883 scoped_refptr<ConvertableToTraceFormat> data2(new MyData());
1944 TRACE_EVENT1("foo", "bar", "data", data); 1884 TRACE_EVENT1("foo", "bar", "data", data);
1945 TRACE_EVENT2("foo", "baz", 1885 TRACE_EVENT2("foo", "baz",
1946 "data1", data1, 1886 "data1", data1,
1947 "data2", data2); 1887 "data2", data2);
1948 1888
1949 1889
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after
2033 value = NULL; 1973 value = NULL;
2034 convertable_dict = NULL; 1974 convertable_dict = NULL;
2035 foo_val = 0; 1975 foo_val = 0;
2036 EXPECT_TRUE(args_dict->Get("convert", &value)); 1976 EXPECT_TRUE(args_dict->Get("convert", &value));
2037 ASSERT_TRUE(value->GetAsDictionary(&convertable_dict)); 1977 ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
2038 EXPECT_TRUE(convertable_dict->GetInteger("foo", &foo_val)); 1978 EXPECT_TRUE(convertable_dict->GetInteger("foo", &foo_val));
2039 EXPECT_EQ(1, foo_val); 1979 EXPECT_EQ(1, foo_val);
2040 } 1980 }
2041 1981
2042 TEST_F(TraceEventTestFixture, PrimitiveArgs) { 1982 TEST_F(TraceEventTestFixture, PrimitiveArgs) {
2043 TraceLog::GetInstance()->SetEnabled( 1983 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
2044 CategoryFilter("*"), 1984 TraceLog::RECORDING_MODE);
2045 TraceLog::RECORDING_MODE,
2046 TraceOptions());
2047 1985
2048 TRACE_EVENT1("foo", "event1", "int_one", 1); 1986 TRACE_EVENT1("foo", "event1", "int_one", 1);
2049 TRACE_EVENT1("foo", "event2", "int_neg_ten", -10); 1987 TRACE_EVENT1("foo", "event2", "int_neg_ten", -10);
2050 TRACE_EVENT1("foo", "event3", "float_one", 1.0f); 1988 TRACE_EVENT1("foo", "event3", "float_one", 1.0f);
2051 TRACE_EVENT1("foo", "event4", "float_half", .5f); 1989 TRACE_EVENT1("foo", "event4", "float_half", .5f);
2052 TRACE_EVENT1("foo", "event5", "float_neghalf", -.5f); 1990 TRACE_EVENT1("foo", "event5", "float_neghalf", -.5f);
2053 TRACE_EVENT1("foo", "event6", "float_infinity", 1991 TRACE_EVENT1("foo", "event6", "float_infinity",
2054 std::numeric_limits<float>::infinity()); 1992 std::numeric_limits<float>::infinity());
2055 TRACE_EVENT1("foo", "event6b", "float_neg_infinity", 1993 TRACE_EVENT1("foo", "event6b", "float_neg_infinity",
2056 -std::numeric_limits<float>::infinity()); 1994 -std::numeric_limits<float>::infinity());
(...skipping 159 matching lines...) Expand 10 before | Expand all | Expand 10 after
2216 2154
2217 return false; 2155 return false;
2218 } 2156 }
2219 2157
2220 } // namespace 2158 } // namespace
2221 2159
2222 TEST_F(TraceEventTestFixture, ArgsWhitelisting) { 2160 TEST_F(TraceEventTestFixture, ArgsWhitelisting) {
2223 TraceLog::GetInstance()->SetArgumentFilterPredicate( 2161 TraceLog::GetInstance()->SetArgumentFilterPredicate(
2224 base::Bind(&IsTraceEventArgsWhitelisted)); 2162 base::Bind(&IsTraceEventArgsWhitelisted));
2225 2163
2226 TraceOptions trace_options; 2164 TraceLog::GetInstance()->SetEnabled(
2227 trace_options.enable_argument_filter = true; 2165 TraceConfig("*", "enable-argument-filter"),
2228 TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"), 2166 TraceLog::RECORDING_MODE);
2229 TraceLog::RECORDING_MODE, trace_options);
2230 2167
2231 TRACE_EVENT1("toplevel", "event1", "int_one", 1); 2168 TRACE_EVENT1("toplevel", "event1", "int_one", 1);
2232 TRACE_EVENT1("whitewashed", "event2", "int_two", 1); 2169 TRACE_EVENT1("whitewashed", "event2", "int_two", 1);
2233 EndTraceAndFlush(); 2170 EndTraceAndFlush();
2234 2171
2235 const DictionaryValue* args_dict = NULL; 2172 const DictionaryValue* args_dict = NULL;
2236 DictionaryValue* dict = NULL; 2173 DictionaryValue* dict = NULL;
2237 int int_value; 2174 int int_value;
2238 2175
2239 dict = FindNamePhase("event1", "X"); 2176 dict = FindNamePhase("event1", "X");
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after
2315 s_instance->collected_events_names_.push_back(name); 2252 s_instance->collected_events_names_.push_back(name);
2316 s_instance->collected_events_timestamps_.push_back(timestamp); 2253 s_instance->collected_events_timestamps_.push_back(timestamp);
2317 } 2254 }
2318 }; 2255 };
2319 2256
2320 TraceEventCallbackTest* TraceEventCallbackTest::s_instance; 2257 TraceEventCallbackTest* TraceEventCallbackTest::s_instance;
2321 2258
2322 TEST_F(TraceEventCallbackTest, TraceEventCallback) { 2259 TEST_F(TraceEventCallbackTest, TraceEventCallback) {
2323 TRACE_EVENT_INSTANT0("all", "before enable", TRACE_EVENT_SCOPE_THREAD); 2260 TRACE_EVENT_INSTANT0("all", "before enable", TRACE_EVENT_SCOPE_THREAD);
2324 TraceLog::GetInstance()->SetEventCallbackEnabled( 2261 TraceLog::GetInstance()->SetEventCallbackEnabled(
2325 CategoryFilter("*"), Callback); 2262 TraceConfig("*", ""), Callback);
2326 TRACE_EVENT_INSTANT0("all", "event1", TRACE_EVENT_SCOPE_GLOBAL); 2263 TRACE_EVENT_INSTANT0("all", "event1", TRACE_EVENT_SCOPE_GLOBAL);
2327 TRACE_EVENT_INSTANT0("all", "event2", TRACE_EVENT_SCOPE_GLOBAL); 2264 TRACE_EVENT_INSTANT0("all", "event2", TRACE_EVENT_SCOPE_GLOBAL);
2328 { 2265 {
2329 TRACE_EVENT0("all", "duration"); 2266 TRACE_EVENT0("all", "duration");
2330 TRACE_EVENT_INSTANT0("all", "event3", TRACE_EVENT_SCOPE_GLOBAL); 2267 TRACE_EVENT_INSTANT0("all", "event3", TRACE_EVENT_SCOPE_GLOBAL);
2331 } 2268 }
2332 TraceLog::GetInstance()->SetEventCallbackDisabled(); 2269 TraceLog::GetInstance()->SetEventCallbackDisabled();
2333 TRACE_EVENT_INSTANT0("all", "after callback removed", 2270 TRACE_EVENT_INSTANT0("all", "after callback removed",
2334 TRACE_EVENT_SCOPE_GLOBAL); 2271 TRACE_EVENT_SCOPE_GLOBAL);
2335 ASSERT_EQ(5u, collected_events_names_.size()); 2272 ASSERT_EQ(5u, collected_events_names_.size());
2336 EXPECT_EQ("event1", collected_events_names_[0]); 2273 EXPECT_EQ("event1", collected_events_names_[0]);
2337 EXPECT_EQ(TRACE_EVENT_PHASE_INSTANT, collected_events_phases_[0]); 2274 EXPECT_EQ(TRACE_EVENT_PHASE_INSTANT, collected_events_phases_[0]);
2338 EXPECT_EQ("event2", collected_events_names_[1]); 2275 EXPECT_EQ("event2", collected_events_names_[1]);
2339 EXPECT_EQ(TRACE_EVENT_PHASE_INSTANT, collected_events_phases_[1]); 2276 EXPECT_EQ(TRACE_EVENT_PHASE_INSTANT, collected_events_phases_[1]);
2340 EXPECT_EQ("duration", collected_events_names_[2]); 2277 EXPECT_EQ("duration", collected_events_names_[2]);
2341 EXPECT_EQ(TRACE_EVENT_PHASE_BEGIN, collected_events_phases_[2]); 2278 EXPECT_EQ(TRACE_EVENT_PHASE_BEGIN, collected_events_phases_[2]);
2342 EXPECT_EQ("event3", collected_events_names_[3]); 2279 EXPECT_EQ("event3", collected_events_names_[3]);
2343 EXPECT_EQ(TRACE_EVENT_PHASE_INSTANT, collected_events_phases_[3]); 2280 EXPECT_EQ(TRACE_EVENT_PHASE_INSTANT, collected_events_phases_[3]);
2344 EXPECT_EQ("duration", collected_events_names_[4]); 2281 EXPECT_EQ("duration", collected_events_names_[4]);
2345 EXPECT_EQ(TRACE_EVENT_PHASE_END, collected_events_phases_[4]); 2282 EXPECT_EQ(TRACE_EVENT_PHASE_END, collected_events_phases_[4]);
2346 for (size_t i = 1; i < collected_events_timestamps_.size(); i++) { 2283 for (size_t i = 1; i < collected_events_timestamps_.size(); i++) {
2347 EXPECT_LE(collected_events_timestamps_[i - 1], 2284 EXPECT_LE(collected_events_timestamps_[i - 1],
2348 collected_events_timestamps_[i]); 2285 collected_events_timestamps_[i]);
2349 } 2286 }
2350 } 2287 }
2351 2288
2352 TEST_F(TraceEventCallbackTest, TraceEventCallbackWhileFull) { 2289 TEST_F(TraceEventCallbackTest, TraceEventCallbackWhileFull) {
2353 TraceLog::GetInstance()->SetEnabled( 2290 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
2354 CategoryFilter("*"), 2291 TraceLog::RECORDING_MODE);
2355 TraceLog::RECORDING_MODE,
2356 TraceOptions());
2357 do { 2292 do {
2358 TRACE_EVENT_INSTANT0("all", "badger badger", TRACE_EVENT_SCOPE_GLOBAL); 2293 TRACE_EVENT_INSTANT0("all", "badger badger", TRACE_EVENT_SCOPE_GLOBAL);
2359 } while (!TraceLog::GetInstance()->BufferIsFull()); 2294 } while (!TraceLog::GetInstance()->BufferIsFull());
2360 TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("*"), 2295 TraceLog::GetInstance()->SetEventCallbackEnabled(TraceConfig("*", ""),
2361 Callback); 2296 Callback);
2362 TRACE_EVENT_INSTANT0("all", "a snake", TRACE_EVENT_SCOPE_GLOBAL); 2297 TRACE_EVENT_INSTANT0("all", "a snake", TRACE_EVENT_SCOPE_GLOBAL);
2363 TraceLog::GetInstance()->SetEventCallbackDisabled(); 2298 TraceLog::GetInstance()->SetEventCallbackDisabled();
2364 ASSERT_EQ(1u, collected_events_names_.size()); 2299 ASSERT_EQ(1u, collected_events_names_.size());
2365 EXPECT_EQ("a snake", collected_events_names_[0]); 2300 EXPECT_EQ("a snake", collected_events_names_[0]);
2366 } 2301 }
2367 2302
2368 // 1: Enable callback, enable recording, disable callback, disable recording. 2303 // 1: Enable callback, enable recording, disable callback, disable recording.
2369 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording1) { 2304 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording1) {
2370 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2305 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2371 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2306 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2372 TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("callback"), 2307 TraceLog::GetInstance()->SetEventCallbackEnabled(TraceConfig("callback", ""),
2373 Callback); 2308 Callback);
2374 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2309 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2375 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2310 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2376 TraceLog::GetInstance()->SetEnabled( 2311 TraceLog::GetInstance()->SetEnabled(TraceConfig("recording", ""),
2377 CategoryFilter("recording"), 2312 TraceLog::RECORDING_MODE);
2378 TraceLog::RECORDING_MODE,
2379 TraceOptions());
2380 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2313 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2381 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2314 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2382 TraceLog::GetInstance()->SetEventCallbackDisabled(); 2315 TraceLog::GetInstance()->SetEventCallbackDisabled();
2383 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2316 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2384 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2317 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2385 EndTraceAndFlush(); 2318 EndTraceAndFlush();
2386 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2319 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2387 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2320 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2388 2321
2389 DropTracedMetadataRecords(); 2322 DropTracedMetadataRecords();
2390 VerifyCallbackAndRecordedEvents(2, 2); 2323 VerifyCallbackAndRecordedEvents(2, 2);
2391 } 2324 }
2392 2325
2393 // 2: Enable callback, enable recording, disable recording, disable callback. 2326 // 2: Enable callback, enable recording, disable recording, disable callback.
2394 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording2) { 2327 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording2) {
2395 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2328 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2396 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2329 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2397 TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("callback"), 2330 TraceLog::GetInstance()->SetEventCallbackEnabled(TraceConfig("callback", ""),
2398 Callback); 2331 Callback);
2399 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2332 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2400 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2333 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2401 TraceLog::GetInstance()->SetEnabled( 2334 TraceLog::GetInstance()->SetEnabled(TraceConfig("recording", ""),
2402 CategoryFilter("recording"), 2335 TraceLog::RECORDING_MODE);
2403 TraceLog::RECORDING_MODE,
2404 TraceOptions());
2405 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2336 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2406 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2337 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2407 EndTraceAndFlush(); 2338 EndTraceAndFlush();
2408 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2339 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2409 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2340 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2410 TraceLog::GetInstance()->SetEventCallbackDisabled(); 2341 TraceLog::GetInstance()->SetEventCallbackDisabled();
2411 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2342 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2412 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2343 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2413 2344
2414 DropTracedMetadataRecords(); 2345 DropTracedMetadataRecords();
2415 VerifyCallbackAndRecordedEvents(3, 1); 2346 VerifyCallbackAndRecordedEvents(3, 1);
2416 } 2347 }
2417 2348
2418 // 3: Enable recording, enable callback, disable callback, disable recording. 2349 // 3: Enable recording, enable callback, disable callback, disable recording.
2419 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording3) { 2350 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording3) {
2420 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2351 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2421 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2352 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2422 TraceLog::GetInstance()->SetEnabled( 2353 TraceLog::GetInstance()->SetEnabled(TraceConfig("recording", ""),
2423 CategoryFilter("recording"), 2354 TraceLog::RECORDING_MODE);
2424 TraceLog::RECORDING_MODE,
2425 TraceOptions());
2426 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2355 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2427 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2356 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2428 TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("callback"), 2357 TraceLog::GetInstance()->SetEventCallbackEnabled(TraceConfig("callback", ""),
2429 Callback); 2358 Callback);
2430 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2359 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2431 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2360 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2432 TraceLog::GetInstance()->SetEventCallbackDisabled(); 2361 TraceLog::GetInstance()->SetEventCallbackDisabled();
2433 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2362 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2434 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2363 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2435 EndTraceAndFlush(); 2364 EndTraceAndFlush();
2436 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2365 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2437 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2366 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2438 2367
2439 DropTracedMetadataRecords(); 2368 DropTracedMetadataRecords();
2440 VerifyCallbackAndRecordedEvents(1, 3); 2369 VerifyCallbackAndRecordedEvents(1, 3);
2441 } 2370 }
2442 2371
2443 // 4: Enable recording, enable callback, disable recording, disable callback. 2372 // 4: Enable recording, enable callback, disable recording, disable callback.
2444 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording4) { 2373 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording4) {
2445 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2374 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2446 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2375 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2447 TraceLog::GetInstance()->SetEnabled( 2376 TraceLog::GetInstance()->SetEnabled(TraceConfig("recording", ""),
2448 CategoryFilter("recording"), 2377 TraceLog::RECORDING_MODE);
2449 TraceLog::RECORDING_MODE,
2450 TraceOptions());
2451 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2378 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2452 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2379 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2453 TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("callback"), 2380 TraceLog::GetInstance()->SetEventCallbackEnabled(TraceConfig("callback", ""),
2454 Callback); 2381 Callback);
2455 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2382 TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2456 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2383 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2457 EndTraceAndFlush(); 2384 EndTraceAndFlush();
2458 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2385 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2459 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL); 2386 TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
2460 TraceLog::GetInstance()->SetEventCallbackDisabled(); 2387 TraceLog::GetInstance()->SetEventCallbackDisabled();
2461 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL); 2388 TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
2462 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); 2389 TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
2463 2390
2464 DropTracedMetadataRecords(); 2391 DropTracedMetadataRecords();
2465 VerifyCallbackAndRecordedEvents(2, 2); 2392 VerifyCallbackAndRecordedEvents(2, 2);
2466 } 2393 }
2467 2394
2468 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecordingDuration) { 2395 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecordingDuration) {
2469 TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("*"), 2396 TraceLog::GetInstance()->SetEventCallbackEnabled(TraceConfig("*", ""),
2470 Callback); 2397 Callback);
2471 { 2398 {
2472 TRACE_EVENT0("callback", "duration1"); 2399 TRACE_EVENT0("callback", "duration1");
2473 TraceLog::GetInstance()->SetEnabled( 2400 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ""),
2474 CategoryFilter("*"), 2401 TraceLog::RECORDING_MODE);
2475 TraceLog::RECORDING_MODE,
2476 TraceOptions());
2477 TRACE_EVENT0("callback", "duration2"); 2402 TRACE_EVENT0("callback", "duration2");
2478 EndTraceAndFlush(); 2403 EndTraceAndFlush();
2479 TRACE_EVENT0("callback", "duration3"); 2404 TRACE_EVENT0("callback", "duration3");
2480 } 2405 }
2481 TraceLog::GetInstance()->SetEventCallbackDisabled(); 2406 TraceLog::GetInstance()->SetEventCallbackDisabled();
2482 2407
2483 ASSERT_EQ(6u, collected_events_names_.size()); 2408 ASSERT_EQ(6u, collected_events_names_.size());
2484 VerifyCollectedEvent(0, TRACE_EVENT_PHASE_BEGIN, "callback", "duration1"); 2409 VerifyCollectedEvent(0, TRACE_EVENT_PHASE_BEGIN, "callback", "duration1");
2485 VerifyCollectedEvent(1, TRACE_EVENT_PHASE_BEGIN, "callback", "duration2"); 2410 VerifyCollectedEvent(1, TRACE_EVENT_PHASE_BEGIN, "callback", "duration2");
2486 VerifyCollectedEvent(2, TRACE_EVENT_PHASE_BEGIN, "callback", "duration3"); 2411 VerifyCollectedEvent(2, TRACE_EVENT_PHASE_BEGIN, "callback", "duration3");
2487 VerifyCollectedEvent(3, TRACE_EVENT_PHASE_END, "callback", "duration3"); 2412 VerifyCollectedEvent(3, TRACE_EVENT_PHASE_END, "callback", "duration3");
2488 VerifyCollectedEvent(4, TRACE_EVENT_PHASE_END, "callback", "duration2"); 2413 VerifyCollectedEvent(4, TRACE_EVENT_PHASE_END, "callback", "duration2");
2489 VerifyCollectedEvent(5, TRACE_EVENT_PHASE_END, "callback", "duration1"); 2414 VerifyCollectedEvent(5, TRACE_EVENT_PHASE_END, "callback", "duration1");
2490 } 2415 }
2491 2416
2492 TEST_F(TraceEventTestFixture, TraceBufferVectorReportFull) { 2417 TEST_F(TraceEventTestFixture, TraceBufferVectorReportFull) {
2493 TraceLog* trace_log = TraceLog::GetInstance(); 2418 TraceLog* trace_log = TraceLog::GetInstance();
2494 trace_log->SetEnabled(CategoryFilter("*"), 2419 trace_log->SetEnabled(TraceConfig("*", ""), TraceLog::RECORDING_MODE);
2495 TraceLog::RECORDING_MODE,
2496 TraceOptions());
2497 trace_log->logged_events_.reset( 2420 trace_log->logged_events_.reset(
2498 trace_log->CreateTraceBufferVectorOfSize(100)); 2421 trace_log->CreateTraceBufferVectorOfSize(100));
2499 do { 2422 do {
2500 TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0( 2423 TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(
2501 "all", "with_timestamp", 0, 0, TraceTicks::Now().ToInternalValue()); 2424 "all", "with_timestamp", 0, 0, TraceTicks::Now().ToInternalValue());
2502 TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0( 2425 TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0(
2503 "all", "with_timestamp", 0, 0, TraceTicks::Now().ToInternalValue()); 2426 "all", "with_timestamp", 0, 0, TraceTicks::Now().ToInternalValue());
2504 } while (!trace_log->BufferIsFull()); 2427 } while (!trace_log->BufferIsFull());
2505 2428
2506 EndTraceAndFlush(); 2429 EndTraceAndFlush();
(...skipping 22 matching lines...) Expand all
2529 double last_trace_event_timestamp = 0; 2452 double last_trace_event_timestamp = 0;
2530 EXPECT_TRUE(trace_parsed_.GetDictionary(trace_parsed_.GetSize() - 1, 2453 EXPECT_TRUE(trace_parsed_.GetDictionary(trace_parsed_.GetSize() - 1,
2531 &last_trace_event)); 2454 &last_trace_event));
2532 EXPECT_TRUE(last_trace_event->GetDouble("ts", &last_trace_event_timestamp)); 2455 EXPECT_TRUE(last_trace_event->GetDouble("ts", &last_trace_event_timestamp));
2533 EXPECT_LE(last_trace_event_timestamp, buffer_limit_reached_timestamp); 2456 EXPECT_LE(last_trace_event_timestamp, buffer_limit_reached_timestamp);
2534 EXPECT_LE(buffer_limit_reached_timestamp, 2457 EXPECT_LE(buffer_limit_reached_timestamp,
2535 trace_log->OffsetNow().ToInternalValue()); 2458 trace_log->OffsetNow().ToInternalValue());
2536 } 2459 }
2537 2460
2538 TEST_F(TraceEventTestFixture, TraceBufferRingBufferGetReturnChunk) { 2461 TEST_F(TraceEventTestFixture, TraceBufferRingBufferGetReturnChunk) {
2539 TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"), 2462 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", RECORD_CONTINUOUSLY),
2540 TraceLog::RECORDING_MODE, 2463 TraceLog::RECORDING_MODE);
2541 TraceOptions(RECORD_CONTINUOUSLY));
2542 TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer(); 2464 TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
2543 size_t capacity = buffer->Capacity(); 2465 size_t capacity = buffer->Capacity();
2544 size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize; 2466 size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
2545 uint32 last_seq = 0; 2467 uint32 last_seq = 0;
2546 size_t chunk_index; 2468 size_t chunk_index;
2547 EXPECT_EQ(0u, buffer->Size()); 2469 EXPECT_EQ(0u, buffer->Size());
2548 2470
2549 scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[num_chunks]); 2471 scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[num_chunks]);
2550 for (size_t i = 0; i < num_chunks; ++i) { 2472 for (size_t i = 0; i < num_chunks; ++i) {
2551 chunks[i] = buffer->GetChunk(&chunk_index).release(); 2473 chunks[i] = buffer->GetChunk(&chunk_index).release();
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
2589 last_seq = chunks[i]->seq(); 2511 last_seq = chunks[i]->seq();
2590 } 2512 }
2591 2513
2592 for (size_t i = 0; i < num_chunks; ++i) 2514 for (size_t i = 0; i < num_chunks; ++i)
2593 buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i])); 2515 buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i]));
2594 2516
2595 TraceLog::GetInstance()->SetDisabled(); 2517 TraceLog::GetInstance()->SetDisabled();
2596 } 2518 }
2597 2519
2598 TEST_F(TraceEventTestFixture, TraceBufferRingBufferHalfIteration) { 2520 TEST_F(TraceEventTestFixture, TraceBufferRingBufferHalfIteration) {
2599 TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"), 2521 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", RECORD_CONTINUOUSLY),
2600 TraceLog::RECORDING_MODE, 2522 TraceLog::RECORDING_MODE);
2601 TraceOptions(RECORD_CONTINUOUSLY));
2602 TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer(); 2523 TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
2603 size_t capacity = buffer->Capacity(); 2524 size_t capacity = buffer->Capacity();
2604 size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize; 2525 size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
2605 size_t chunk_index; 2526 size_t chunk_index;
2606 EXPECT_EQ(0u, buffer->Size()); 2527 EXPECT_EQ(0u, buffer->Size());
2607 EXPECT_FALSE(buffer->NextChunk()); 2528 EXPECT_FALSE(buffer->NextChunk());
2608 2529
2609 size_t half_chunks = num_chunks / 2; 2530 size_t half_chunks = num_chunks / 2;
2610 scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[half_chunks]); 2531 scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[half_chunks]);
2611 2532
2612 for (size_t i = 0; i < half_chunks; ++i) { 2533 for (size_t i = 0; i < half_chunks; ++i) {
2613 chunks[i] = buffer->GetChunk(&chunk_index).release(); 2534 chunks[i] = buffer->GetChunk(&chunk_index).release();
2614 EXPECT_TRUE(chunks[i]); 2535 EXPECT_TRUE(chunks[i]);
2615 EXPECT_EQ(i, chunk_index); 2536 EXPECT_EQ(i, chunk_index);
2616 } 2537 }
2617 for (size_t i = 0; i < half_chunks; ++i) 2538 for (size_t i = 0; i < half_chunks; ++i)
2618 buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i])); 2539 buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i]));
2619 2540
2620 for (size_t i = 0; i < half_chunks; ++i) 2541 for (size_t i = 0; i < half_chunks; ++i)
2621 EXPECT_EQ(chunks[i], buffer->NextChunk()); 2542 EXPECT_EQ(chunks[i], buffer->NextChunk());
2622 EXPECT_FALSE(buffer->NextChunk()); 2543 EXPECT_FALSE(buffer->NextChunk());
2623 TraceLog::GetInstance()->SetDisabled(); 2544 TraceLog::GetInstance()->SetDisabled();
2624 } 2545 }
2625 2546
2626 TEST_F(TraceEventTestFixture, TraceBufferRingBufferFullIteration) { 2547 TEST_F(TraceEventTestFixture, TraceBufferRingBufferFullIteration) {
2627 TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"), 2548 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", RECORD_CONTINUOUSLY),
2628 TraceLog::RECORDING_MODE, 2549 TraceLog::RECORDING_MODE);
2629 TraceOptions(RECORD_CONTINUOUSLY));
2630 TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer(); 2550 TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
2631 size_t capacity = buffer->Capacity(); 2551 size_t capacity = buffer->Capacity();
2632 size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize; 2552 size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
2633 size_t chunk_index; 2553 size_t chunk_index;
2634 EXPECT_EQ(0u, buffer->Size()); 2554 EXPECT_EQ(0u, buffer->Size());
2635 EXPECT_FALSE(buffer->NextChunk()); 2555 EXPECT_FALSE(buffer->NextChunk());
2636 2556
2637 scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[num_chunks]); 2557 scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[num_chunks]);
2638 2558
2639 for (size_t i = 0; i < num_chunks; ++i) { 2559 for (size_t i = 0; i < num_chunks; ++i) {
2640 chunks[i] = buffer->GetChunk(&chunk_index).release(); 2560 chunks[i] = buffer->GetChunk(&chunk_index).release();
2641 EXPECT_TRUE(chunks[i]); 2561 EXPECT_TRUE(chunks[i]);
2642 EXPECT_EQ(i, chunk_index); 2562 EXPECT_EQ(i, chunk_index);
2643 } 2563 }
2644 for (size_t i = 0; i < num_chunks; ++i) 2564 for (size_t i = 0; i < num_chunks; ++i)
2645 buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i])); 2565 buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i]));
2646 2566
2647 for (size_t i = 0; i < num_chunks; ++i) 2567 for (size_t i = 0; i < num_chunks; ++i)
2648 EXPECT_TRUE(chunks[i] == buffer->NextChunk()); 2568 EXPECT_TRUE(chunks[i] == buffer->NextChunk());
2649 EXPECT_FALSE(buffer->NextChunk()); 2569 EXPECT_FALSE(buffer->NextChunk());
2650 TraceLog::GetInstance()->SetDisabled(); 2570 TraceLog::GetInstance()->SetDisabled();
2651 } 2571 }
2652 2572
2653 TEST_F(TraceEventTestFixture, TraceRecordAsMuchAsPossibleMode) { 2573 TEST_F(TraceEventTestFixture, TraceRecordAsMuchAsPossibleMode) {
2654 TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"), 2574 TraceLog::GetInstance()->SetEnabled(
2655 TraceLog::RECORDING_MODE, 2575 TraceConfig("*", RECORD_AS_MUCH_AS_POSSIBLE),
2656 TraceOptions(RECORD_AS_MUCH_AS_POSSIBLE)); 2576 TraceLog::RECORDING_MODE);
2657 TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer(); 2577 TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
2658 EXPECT_EQ(512000000UL, buffer->Capacity()); 2578 EXPECT_EQ(512000000UL, buffer->Capacity());
2659 TraceLog::GetInstance()->SetDisabled(); 2579 TraceLog::GetInstance()->SetDisabled();
2660 } 2580 }
2661 2581
2662 void BlockUntilStopped(WaitableEvent* task_start_event, 2582 void BlockUntilStopped(WaitableEvent* task_start_event,
2663 WaitableEvent* task_stop_event) { 2583 WaitableEvent* task_stop_event) {
2664 task_start_event->Signal(); 2584 task_start_event->Signal();
2665 task_stop_event->Wait(); 2585 task_stop_event->Wait();
2666 } 2586 }
(...skipping 18 matching lines...) Expand all
2685 FROM_HERE, Bind(&BlockUntilStopped, &task_start_event, &task_stop_event)); 2605 FROM_HERE, Bind(&BlockUntilStopped, &task_start_event, &task_stop_event));
2686 task_start_event.Wait(); 2606 task_start_event.Wait();
2687 2607
2688 EndTraceAndFlush(); 2608 EndTraceAndFlush();
2689 ValidateAllTraceMacrosCreatedData(trace_parsed_); 2609 ValidateAllTraceMacrosCreatedData(trace_parsed_);
2690 2610
2691 task_stop_event.Signal(); 2611 task_stop_event.Signal();
2692 thread.Stop(); 2612 thread.Stop();
2693 } 2613 }
2694 2614
2695 TEST_F(TraceEventTestFixture, ConvertTraceOptionsToInternalOptions) { 2615 TEST_F(TraceEventTestFixture, ConvertTraceConfigToInternalOptions) {
2696 TraceLog* trace_log = TraceLog::GetInstance(); 2616 TraceLog* trace_log = TraceLog::GetInstance();
2697 TraceOptions options(RECORD_UNTIL_FULL);
2698 EXPECT_EQ(TraceLog::kInternalRecordUntilFull, 2617 EXPECT_EQ(TraceLog::kInternalRecordUntilFull,
2699 trace_log->GetInternalOptionsFromTraceOptions(options)); 2618 trace_log->GetInternalOptionsFromTraceConfig(
2619 TraceConfig("*", RECORD_UNTIL_FULL)));
2700 2620
2701 options.record_mode = RECORD_CONTINUOUSLY;
2702 EXPECT_EQ(TraceLog::kInternalRecordContinuously, 2621 EXPECT_EQ(TraceLog::kInternalRecordContinuously,
2703 trace_log->GetInternalOptionsFromTraceOptions(options)); 2622 trace_log->GetInternalOptionsFromTraceConfig(
2623 TraceConfig("*", RECORD_CONTINUOUSLY)));
2704 2624
2705 options.record_mode = ECHO_TO_CONSOLE;
2706 EXPECT_EQ(TraceLog::kInternalEchoToConsole, 2625 EXPECT_EQ(TraceLog::kInternalEchoToConsole,
2707 trace_log->GetInternalOptionsFromTraceOptions(options)); 2626 trace_log->GetInternalOptionsFromTraceConfig(
2627 TraceConfig("*", ECHO_TO_CONSOLE)));
2708 2628
2709 options.enable_sampling = true;
2710
2711 options.record_mode = RECORD_UNTIL_FULL;
2712 EXPECT_EQ( 2629 EXPECT_EQ(
2713 TraceLog::kInternalRecordUntilFull | TraceLog::kInternalEnableSampling, 2630 TraceLog::kInternalRecordUntilFull | TraceLog::kInternalEnableSampling,
2714 trace_log->GetInternalOptionsFromTraceOptions(options)); 2631 trace_log->GetInternalOptionsFromTraceConfig(
2632 TraceConfig("*", "record-until-full,enable-sampling")));
2715 2633
2716 options.record_mode = RECORD_CONTINUOUSLY;
2717 EXPECT_EQ( 2634 EXPECT_EQ(
2718 TraceLog::kInternalRecordContinuously | TraceLog::kInternalEnableSampling, 2635 TraceLog::kInternalRecordContinuously | TraceLog::kInternalEnableSampling,
2719 trace_log->GetInternalOptionsFromTraceOptions(options)); 2636 trace_log->GetInternalOptionsFromTraceConfig(
2637 TraceConfig("*", "record-continuously,enable-sampling")));
2720 2638
2721 options.record_mode = ECHO_TO_CONSOLE;
2722 EXPECT_EQ( 2639 EXPECT_EQ(
2723 TraceLog::kInternalEchoToConsole | TraceLog::kInternalEnableSampling, 2640 TraceLog::kInternalEchoToConsole | TraceLog::kInternalEnableSampling,
2724 trace_log->GetInternalOptionsFromTraceOptions(options)); 2641 trace_log->GetInternalOptionsFromTraceConfig(
2642 TraceConfig("*", "trace-to-console,enable-sampling")));
2725 2643
2726 options.enable_systrace = true;
2727 EXPECT_EQ( 2644 EXPECT_EQ(
2728 TraceLog::kInternalEchoToConsole | TraceLog::kInternalEnableSampling, 2645 TraceLog::kInternalEchoToConsole | TraceLog::kInternalEnableSampling,
2729 trace_log->GetInternalOptionsFromTraceOptions(options)); 2646 trace_log->GetInternalOptionsFromTraceConfig(
2647 TraceConfig(
2648 "*", "trace-to-console,enable-sampling,enable-systrace")));
2730 } 2649 }
2731 2650
2732 void SetBlockingFlagAndBlockUntilStopped(WaitableEvent* task_start_event, 2651 void SetBlockingFlagAndBlockUntilStopped(WaitableEvent* task_start_event,
2733 WaitableEvent* task_stop_event) { 2652 WaitableEvent* task_stop_event) {
2734 TraceLog::GetInstance()->SetCurrentThreadBlocksMessageLoop(); 2653 TraceLog::GetInstance()->SetCurrentThreadBlocksMessageLoop();
2735 BlockUntilStopped(task_start_event, task_stop_event); 2654 BlockUntilStopped(task_start_event, task_stop_event);
2736 } 2655 }
2737 2656
2738 TEST_F(TraceEventTestFixture, SetCurrentThreadBlocksMessageLoopAfterTracing) { 2657 TEST_F(TraceEventTestFixture, SetCurrentThreadBlocksMessageLoopAfterTracing) {
2739 BeginTrace(); 2658 BeginTrace();
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after
2813 g_log_buffer = new std::string(); 2732 g_log_buffer = new std::string();
2814 g_log_buffer->append(str); 2733 g_log_buffer->append(str);
2815 return false; 2734 return false;
2816 } 2735 }
2817 2736
2818 TEST_F(TraceEventTestFixture, EchoToConsole) { 2737 TEST_F(TraceEventTestFixture, EchoToConsole) {
2819 logging::LogMessageHandlerFunction old_log_message_handler = 2738 logging::LogMessageHandlerFunction old_log_message_handler =
2820 logging::GetLogMessageHandler(); 2739 logging::GetLogMessageHandler();
2821 logging::SetLogMessageHandler(MockLogMessageHandler); 2740 logging::SetLogMessageHandler(MockLogMessageHandler);
2822 2741
2823 TraceLog::GetInstance()->SetEnabled( 2742 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ECHO_TO_CONSOLE),
2824 CategoryFilter("*"), 2743 TraceLog::RECORDING_MODE);
2825 TraceLog::RECORDING_MODE,
2826 TraceOptions(ECHO_TO_CONSOLE));
2827 TRACE_EVENT_BEGIN0("a", "begin_end"); 2744 TRACE_EVENT_BEGIN0("a", "begin_end");
2828 { 2745 {
2829 TRACE_EVENT0("b", "duration"); 2746 TRACE_EVENT0("b", "duration");
2830 TRACE_EVENT0("b1", "duration1"); 2747 TRACE_EVENT0("b1", "duration1");
2831 } 2748 }
2832 TRACE_EVENT_INSTANT0("c", "instant", TRACE_EVENT_SCOPE_GLOBAL); 2749 TRACE_EVENT_INSTANT0("c", "instant", TRACE_EVENT_SCOPE_GLOBAL);
2833 TRACE_EVENT_END0("a", "begin_end"); 2750 TRACE_EVENT_END0("a", "begin_end");
2834 2751
2835 EXPECT_NE(std::string::npos, g_log_buffer->find("begin_end[a]\x1b")); 2752 EXPECT_NE(std::string::npos, g_log_buffer->find("begin_end[a]\x1b"));
2836 EXPECT_NE(std::string::npos, g_log_buffer->find("| duration[b]\x1b")); 2753 EXPECT_NE(std::string::npos, g_log_buffer->find("| duration[b]\x1b"));
(...skipping 13 matching lines...) Expand all
2850 const std::string&) { 2767 const std::string&) {
2851 TRACE_EVENT0("log", "trace_event"); 2768 TRACE_EVENT0("log", "trace_event");
2852 return false; 2769 return false;
2853 } 2770 }
2854 2771
2855 TEST_F(TraceEventTestFixture, EchoToConsoleTraceEventRecursion) { 2772 TEST_F(TraceEventTestFixture, EchoToConsoleTraceEventRecursion) {
2856 logging::LogMessageHandlerFunction old_log_message_handler = 2773 logging::LogMessageHandlerFunction old_log_message_handler =
2857 logging::GetLogMessageHandler(); 2774 logging::GetLogMessageHandler();
2858 logging::SetLogMessageHandler(LogMessageHandlerWithTraceEvent); 2775 logging::SetLogMessageHandler(LogMessageHandlerWithTraceEvent);
2859 2776
2860 TraceLog::GetInstance()->SetEnabled( 2777 TraceLog::GetInstance()->SetEnabled(TraceConfig("*", ECHO_TO_CONSOLE),
2861 CategoryFilter("*"), 2778 TraceLog::RECORDING_MODE);
2862 TraceLog::RECORDING_MODE,
2863 TraceOptions(ECHO_TO_CONSOLE));
2864 { 2779 {
2865 // This should not cause deadlock or infinite recursion. 2780 // This should not cause deadlock or infinite recursion.
2866 TRACE_EVENT0("b", "duration"); 2781 TRACE_EVENT0("b", "duration");
2867 } 2782 }
2868 2783
2869 EndTraceAndFlush(); 2784 EndTraceAndFlush();
2870 logging::SetLogMessageHandler(old_log_message_handler); 2785 logging::SetLogMessageHandler(old_log_message_handler);
2871 } 2786 }
2872 2787
2873 TEST_F(TraceEventTestFixture, TimeOffset) { 2788 TEST_F(TraceEventTestFixture, TimeOffset) {
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
2909 { 2824 {
2910 TRACE_EVENT_SYNTHETIC_DELAY("test.Delay"); 2825 TRACE_EVENT_SYNTHETIC_DELAY("test.Delay");
2911 } 2826 }
2912 base::TimeDelta duration = base::TimeTicks::Now() - start; 2827 base::TimeDelta duration = base::TimeTicks::Now() - start;
2913 EXPECT_GE(duration.InMilliseconds(), 50); 2828 EXPECT_GE(duration.InMilliseconds(), 50);
2914 2829
2915 EndTraceAndFlush(); 2830 EndTraceAndFlush();
2916 } 2831 }
2917 2832
2918 TEST_F(TraceEventTestFixture, BadSyntheticDelayConfigurations) { 2833 TEST_F(TraceEventTestFixture, BadSyntheticDelayConfigurations) {
2919 const char* const configs[] = { 2834 const char* const filters[] = {
2920 "", 2835 "",
2921 "DELAY(", 2836 "DELAY(",
2922 "DELAY(;", 2837 "DELAY(;",
2923 "DELAY(;)", 2838 "DELAY(;)",
2924 "DELAY(test.Delay)", 2839 "DELAY(test.Delay)",
2925 "DELAY(test.Delay;)" 2840 "DELAY(test.Delay;)"
2926 }; 2841 };
2927 for (size_t i = 0; i < arraysize(configs); i++) { 2842 for (size_t i = 0; i < arraysize(filters); i++) {
2928 BeginSpecificTrace(configs[i]); 2843 BeginSpecificTrace(filters[i]);
2929 EndTraceAndFlush(); 2844 EndTraceAndFlush();
2930 CategoryFilter filter = TraceLog::GetInstance()->GetCurrentCategoryFilter(); 2845 TraceConfig trace_config = TraceLog::GetInstance()->GetCurrentTraceConfig();
2931 EXPECT_EQ(0u, filter.GetSyntheticDelayValues().size()); 2846 EXPECT_EQ(0u, trace_config.GetSyntheticDelayValues().size());
2932 } 2847 }
2933 } 2848 }
2934 2849
2935 TEST_F(TraceEventTestFixture, SyntheticDelayConfigurationMerging) { 2850 TEST_F(TraceEventTestFixture, SyntheticDelayConfigurationMerging) {
2936 CategoryFilter filter1("DELAY(test.Delay1;16)"); 2851 TraceConfig config1("DELAY(test.Delay1;16)", "");
2937 CategoryFilter filter2("DELAY(test.Delay2;32)"); 2852 TraceConfig config2("DELAY(test.Delay2;32)", "");
2938 filter1.Merge(filter2); 2853 config1.Merge(config2);
2939 EXPECT_EQ(2u, filter1.GetSyntheticDelayValues().size()); 2854 EXPECT_EQ(2u, config1.GetSyntheticDelayValues().size());
2940 } 2855 }
2941 2856
2942 TEST_F(TraceEventTestFixture, SyntheticDelayConfigurationToString) { 2857 TEST_F(TraceEventTestFixture, SyntheticDelayConfigurationToString) {
2943 const char config[] = "DELAY(test.Delay;16;oneshot)"; 2858 const char filter[] = "DELAY(test.Delay;16;oneshot)";
2944 CategoryFilter filter(config); 2859 TraceConfig config(filter, "");
2945 EXPECT_EQ(config, filter.ToString()); 2860 EXPECT_EQ(filter, config.ToCategoryFilterString());
2946 } 2861 }
2947 2862
2948 } // namespace trace_event 2863 } // namespace trace_event
2949 } // namespace base 2864 } // namespace base
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698