Implement TracingController::GetMonitoringStatus

content/browser/tracing/tracing_ui.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 "content/browser/tracing/tracing_ui.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 26 matching lines @@
     category_list->AppendString(*it);
   }
 
   base::RefCountedString* res = new base::RefCountedString();
   base::JSONWriter::Write(category_list.get(), &res->data());
   callback.Run(res);
 }
 
 bool GetTracingOptions(const std::string& data64,
                        std::string* category_filter_string,
-                       int* tracing_options)
-{
+                       int* tracing_options) {
   std::string data;
   if (!base::Base64Decode(data64, &data)) {
     LOG(ERROR) << "Options were not base64 encoded.";
     return false;
   }
 
   scoped_ptr<base::Value> optionsRaw(base::JSONReader::Read(data));
   if (!optionsRaw) {
     LOG(ERROR) << "Options were not valid JSON";
     return false;
@@ skipping 24 matching lines @@
     *tracing_options |= TracingController::ENABLE_SYSTRACE;
   if (use_sampling)
     *tracing_options |= TracingController::ENABLE_SAMPLING;
   if (use_continuous_tracing)
     *tracing_options |= TracingController::RECORD_CONTINUOUSLY;
   return true;
 }
 
 void OnRecordingEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 
-bool OnBeginRecording(const std::string& data64,
-                      const WebUIDataSource::GotDataCallback& callback) {
+bool BeginRecording(const std::string& data64,
+                    const WebUIDataSource::GotDataCallback& callback) {
   std::string category_filter_string;
   int tracing_options = 0;
   if (!GetTracingOptions(data64, &category_filter_string, &tracing_options))
     return false;
 
   return TracingController::GetInstance()->EnableRecording(
       category_filter_string,
       static_cast<TracingController::Options>(tracing_options),
       base::Bind(&OnRecordingEnabledAck, callback));
 }
@@ skipping 21 matching lines @@
 void BeginReadingRecordingResult(
     const WebUIDataSource::GotDataCallback& callback,
     const base::FilePath& path) {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(ReadRecordingResult, callback, path));
 }
 
 void OnMonitoringEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 
-bool OnEnableMonitoring(const std::string& data64,
-                        const WebUIDataSource::GotDataCallback& callback) {
+bool EnableMonitoring(const std::string& data64,
+                      const WebUIDataSource::GotDataCallback& callback) {
   std::string category_filter_string;
   int tracing_options = 0;
   if (!GetTracingOptions(data64, &category_filter_string, &tracing_options))
     return false;
 
   return TracingController::GetInstance()->EnableMonitoring(
       category_filter_string,
       static_cast<TracingController::Options>(tracing_options),
       base::Bind(OnMonitoringEnabledAck, callback));
 }
 
 void OnMonitoringEnabledAck(const WebUIDataSource::GotDataCallback& callback) {
   base::RefCountedString* res = new base::RefCountedString();
   callback.Run(res);
 }
 
 void OnMonitoringDisabled(const WebUIDataSource::GotDataCallback& callback) {
   base::RefCountedString* res = new base::RefCountedString();
   callback.Run(res);
 }
 
+void GetMonitoringStatus(const WebUIDataSource::GotDataCallback& callback) {
+  bool is_monitoring;
+  std::string category_filter;
+  TracingController::Options options;
+  TracingController::GetInstance()->GetMonitoringStatus(
+      &is_monitoring, &category_filter, &options);
+
+  scoped_ptr<base::DictionaryValue>
+    monitoring_options(new base::DictionaryValue());
+  monitoring_options->SetBoolean("isMonitoring", is_monitoring);
+  monitoring_options->SetString("categoryFilter", category_filter);
+  monitoring_options->SetBoolean("useSystemTracing",
+      (options & TracingController::ENABLE_SYSTRACE) != 0);
+  monitoring_options->SetBoolean("useContinuousTracing",
+      (options & TracingController::RECORD_CONTINUOUSLY) != 0);
+  monitoring_options->SetBoolean("useSampling",
+      (options & TracingController::ENABLE_SAMPLING) != 0);
+
+  std::string monitoring_options_json;
+  base::JSONWriter::Write(monitoring_options.get(), &monitoring_options_json);
+
+  base::RefCountedString* monitoring_options_base64 =
+    new base::RefCountedString();
+  base::Base64Encode(monitoring_options_json,
+                     &monitoring_options_base64->data());
+  callback.Run(monitoring_options_base64);
+}
+
 void ReadMonitoringSnapshot(const WebUIDataSource::GotDataCallback& callback,
                             const base::FilePath& path) {
   std::string tmp;
   if (!base::ReadFileToString(path, &tmp))
     LOG(ERROR) << "Failed to read file " << path.value();
   base::DeleteFile(path, false);
   callback.Run(base::RefCountedString::TakeString(&tmp));
 }
 
 void OnMonitoringSnapshotCaptured(
     const WebUIDataSource::GotDataCallback& callback,
     const base::FilePath& path) {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(ReadMonitoringSnapshot, callback, path));
 }
 
 bool OnBeginJSONRequest(const std::string& path,
                         const WebUIDataSource::GotDataCallback& callback) {
   if (path == "json/categories") {
     return TracingController::GetInstance()->GetCategories(
         base::Bind(OnGotCategories, callback));
   }
 
   const char* beginRecordingPath = "json/begin_recording?";
   if (StartsWithASCII(path, beginRecordingPath, true)) {
     std::string data = path.substr(strlen(beginRecordingPath));
-    return OnBeginRecording(data, callback);
+    return BeginRecording(data, callback);
   }
   if (path == "json/get_buffer_percent_full") {
     return TracingController::GetInstance()->GetTraceBufferPercentFull(
         base::Bind(OnTraceBufferPercentFullResult, callback));
   }
   if (path == "json/end_recording") {
     return TracingController::GetInstance()->DisableRecording(
         base::FilePath(), base::Bind(BeginReadingRecordingResult, callback));
   }
 
   const char* enableMonitoringPath = "json/begin_monitoring?";
   if (path.find(enableMonitoringPath) == 0) {
     std::string data = path.substr(strlen(enableMonitoringPath));
-    return OnEnableMonitoring(data, callback);
+    return EnableMonitoring(data, callback);
   }
   if (path == "json/end_monitoring") {
     return TracingController::GetInstance()->DisableMonitoring(
         base::Bind(OnMonitoringDisabled, callback));
   }
   if (path == "json/capture_monitoring") {
     TracingController::GetInstance()->CaptureMonitoringSnapshot(
         base::FilePath(), base::Bind(OnMonitoringSnapshotCaptured, callback));
     return true;
   }
+  if (path == "json/get_monitoring_status") {
+    GetMonitoringStatus(callback);
+    return true;
+  }
+
   LOG(ERROR) << "Unhandled request to " << path;
   return false;
 }
 
 bool OnTracingRequest(const std::string& path,
                       const WebUIDataSource::GotDataCallback& callback) {
   if (StartsWithASCII(path, "json/", true)) {
     if (!OnBeginJSONRequest(path, callback)) {
       std::string error("##ERROR##");
       callback.Run(base::RefCountedString::TakeString(&error));
@@ skipping 29 matching lines @@
 TracingUI::~TracingUI() {
   TracingControllerImpl::GetInstance()->UnregisterTracingUI(this);
 }
 
 void TracingUI::OnMonitoringStateChanged(bool is_monitoring) {
   web_ui()->CallJavascriptFunction(
       "onMonitoringStateChanged", base::FundamentalValue(is_monitoring));
 }
 
 }  // namespace content