Tracing: Removed monitoring mode

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 <stddef.h>
 
 #include <set>
 #include <string>
@@ skipping 127 matching lines @@
   status.SetInteger("approximateEventCount", approximate_event_count);
 
   std::string status_json;
   base::JSONWriter::Write(status, &status_json);
 
   base::RefCountedString* status_base64 = new base::RefCountedString();
   base::Base64Encode(status_json, &status_base64->data());
   callback.Run(status_base64);
 }
 
-void OnMonitoringEnabledAck(const WebUIDataSource::GotDataCallback& callback);
-
-bool StartMonitoring(const std::string& data64,
-                      const WebUIDataSource::GotDataCallback& callback) {
-  base::trace_event::TraceConfig trace_config("", "");
-  if (!GetTracingOptions(data64, &trace_config))
-    return false;
-
-  return TracingController::GetInstance()->StartMonitoring(
-      trace_config,
-      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;
-  base::trace_event::TraceConfig config("", "");
-  TracingController::GetInstance()->GetMonitoringStatus(
-      &is_monitoring, &config);
-
-  base::DictionaryValue monitoring_options;
-  monitoring_options.SetBoolean("isMonitoring", is_monitoring);
-  monitoring_options.SetString("categoryFilter",
-                               config.ToCategoryFilterString());
-  monitoring_options.SetBoolean("useSystemTracing", config.IsSystraceEnabled());
-  monitoring_options.SetBoolean(
-      "useContinuousTracing",
-      config.GetTraceRecordMode() == base::trace_event::RECORD_CONTINUOUSLY);
-  monitoring_options.SetBoolean("useSampling", config.IsSamplingEnabled());
-
-  std::string monitoring_options_json;
-  base::JSONWriter::Write(monitoring_options, &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 TracingCallbackWrapperBase64(
     const WebUIDataSource::GotDataCallback& callback,
     scoped_ptr<const base::DictionaryValue> metadata,
     base::RefCountedString* data) {
   base::RefCountedString* data_base64 = new base::RefCountedString();
   base::Base64Encode(data->data(), &data_base64->data());
   callback.Run(data_base64);
 }
 
 void AddCustomMetadata(TracingControllerImpl::TraceDataSink* trace_data_sink) {
@@ skipping 27 matching lines @@
   }
   if (path == "json/end_recording_compressed") {
     scoped_refptr<TracingControllerImpl::TraceDataSink> data_sink =
         TracingController::CreateCompressedStringSink(
             TracingController::CreateCallbackEndpoint(
                 base::Bind(TracingCallbackWrapperBase64, callback)));
     AddCustomMetadata(data_sink.get());
     return TracingController::GetInstance()->StopTracing(data_sink);
   }
 
-  const char* StartMonitoringPath = "json/begin_monitoring?";
-  if (path.find(StartMonitoringPath) == 0) {
-    std::string data = path.substr(strlen(StartMonitoringPath));
-    return StartMonitoring(data, callback);
-  }
-  if (path == "json/end_monitoring") {
-    return TracingController::GetInstance()->StopMonitoring(
-        base::Bind(OnMonitoringDisabled, callback));
-  }
-  if (path == "json/capture_monitoring_compressed") {
-    scoped_refptr<TracingControllerImpl::TraceDataSink> data_sink =
-        TracingController::CreateCompressedStringSink(
-            TracingController::CreateCallbackEndpoint(
-                base::Bind(TracingCallbackWrapperBase64, callback)));
-    AddCustomMetadata(data_sink.get());
-    TracingController::GetInstance()->CaptureMonitoringSnapshot(data_sink);
-    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 (base::StartsWith(path, "json/", base::CompareCase::SENSITIVE)) {
     if (!OnBeginJSONRequest(path, callback)) {
       std::string error("##ERROR##");
       callback.Run(base::RefCountedString::TakeString(&error));
@@ skipping 33 matching lines @@
   source->AddResourcePath("tracing.js", IDR_TRACING_JS);
   source->SetRequestFilter(base::Bind(OnTracingRequest));
   WebUIDataSource::Add(browser_context, source);
   TracingControllerImpl::GetInstance()->RegisterTracingUI(this);
 }
 
 TracingUI::~TracingUI() {
   TracingControllerImpl::GetInstance()->UnregisterTracingUI(this);
 }
 
-void TracingUI::OnMonitoringStateChanged(bool is_monitoring) {
-  web_ui()->CallJavascriptFunction(
-      "onMonitoringStateChanged", base::FundamentalValue(is_monitoring));
-}
-
 void TracingUI::DoUploadBase64Encoded(const base::ListValue* args) {
   std::string file_contents_base64;
   if (!args || args->empty() || !args->GetString(0, &file_contents_base64)) {
     web_ui()->CallJavascriptFunction("onUploadError",
                                      base::StringValue("Missing data"));
     return;
   }
 
   std::string file_contents;
   base::Base64Decode(file_contents_base64, &file_contents);
@@ skipping 59 matching lines @@
     web_ui()->CallJavascriptFunction("onUploadComplete",
                                      base::StringValue(feedback));
   } else {
     web_ui()->CallJavascriptFunction("onUploadError",
                                      base::StringValue(feedback));
   }
   trace_uploader_.reset();
 }
 
 }  // namespace content