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 3 // found in the LICENSE file. 4 5 #include "chrome/browser/ui/webui/performance_monitor/performance_monitor_handler.h" 6 7 #include "base/bind.h" 8 #include "base/bind_helpers.h" 9 #include "base/command_line.h" 10 #include "base/time/time.h" 11 #include "base/values.h" 12 #include "chrome/browser/performance_monitor/database.h" 13 #include "chrome/browser/performance_monitor/event.h" 14 #include "chrome/browser/performance_monitor/metric.h" 15 #include "chrome/browser/performance_monitor/performance_monitor.h" 16 #include "chrome/browser/performance_monitor/performance_monitor_util.h" 17 #include "chrome/browser/ui/webui/performance_monitor/performance_monitor_l10n.h" 18 #include "chrome/browser/ui/webui/performance_monitor/performance_monitor_ui_constants.h" 19 #include "chrome/browser/ui/webui/performance_monitor/performance_monitor_ui_util.h" 20 #include "chrome/common/chrome_switches.h" 21 #include "content/public/browser/browser_thread.h" 22 #include "content/public/browser/web_ui.h" 23 #include "extensions/common/value_builder.h" 24 25 using content::BrowserThread; 26 27 namespace performance_monitor { 28 namespace { 29 30 std::set<MetricType> GetMetricSetForCategory(MetricCategory category) { 31 std::set<MetricType> metric_set; 32 switch (category) { 33 case METRIC_CATEGORY_CPU: 34 metric_set.insert(METRIC_CPU_USAGE); 35 break; 36 case METRIC_CATEGORY_MEMORY: 37 metric_set.insert(METRIC_SHARED_MEMORY_USAGE); 38 metric_set.insert(METRIC_PRIVATE_MEMORY_USAGE); 39 break; 40 case METRIC_CATEGORY_TIMING: 41 metric_set.insert(METRIC_STARTUP_TIME); 42 metric_set.insert(METRIC_TEST_STARTUP_TIME); 43 metric_set.insert(METRIC_SESSION_RESTORE_TIME); 44 metric_set.insert(METRIC_PAGE_LOAD_TIME); 45 break; 46 case METRIC_CATEGORY_NETWORK: 47 metric_set.insert(METRIC_NETWORK_BYTES_READ); 48 break; 49 default: 50 NOTREACHED(); 51 } 52 return metric_set; 53 } 54 55 std::set<EventType> GetEventSetForCategory(EventCategory category) { 56 std::set<EventType> event_set; 57 switch (category) { 58 case EVENT_CATEGORY_EXTENSIONS: 59 event_set.insert(EVENT_EXTENSION_INSTALL); 60 event_set.insert(EVENT_EXTENSION_UNINSTALL); 61 event_set.insert(EVENT_EXTENSION_UPDATE); 62 event_set.insert(EVENT_EXTENSION_ENABLE); 63 event_set.insert(EVENT_EXTENSION_DISABLE); 64 break; 65 case EVENT_CATEGORY_CHROME: 66 event_set.insert(EVENT_CHROME_UPDATE); 67 break; 68 case EVENT_CATEGORY_EXCEPTIONS: 69 event_set.insert(EVENT_RENDERER_HANG); 70 event_set.insert(EVENT_RENDERER_CRASH); 71 event_set.insert(EVENT_RENDERER_KILLED); 72 event_set.insert(EVENT_UNCLEAN_EXIT); 73 break; 74 default: 75 NOTREACHED(); 76 } 77 return event_set; 78 } 79 80 Unit GetUnitForMetricCategory(MetricCategory category) { 81 switch (category) { 82 case METRIC_CATEGORY_CPU: 83 return UNIT_PERCENT; 84 case METRIC_CATEGORY_MEMORY: 85 return UNIT_MEGABYTES; 86 case METRIC_CATEGORY_TIMING: 87 return UNIT_SECONDS; 88 case METRIC_CATEGORY_NETWORK: 89 return UNIT_MEGABYTES; 90 default: 91 NOTREACHED(); 92 } 93 return UNIT_UNDEFINED; 94 } 95 96 MetricCategory GetCategoryForMetric(MetricType type) { 97 switch (type) { 98 case METRIC_CPU_USAGE: 99 return METRIC_CATEGORY_CPU; 100 case METRIC_SHARED_MEMORY_USAGE: 101 case METRIC_PRIVATE_MEMORY_USAGE: 102 return METRIC_CATEGORY_MEMORY; 103 case METRIC_STARTUP_TIME: 104 case METRIC_TEST_STARTUP_TIME: 105 case METRIC_SESSION_RESTORE_TIME: 106 case METRIC_PAGE_LOAD_TIME: 107 return METRIC_CATEGORY_TIMING; 108 case METRIC_NETWORK_BYTES_READ: 109 return METRIC_CATEGORY_NETWORK; 110 default: 111 NOTREACHED(); 112 } 113 return METRIC_CATEGORY_NUMBER_OF_CATEGORIES; 114 } 115 116 Unit GetUnitForMetricType(MetricType type) { 117 switch (type) { 118 case METRIC_CPU_USAGE: 119 return UNIT_PERCENT; 120 case METRIC_SHARED_MEMORY_USAGE: 121 case METRIC_PRIVATE_MEMORY_USAGE: 122 case METRIC_NETWORK_BYTES_READ: 123 return UNIT_BYTES; 124 case METRIC_STARTUP_TIME: 125 case METRIC_TEST_STARTUP_TIME: 126 case METRIC_SESSION_RESTORE_TIME: 127 case METRIC_PAGE_LOAD_TIME: 128 return UNIT_MICROSECONDS; 129 default: 130 NOTREACHED(); 131 } 132 return UNIT_UNDEFINED; 133 } 134 135 // Returns a dictionary for the aggregation method. Aggregation strategies 136 // contain an id representing the method, and localized strings for the 137 // method name and method description. 138 scoped_ptr<DictionaryValue> GetAggregationMethod( 139 AggregationMethod method) { 140 scoped_ptr<DictionaryValue> value(new DictionaryValue()); 141 value->SetInteger("id", method); 142 value->SetString("name", GetLocalizedStringFromAggregationMethod(method)); 143 value->SetString( 144 "description", 145 GetLocalizedStringForAggregationMethodDescription(method)); 146 return value.Pass(); 147 } 148 149 // Returns a list of metric details, with one entry per metric. Metric details 150 // are dictionaries which contain the id representing the metric and localized 151 // strings for the metric name and metric description. 152 scoped_ptr<ListValue> GetMetricDetailsForCategory(MetricCategory category) { 153 scoped_ptr<ListValue> value(new ListValue()); 154 std::set<MetricType> metric_set = GetMetricSetForCategory(category); 155 for (std::set<MetricType>::const_iterator iter = metric_set.begin(); 156 iter != metric_set.end(); ++iter) { 157 DictionaryValue* metric_details = new DictionaryValue(); 158 metric_details->SetInteger("metricId", *iter); 159 metric_details->SetString( 160 "name", GetLocalizedStringFromMetricType(*iter)); 161 metric_details->SetString( 162 "description", GetLocalizedStringForMetricTypeDescription(*iter)); 163 value->Append(metric_details); 164 } 165 return value.Pass(); 166 } 167 168 // Returns a dictionary for the metric category. Metric categories contain 169 // an id representing the category; localized strings for the category name, 170 // the default unit in which the category is measured, and the category's 171 // description; and the metric details for each metric type in the category. 172 scoped_ptr<DictionaryValue> GetMetricCategory(MetricCategory category) { 173 scoped_ptr<DictionaryValue> value(new DictionaryValue()); 174 value->SetInteger("metricCategoryId", category); 175 value->SetString( 176 "name", GetLocalizedStringFromMetricCategory(category)); 177 value->SetString( 178 "unit", 179 GetLocalizedStringFromUnit(GetUnitForMetricCategory(category))); 180 value->SetString( 181 "description", 182 GetLocalizedStringForMetricCategoryDescription(category)); 183 value->Set("details", GetMetricDetailsForCategory(category).release()); 184 return value.Pass(); 185 } 186 187 // Returns a list of event types, with one entry per event. Event types 188 // are dictionaries which contain the id representing the event and localized 189 // strings for the event name, event description, and a title suitable for a 190 // mouseover popup. 191 scoped_ptr<ListValue> GetEventTypesForCategory(EventCategory category) { 192 scoped_ptr<ListValue> value(new ListValue()); 193 std::set<EventType> event_set = GetEventSetForCategory(category); 194 for (std::set<EventType>::const_iterator iter = event_set.begin(); 195 iter != event_set.end(); ++iter) { 196 DictionaryValue* event_details = new DictionaryValue(); 197 event_details->SetInteger("eventId", *iter); 198 event_details->SetString( 199 "name", GetLocalizedStringFromEventType(*iter)); 200 event_details->SetString( 201 "description", GetLocalizedStringForEventTypeDescription(*iter)); 202 event_details->SetString( 203 "popupTitle", GetLocalizedStringForEventTypeMouseover(*iter)); 204 value->Append(event_details); 205 } 206 return value.Pass(); 207 } 208 209 // Returns a dictionary for the event category. Event categories contain an 210 // id representing the category, localized strings for the event name and 211 // event description, and event details for each event type in the category. 212 scoped_ptr<DictionaryValue> GetEventCategory(EventCategory category) { 213 scoped_ptr<DictionaryValue> value(new DictionaryValue()); 214 value->SetInteger("eventCategoryId", category); 215 value->SetString( 216 "name", GetLocalizedStringFromEventCategory(category)); 217 value->SetString( 218 "description", 219 GetLocalizedStringForEventCategoryDescription(category)); 220 value->Set("details", GetEventTypesForCategory(category).release()); 221 return value.Pass(); 222 } 223 224 // Queries the performance monitor database for active intervals between 225 // |start| and |end| times and appends the results to |results|. 226 void DoGetActiveIntervals(ListValue* results, 227 const base::Time& start, 228 const base::Time& end) { 229 Database* db = PerformanceMonitor::GetInstance()->database(); 230 if (db == NULL) 231 return; 232 233 std::vector<TimeRange> intervals = db->GetActiveIntervals(start, end); 234 235 for (std::vector<TimeRange>::iterator it = intervals.begin(); 236 it != intervals.end(); ++it) { 237 DictionaryValue* interval_value = new DictionaryValue(); 238 interval_value->SetDouble("start", it->start.ToJsTime()); 239 interval_value->SetDouble("end", it->end.ToJsTime()); 240 results->Append(interval_value); 241 } 242 } 243 244 // Queries the PerformanceMonitor database for events of type |event_type| 245 // between |start| and |end| times, creates a new event with localized keys 246 // for display, and appends the results to |results|. 247 void DoGetEvents(ListValue* results, 248 const std::set<EventType>& event_types, 249 const base::Time& start, 250 const base::Time& end) { 251 Database* db = PerformanceMonitor::GetInstance()->database(); 252 if (db == NULL) 253 return; 254 255 for (std::set<EventType>::const_iterator iter = event_types.begin(); 256 iter != event_types.end(); ++iter) { 257 DictionaryValue* event_results = new DictionaryValue(); 258 event_results->SetInteger("eventId", static_cast<int>(*iter)); 259 ListValue* events = new ListValue(); 260 event_results->Set("events", events); 261 results->Append(event_results); 262 263 Database::EventVector event_vector = db->GetEvents(*iter, start, end); 264 265 for (Database::EventVector::iterator event = event_vector.begin(); 266 event != event_vector.end(); ++event) { 267 DictionaryValue* localized_event = new DictionaryValue(); 268 269 for (DictionaryValue::Iterator data(*(*event)->data()); !data.IsAtEnd(); 270 data.Advance()) { 271 Value* value = NULL; 272 273 // The property 'eventType' is set in HandleGetEvents as part of the 274 // entire result set, so we don't need to include this here in the 275 // event. 276 if (data.key() == "eventType") 277 continue; 278 else if (data.key() == "time") { 279 // The property 'time' is also used computationally, but must be 280 // converted to JS-style time. 281 double time = 0.0; 282 if (!data.value().GetAsDouble(&time)) { 283 LOG(ERROR) << "Failed to get 'time' field from event."; 284 continue; 285 } 286 value = Value::CreateDoubleValue( 287 base::Time::FromInternalValue( 288 static_cast<int64>(time)).ToJsTime()); 289 } else { 290 // All other values are user-facing, so we create a new value for 291 // localized display. 292 DictionaryValue* localized_value = new DictionaryValue(); 293 localized_value->SetString( 294 "label", 295 GetLocalizedStringFromEventProperty(data.key())); 296 localized_value->SetWithoutPathExpansion("value", 297 data.value().DeepCopy()); 298 value = localized_value; 299 } 300 301 localized_event->SetWithoutPathExpansion(data.key(), value); 302 } 303 events->Append(localized_event); 304 } 305 } 306 } 307 308 // Populates results with a dictionary for each metric requested. The dictionary 309 // includes a metric id, the maximum value for the metric, and a list of lists 310 // of metric points, with each sublist containing the aggregated data for an 311 // interval for which PerformanceMonitor was active. This will also convert 312 // time to JS-style time. 313 void DoGetMetrics(ListValue* results, 314 const std::set<MetricType>& metric_types, 315 const base::Time& start, 316 const base::Time& end, 317 const base::TimeDelta& resolution, 318 AggregationMethod aggregation_method) { 319 Database* db = PerformanceMonitor::GetInstance()->database(); 320 if (db == NULL) 321 return; 322 323 std::vector<TimeRange> intervals = db->GetActiveIntervals(start, end); 324 325 // For each metric type, populate a new dictionary and append it to results. 326 for (std::set<MetricType>::const_iterator metric_type = metric_types.begin(); 327 metric_type != metric_types.end(); ++metric_type) { 328 double conversion_factor = 329 GetConversionFactor(*GetUnitDetails(GetUnitForMetricType(*metric_type)), 330 *GetUnitDetails(GetUnitForMetricCategory( 331 GetCategoryForMetric(*metric_type)))); 332 333 DictionaryValue* metric_set = new DictionaryValue(); 334 metric_set->SetInteger("metricId", static_cast<int>(*metric_type)); 335 metric_set->SetDouble( 336 "maxValue", 337 db->GetMaxStatsForActivityAndMetric(*metric_type) * conversion_factor); 338 339 // Retrieve all metrics in the database, and aggregate them into a series 340 // of points for each active interval. 341 scoped_ptr<Database::MetricVector> metric_vector = 342 db->GetStatsForActivityAndMetric(*metric_type, start, end); 343 344 scoped_ptr<VectorOfMetricVectors> aggregated_metrics = 345 AggregateMetric(*metric_type, 346 metric_vector.get(), 347 start, 348 intervals, 349 resolution, 350 aggregation_method); 351 352 // The JS-side expects a list to be present, even if there are no metrics. 353 if (!aggregated_metrics) { 354 metric_set->Set("metrics", new ListValue()); 355 results->Append(metric_set); 356 continue; 357 } 358 359 ListValue* metric_points_by_interval = new ListValue(); 360 361 // For each metric point, record it in the expected format for the JS-side 362 // (a dictionary of time and value, with time as a JS-style time), and 363 // convert the values to be display-friendly. 364 for (VectorOfMetricVectors::const_iterator metric_series = 365 aggregated_metrics->begin(); 366 metric_series != aggregated_metrics->end(); ++metric_series) { 367 ListValue* series_value = new ListValue(); 368 for (Database::MetricVector::const_iterator metric_point = 369 metric_series->begin(); 370 metric_point != metric_series->end(); ++metric_point) { 371 DictionaryValue* point_value = new DictionaryValue(); 372 point_value->SetDouble("time", metric_point->time.ToJsTime()); 373 point_value->SetDouble("value", 374 metric_point->value * conversion_factor); 375 series_value->Append(point_value); 376 } 377 metric_points_by_interval->Append(series_value); 378 } 379 380 metric_set->Set("metrics", metric_points_by_interval); 381 results->Append(metric_set); 382 } 383 } 384 385 } // namespace 386 387 PerformanceMonitorHandler::PerformanceMonitorHandler() { 388 } 389 390 PerformanceMonitorHandler::~PerformanceMonitorHandler() {} 391 392 void PerformanceMonitorHandler::RegisterMessages() { 393 web_ui()->RegisterMessageCallback( 394 "getActiveIntervals", 395 base::Bind(&PerformanceMonitorHandler::HandleGetActiveIntervals, 396 AsWeakPtr())); 397 web_ui()->RegisterMessageCallback( 398 "getFlagEnabled", 399 base::Bind(&PerformanceMonitorHandler::HandleGetFlagEnabled, 400 AsWeakPtr())); 401 web_ui()->RegisterMessageCallback( 402 "getAggregationTypes", 403 base::Bind(&PerformanceMonitorHandler::HandleGetAggregationTypes, 404 AsWeakPtr())); 405 web_ui()->RegisterMessageCallback( 406 "getEventTypes", 407 base::Bind(&PerformanceMonitorHandler::HandleGetEventTypes, 408 AsWeakPtr())); 409 web_ui()->RegisterMessageCallback( 410 "getEvents", 411 base::Bind(&PerformanceMonitorHandler::HandleGetEvents, 412 AsWeakPtr())); 413 web_ui()->RegisterMessageCallback( 414 "getMetricTypes", 415 base::Bind(&PerformanceMonitorHandler::HandleGetMetricTypes, 416 AsWeakPtr())); 417 web_ui()->RegisterMessageCallback( 418 "getMetrics", 419 base::Bind(&PerformanceMonitorHandler::HandleGetMetrics, 420 AsWeakPtr())); 421 } 422 423 void PerformanceMonitorHandler::ReturnResults(const std::string& function, 424 const Value* results) { 425 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 426 web_ui()->CallJavascriptFunction(function, *results); 427 } 428 429 void PerformanceMonitorHandler::HandleGetActiveIntervals( 430 const ListValue* args) { 431 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 432 CHECK_EQ(2u, args->GetSize()); 433 double double_time = 0.0; 434 CHECK(args->GetDouble(0, &double_time)); 435 base::Time start = base::Time::FromJsTime(double_time); 436 CHECK(args->GetDouble(1, &double_time)); 437 base::Time end = base::Time::FromJsTime(double_time); 438 439 ListValue* results = new ListValue(); 440 util::PostTaskToDatabaseThreadAndReply( 441 FROM_HERE, 442 base::Bind(&DoGetActiveIntervals, results, start, end), 443 base::Bind(&PerformanceMonitorHandler::ReturnResults, AsWeakPtr(), 444 "PerformanceMonitor.getActiveIntervalsCallback", 445 base::Owned(results))); 446 } 447 448 void PerformanceMonitorHandler::HandleGetFlagEnabled(const ListValue* args) { 449 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 450 CHECK_EQ(0u, args->GetSize()); 451 scoped_ptr<Value> value(Value::CreateBooleanValue( 452 CommandLine::ForCurrentProcess()->HasSwitch( 453 switches::kPerformanceMonitorGathering))); 454 ReturnResults("PerformanceMonitor.getFlagEnabledCallback", value.get()); 455 } 456 457 void PerformanceMonitorHandler::HandleGetAggregationTypes( 458 const ListValue* args) { 459 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 460 CHECK_EQ(0u, args->GetSize()); 461 ListValue results; 462 for (int i = 0; i < AGGREGATION_METHOD_NUMBER_OF_METHODS; ++i) { 463 results.Append( 464 GetAggregationMethod(static_cast<AggregationMethod>(i)).release()); 465 } 466 467 ReturnResults( 468 "PerformanceMonitor.getAggregationTypesCallback", &results); 469 } 470 471 void PerformanceMonitorHandler::HandleGetEventTypes(const ListValue* args) { 472 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 473 CHECK_EQ(0u, args->GetSize()); 474 ListValue results; 475 for (int i = 0; i < EVENT_CATEGORY_NUMBER_OF_CATEGORIES; ++i) 476 results.Append(GetEventCategory(static_cast<EventCategory>(i)).release()); 477 478 ReturnResults("PerformanceMonitor.getEventTypesCallback", &results); 479 } 480 481 void PerformanceMonitorHandler::HandleGetEvents(const ListValue* args) { 482 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 483 CHECK_EQ(3u, args->GetSize()); 484 485 const ListValue* event_type_list; 486 CHECK(args->GetList(0, &event_type_list)); 487 std::set<EventType> event_types; 488 for (ListValue::const_iterator iter = event_type_list->begin(); 489 iter != event_type_list->end(); ++iter) { 490 double event_type_double = 0.0; 491 CHECK((*iter)->GetAsDouble(&event_type_double)); 492 CHECK(event_type_double < EVENT_NUMBER_OF_EVENTS && 493 event_type_double > EVENT_UNDEFINED); 494 event_types.insert( 495 static_cast<EventType>(static_cast<int>(event_type_double))); 496 } 497 498 double double_time = 0.0; 499 CHECK(args->GetDouble(1, &double_time)); 500 base::Time start = base::Time::FromJsTime(double_time); 501 CHECK(args->GetDouble(2, &double_time)); 502 base::Time end = base::Time::FromJsTime(double_time); 503 504 ListValue* results = new ListValue(); 505 util::PostTaskToDatabaseThreadAndReply( 506 FROM_HERE, 507 base::Bind(&DoGetEvents, results, event_types, start, end), 508 base::Bind(&PerformanceMonitorHandler::ReturnResults, AsWeakPtr(), 509 "PerformanceMonitor.getEventsCallback", 510 base::Owned(results))); 511 } 512 513 void PerformanceMonitorHandler::HandleGetMetricTypes(const ListValue* args) { 514 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 515 CHECK_EQ(0u, args->GetSize()); 516 ListValue results; 517 for (int i = 0; i < METRIC_CATEGORY_NUMBER_OF_CATEGORIES; ++i) 518 results.Append(GetMetricCategory(static_cast<MetricCategory>(i)).release()); 519 520 ReturnResults("PerformanceMonitor.getMetricTypesCallback", &results); 521 } 522 523 void PerformanceMonitorHandler::HandleGetMetrics(const ListValue* args) { 524 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 525 CHECK_EQ(5u, args->GetSize()); 526 527 const ListValue* metric_type_list; 528 CHECK(args->GetList(0, &metric_type_list)); 529 std::set<MetricType> metric_types; 530 for (ListValue::const_iterator iter = metric_type_list->begin(); 531 iter != metric_type_list->end(); ++iter) { 532 double metric_type_double = 0.0; 533 CHECK((*iter)->GetAsDouble(&metric_type_double)); 534 CHECK(metric_type_double < METRIC_NUMBER_OF_METRICS && 535 metric_type_double > METRIC_UNDEFINED); 536 metric_types.insert( 537 static_cast<MetricType>(static_cast<int>(metric_type_double))); 538 } 539 540 double time_double = 0.0; 541 CHECK(args->GetDouble(1, &time_double)); 542 base::Time start = base::Time::FromJsTime(time_double); 543 CHECK(args->GetDouble(2, &time_double)); 544 base::Time end = base::Time::FromJsTime(time_double); 545 546 double resolution_in_milliseconds = 0.0; 547 CHECK(args->GetDouble(3, &resolution_in_milliseconds)); 548 base::TimeDelta resolution = 549 base::TimeDelta::FromMilliseconds(resolution_in_milliseconds); 550 551 double aggregation_double = 0.0; 552 CHECK(args->GetDouble(4, &aggregation_double)); 553 CHECK(aggregation_double < AGGREGATION_METHOD_NUMBER_OF_METHODS && 554 aggregation_double >= 0); 555 AggregationMethod aggregation_method = 556 static_cast<AggregationMethod>(static_cast<int>(aggregation_double)); 557 558 ListValue* results = new ListValue(); 559 util::PostTaskToDatabaseThreadAndReply( 560 FROM_HERE, 561 base::Bind(&DoGetMetrics, results, metric_types, 562 start, end, resolution, aggregation_method), 563 base::Bind(&PerformanceMonitorHandler::ReturnResults, AsWeakPtr(), 564 "PerformanceMonitor.getMetricsCallback", 565 base::Owned(results))); 566 } 567 568 } // namespace performance_monitor 569
