CPM: API changes for API/UI integration.

chrome/browser/ui/webui/performance_monitor/web_ui_handler.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/webui/performance_monitor/web_ui_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/time.h"
 #include "base/values.h"
@@ skipping 61 matching lines @@
        it != aggregated_metrics.end(); ++it) {
     DictionaryValue* metric_value = new DictionaryValue();
     metric_value->SetDouble("time", it->time.ToJsTime());
     metric_value->SetDouble("value", it->value);
     results->Append(metric_value);
   }
 }
 
 }  // namespace
 
-WebUIHandler::WebUIHandler() {}
+WebUIHandler::WebUIHandler() {
+  // TODO(mtytel): Remove this check when the PerformanceMonitor starts up
+  // before the WebUI.
+  if (!PerformanceMonitor::GetInstance()->database())
+    PerformanceMonitor::GetInstance()->Start();
+}
+
 WebUIHandler::~WebUIHandler() {}
 
 void WebUIHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "getActiveIntervals",
       base::Bind(&WebUIHandler::HandleGetActiveIntervals,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "getAllEventTypes",
       base::Bind(&WebUIHandler::HandleGetAllEventTypes,
@@ skipping 22 matching lines @@
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   CHECK_EQ(2u, args->GetSize());
   double double_time = 0.0;
   CHECK(args->GetDouble(0, &double_time));
   base::Time start = base::Time::FromJsTime(double_time);
   CHECK(args->GetDouble(1, &double_time));
   base::Time end = base::Time::FromJsTime(double_time);
 
   ListValue* results = new ListValue();
   util::PostTaskToDatabaseThreadAndReply(
+      FROM_HERE,
       base::Bind(&DoGetActiveIntervals, results, start, end),
       base::Bind(&WebUIHandler::ReturnResults, AsWeakPtr(),
-                 "performance_monitor.getActiveIntervalsCallback",
+                 "PerformanceMonitor.getActiveIntervalsCallback",
                  base::Owned(results)));
 }
 
 void WebUIHandler::HandleGetAllEventTypes(const ListValue* args) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   CHECK_EQ(0u, args->GetSize());
   ListValue results;
   for (int i = 0; i < EVENT_NUMBER_OF_EVENTS; ++i) {
     EventType event_type = static_cast<EventType>(i);
     DictionaryValue* event_type_info = new DictionaryValue();
     event_type_info->SetInteger("eventType", event_type);
     event_type_info->SetString("shortDescription",
                                EventTypeToString(event_type));
     results.Append(event_type_info);
   }
-
-  ReturnResults("performance_monitor.getAllEventTypesCallback", &results);
+  ReturnResults("PerformanceMonitor.getAllEventTypesCallback", &results);
 }
 
 void WebUIHandler::HandleGetEvents(const ListValue* args) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   CHECK_EQ(3u, args->GetSize());
   double event = 0;
   CHECK(args->GetDouble(0, &event));
   EventType event_type = static_cast<EventType>(static_cast<int>(event));
 
   double double_time = 0.0;
   CHECK(args->GetDouble(1, &double_time));
   base::Time start = base::Time::FromJsTime(double_time);
   CHECK(args->GetDouble(2, &double_time));
   base::Time end = base::Time::FromJsTime(double_time);
 
   DictionaryValue* results = new DictionaryValue();
   ListValue* points_results = new ListValue();
   results->Set("points", points_results);
-  results->SetInteger("type", event_type);
+  results->SetInteger("eventType", event_type);
   util::PostTaskToDatabaseThreadAndReply(
+      FROM_HERE,
       base::Bind(&DoGetEvents, points_results, event_type, start, end),
       base::Bind(&WebUIHandler::ReturnResults, AsWeakPtr(),
-                 "performance_monitor.getEventsCallback",
+                 "PerformanceMonitor.getEventsCallback",
                  base::Owned(results)));
 }
 
 void WebUIHandler::HandleGetAllMetricTypes(const ListValue* args) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   CHECK_EQ(0u, args->GetSize());
   ListValue results;
   for (int i = 0; i < METRIC_NUMBER_OF_METRICS; ++i) {
     MetricType metric_type = static_cast<MetricType>(i);
     const MetricDetails* metric_details = GetMetricDetails(metric_type);
 
     DictionaryValue* metric_type_info = new DictionaryValue();
     metric_type_info->SetInteger("metricType", metric_type);
     metric_type_info->SetString("shortDescription",
                                 metric_details->description);
     metric_type_info->SetDouble("tickSize", metric_details->tick_size);
     metric_type_info->SetString("units", metric_details->units);
     results.Append(metric_type_info);
   }
 
-  ReturnResults("performance_monitor.getAllMetricTypesCallback", &results);
+  ReturnResults("PerformanceMonitor.getAllMetricTypesCallback", &results);
 }
 
 void WebUIHandler::HandleGetMetric(const ListValue* args) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   CHECK_EQ(4u, args->GetSize());
   double metric = 0;
   CHECK(args->GetDouble(0, &metric));
   MetricType metric_type = static_cast<MetricType>(static_cast<int>(metric));
 
   double double_time = 0.0;
   CHECK(args->GetDouble(1, &double_time));
   base::Time start = base::Time::FromJsTime(double_time);
   CHECK(args->GetDouble(2, &double_time));
   base::Time end = base::Time::FromJsTime(double_time);
 
   double resolution_in_milliseconds = 0;
   CHECK(args->GetDouble(3, &resolution_in_milliseconds));
   base::TimeDelta resolution =
       base::TimeDelta::FromMilliseconds(resolution_in_milliseconds);
 
   DictionaryValue* results = new DictionaryValue();
-  results->SetInteger("type", metric_type);
+  results->SetInteger("metricType", metric_type);
   ListValue* points_results = new ListValue();
   results->Set("points", points_results);
   util::PostTaskToDatabaseThreadAndReply(
+      FROM_HERE,
       base::Bind(&DoGetMetric, points_results, metric_type,
                  start, end, resolution),
       base::Bind(&WebUIHandler::ReturnResults, AsWeakPtr(),
-                 "performance_monitor.getMetricCallback",
+                 "PerformanceMonitor.getMetricCallback",
                  base::Owned(results)));
 }
 
 }  // namespace performance_monitor