content/browser/tracing/tracing_ui.cc

   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 "content/browser/tracing/tracing_ui.h"
   6
   7 #include <set>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/base64.h"
  12 #include "base/bind.h"
  13 #include "base/bind_helpers.h"
  14 #include "base/format_macros.h"
  15 #include "base/json/json_reader.h"
  16 #include "base/json/json_writer.h"
  17 #include "base/memory/scoped_ptr.h"
  18 #include "base/strings/string_number_conversions.h"
  19 #include "base/strings/string_split.h"
  20 #include "base/strings/string_util.h"
  21 #include "base/strings/stringprintf.h"
  22 #include "base/trace_event/trace_event.h"
  23 #include "base/values.h"
  24 #include "content/browser/tracing/grit/tracing_resources.h"
  25 #include "content/browser/tracing/tracing_controller_impl.h"
  26 #include "content/public/browser/browser_context.h"
  27 #include "content/public/browser/browser_thread.h"
  28 #include "content/public/browser/content_browser_client.h"
  29 #include "content/public/browser/trace_uploader.h"
  30 #include "content/public/browser/tracing_controller.h"
  31 #include "content/public/browser/tracing_delegate.h"
  32 #include "content/public/browser/web_contents.h"
  33 #include "content/public/browser/web_ui.h"
  34 #include "content/public/browser/web_ui_data_source.h"
  35 #include "content/public/common/content_client.h"
  36 #include "content/public/common/url_constants.h"
  37
  38 namespace content {
  39 namespace {
  40
  41 void OnGotCategories(const WebUIDataSource::GotDataCallback& callback,
  42                      const std::set<std::string>& categorySet) {
  43   scoped_ptr<base::ListValue> category_list(new base::ListValue());
  44   for (std::set<std::string>::const_iterator it = categorySet.begin();
  45        it != categorySet.end(); it++) {
  46     category_list->AppendString(*it);
  47   }
  48
  49   base::RefCountedString* res = new base::RefCountedString();
  50   base::JSONWriter::Write(category_list.get(), &res->data());
  51   callback.Run(res);
  52 }
  53
  54 bool GetTracingOptions(const std::string& data64,
  55                        base::trace_event::CategoryFilter* category_filter,
  56                        base::trace_event::TraceOptions* tracing_options) {
  57   std::string data;
  58   if (!base::Base64Decode(data64, &data)) {
  59     LOG(ERROR) << "Options were not base64 encoded.";
  60     return false;
  61   }
  62
  63   scoped_ptr<base::Value> optionsRaw(base::JSONReader::Read(data));
  64   if (!optionsRaw) {
  65     LOG(ERROR) << "Options were not valid JSON";
  66     return false;
  67   }
  68   base::DictionaryValue* options;
  69   if (!optionsRaw->GetAsDictionary(&options)) {
  70     LOG(ERROR) << "Options must be dict";
  71     return false;
  72   }
  73
  74   if (!category_filter) {
  75     LOG(ERROR) << "category_filter can't be passed as NULL";
  76     return false;
  77   }
  78
  79   if (!tracing_options) {
  80     LOG(ERROR) << "tracing_options can't be passed as NULL";
  81     return false;
  82   }
  83
  84   bool options_ok = true;
  85   std::string category_filter_string;
  86   options_ok &= options->GetString("categoryFilter", &category_filter_string);
  87   *category_filter = base::trace_event::CategoryFilter(category_filter_string);
  88
  89   std::string record_mode;
  90   options_ok &=
  91       options->GetString("tracingRecordMode", &record_mode);
  92   options_ok &= tracing_options->SetFromString(record_mode);
  93
  94   options_ok &= options->GetBoolean("useSystemTracing",
  95                                     &tracing_options->enable_systrace);
  96   options_ok &=
  97       options->GetBoolean("useSampling", &tracing_options->enable_sampling);
  98
  99   if (!options_ok) {
 100     LOG(ERROR) << "Malformed options";
 101     return false;
 102   }
 103   return true;
 104 }
 105
 106 void OnRecordingEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 107
 108 bool BeginRecording(const std::string& data64,
 109                     const WebUIDataSource::GotDataCallback& callback) {
 110   base::trace_event::CategoryFilter category_filter("");
 111   base::trace_event::TraceOptions tracing_options;
 112   if (!GetTracingOptions(data64, &category_filter, &tracing_options))
 113     return false;
 114
 115   return TracingController::GetInstance()->EnableRecording(
 116       category_filter,
 117       tracing_options,
 118       base::Bind(&OnRecordingEnabledAck, callback));
 119 }
 120
 121 void OnRecordingEnabledAck(const WebUIDataSource::GotDataCallback& callback) {
 122   base::RefCountedString* res = new base::RefCountedString();
 123   callback.Run(res);
 124 }
 125
 126 void OnTraceBufferUsageResult(const WebUIDataSource::GotDataCallback& callback,
 127                               float percent_full,
 128                               size_t approximate_event_count) {
 129   std::string str = base::DoubleToString(percent_full);
 130   callback.Run(base::RefCountedString::TakeString(&str));
 131 }
 132
 133 void OnTraceBufferStatusResult(const WebUIDataSource::GotDataCallback& callback,
 134                                float percent_full,
 135                                size_t approximate_event_count) {
 136   scoped_ptr<base::DictionaryValue> status(new base::DictionaryValue());
 137   status->SetDouble("percentFull", percent_full);
 138   status->SetInteger("approximateEventCount", approximate_event_count);
 139
 140   std::string status_json;
 141   base::JSONWriter::Write(status.get(), &status_json);
 142
 143   base::RefCountedString* status_base64 = new base::RefCountedString();
 144   base::Base64Encode(status_json, &status_base64->data());
 145   callback.Run(status_base64);
 146 }
 147
 148 void OnMonitoringEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 149
 150 bool EnableMonitoring(const std::string& data64,
 151                       const WebUIDataSource::GotDataCallback& callback) {
 152   base::trace_event::TraceOptions tracing_options;
 153   base::trace_event::CategoryFilter category_filter("");
 154   if (!GetTracingOptions(data64, &category_filter, &tracing_options))
 155     return false;
 156
 157   return TracingController::GetInstance()->EnableMonitoring(
 158       category_filter,
 159       tracing_options,
 160       base::Bind(OnMonitoringEnabledAck, callback));
 161 }
 162
 163 void OnMonitoringEnabledAck(const WebUIDataSource::GotDataCallback& callback) {
 164   base::RefCountedString* res = new base::RefCountedString();
 165   callback.Run(res);
 166 }
 167
 168 void OnMonitoringDisabled(const WebUIDataSource::GotDataCallback& callback) {
 169   base::RefCountedString* res = new base::RefCountedString();
 170   callback.Run(res);
 171 }
 172
 173 void GetMonitoringStatus(const WebUIDataSource::GotDataCallback& callback) {
 174   bool is_monitoring;
 175   base::trace_event::CategoryFilter category_filter("");
 176   base::trace_event::TraceOptions options;
 177   TracingController::GetInstance()->GetMonitoringStatus(
 178       &is_monitoring, &category_filter, &options);
 179
 180   scoped_ptr<base::DictionaryValue>
 181     monitoring_options(new base::DictionaryValue());
 182   monitoring_options->SetBoolean("isMonitoring", is_monitoring);
 183   monitoring_options->SetString("categoryFilter", category_filter.ToString());
 184   monitoring_options->SetBoolean("useSystemTracing", options.enable_systrace);
 185   monitoring_options->SetBoolean(
 186       "useContinuousTracing",
 187       options.record_mode == base::trace_event::RECORD_CONTINUOUSLY);
 188   monitoring_options->SetBoolean("useSampling", options.enable_sampling);
 189
 190   std::string monitoring_options_json;
 191   base::JSONWriter::Write(monitoring_options.get(), &monitoring_options_json);
 192
 193   base::RefCountedString* monitoring_options_base64 =
 194     new base::RefCountedString();
 195   base::Base64Encode(monitoring_options_json,
 196                      &monitoring_options_base64->data());
 197   callback.Run(monitoring_options_base64);
 198 }
 199
 200 void TracingCallbackWrapper(const WebUIDataSource::GotDataCallback& callback,
 201                             base::RefCountedString* data) {
 202   callback.Run(data);
 203 }
 204
 205 bool OnBeginJSONRequest(const std::string& path,
 206                         const WebUIDataSource::GotDataCallback& callback) {
 207   if (path == "json/categories") {
 208     return TracingController::GetInstance()->GetCategories(
 209         base::Bind(OnGotCategories, callback));
 210   }
 211
 212   const char* beginRecordingPath = "json/begin_recording?";
 213   if (StartsWithASCII(path, beginRecordingPath, true)) {
 214     std::string data = path.substr(strlen(beginRecordingPath));
 215     return BeginRecording(data, callback);
 216   }
 217   if (path == "json/get_buffer_percent_full") {
 218     return TracingController::GetInstance()->GetTraceBufferUsage(
 219         base::Bind(OnTraceBufferUsageResult, callback));
 220   }
 221   if (path == "json/get_buffer_status") {
 222     return TracingController::GetInstance()->GetTraceBufferUsage(
 223         base::Bind(OnTraceBufferStatusResult, callback));
 224   }
 225   if (path == "json/end_recording") {
 226     return TracingController::GetInstance()->DisableRecording(
 227         TracingControllerImpl::CreateStringSink(
 228             base::Bind(TracingCallbackWrapper, callback)));
 229   }
 230
 231   const char* enableMonitoringPath = "json/begin_monitoring?";
 232   if (path.find(enableMonitoringPath) == 0) {
 233     std::string data = path.substr(strlen(enableMonitoringPath));
 234     return EnableMonitoring(data, callback);
 235   }
 236   if (path == "json/end_monitoring") {
 237     return TracingController::GetInstance()->DisableMonitoring(
 238         base::Bind(OnMonitoringDisabled, callback));
 239   }
 240   if (path == "json/capture_monitoring") {
 241     TracingController::GetInstance()->CaptureMonitoringSnapshot(
 242         TracingControllerImpl::CreateStringSink(
 243             base::Bind(TracingCallbackWrapper, callback)));
 244     return true;
 245   }
 246   if (path == "json/get_monitoring_status") {
 247     GetMonitoringStatus(callback);
 248     return true;
 249   }
 250
 251   LOG(ERROR) << "Unhandled request to " << path;
 252   return false;
 253 }
 254
 255 bool OnTracingRequest(const std::string& path,
 256                       const WebUIDataSource::GotDataCallback& callback) {
 257   if (StartsWithASCII(path, "json/", true)) {
 258     if (!OnBeginJSONRequest(path, callback)) {
 259       std::string error("##ERROR##");
 260       callback.Run(base::RefCountedString::TakeString(&error));
 261     }
 262     return true;
 263   }
 264   return false;
 265 }
 266
 267 }  // namespace
 268
 269
 270 ////////////////////////////////////////////////////////////////////////////////
 271 //
 272 // TracingUI
 273 //
 274 ////////////////////////////////////////////////////////////////////////////////
 275
 276 TracingUI::TracingUI(WebUI* web_ui)
 277     : WebUIController(web_ui),
 278       delegate_(GetContentClient()->browser()->GetTracingDelegate()),
 279       weak_factory_(this) {
 280   web_ui->RegisterMessageCallback(
 281         "doUpload",
 282         base::Bind(&TracingUI::DoUpload, base::Unretained(this)));
 283
 284   // Set up the chrome://tracing/ source.
 285   BrowserContext* browser_context =
 286       web_ui->GetWebContents()->GetBrowserContext();
 287
 288   WebUIDataSource* source = WebUIDataSource::Create(kChromeUITracingHost);
 289   source->SetJsonPath("strings.js");
 290   source->SetDefaultResource(IDR_TRACING_HTML);
 291   source->AddResourcePath("tracing.js", IDR_TRACING_JS);
 292   source->SetRequestFilter(base::Bind(OnTracingRequest));
 293   WebUIDataSource::Add(browser_context, source);
 294   TracingControllerImpl::GetInstance()->RegisterTracingUI(this);
 295 }
 296
 297 TracingUI::~TracingUI() {
 298   TracingControllerImpl::GetInstance()->UnregisterTracingUI(this);
 299 }
 300
 301 void TracingUI::OnMonitoringStateChanged(bool is_monitoring) {
 302   web_ui()->CallJavascriptFunction(
 303       "onMonitoringStateChanged", base::FundamentalValue(is_monitoring));
 304 }
 305
 306 void TracingUI::DoUpload(const base::ListValue* args) {
 307   std::string file_contents;
 308   if (!args || args->empty() || !args->GetString(0, &file_contents)) {
 309     web_ui()->CallJavascriptFunction("onUploadError",
 310                                      base::StringValue("Missing data"));
 311     return;
 312   }
 313
 314   if (!delegate_) {
 315     web_ui()->CallJavascriptFunction("onUploadError",
 316                                      base::StringValue("Not implemented"));
 317     return;
 318   }
 319
 320   if (trace_uploader_) {
 321     web_ui()->CallJavascriptFunction("onUploadError",
 322                                      base::StringValue("Upload in progress"));
 323     return;
 324   }
 325
 326   TraceUploader::UploadProgressCallback progress_callback =
 327       base::Bind(&TracingUI::OnTraceUploadProgress,
 328       weak_factory_.GetWeakPtr());
 329   TraceUploader::UploadDoneCallback done_callback =
 330       base::Bind(&TracingUI::OnTraceUploadComplete,
 331       weak_factory_.GetWeakPtr());
 332
 333   trace_uploader_ = delegate_->GetTraceUploader(
 334       web_ui()->GetWebContents()->GetBrowserContext()->GetRequestContext());
 335   DCHECK(trace_uploader_);
 336   trace_uploader_->DoUpload(file_contents, progress_callback, done_callback);
 337   // TODO(mmandlis): Add support for stopping the upload in progress.
 338 }
 339
 340 void TracingUI::OnTraceUploadProgress(int64 current, int64 total) {
 341   DCHECK(current <= total);
 342   int percent = (current / total) * 100;
 343   web_ui()->CallJavascriptFunction(
 344         "onUploadProgress",
 345         base::FundamentalValue(percent),
 346         base::StringValue(base::StringPrintf("%" PRId64, current)),
 347         base::StringValue(base::StringPrintf("%" PRId64, total)));
 348 }
 349
 350 void TracingUI::OnTraceUploadComplete(bool success,
 351                                       const std::string& feedback) {
 352   if (success) {
 353     web_ui()->CallJavascriptFunction("onUploadComplete",
 354                                      base::StringValue(feedback));
 355   } else {
 356     web_ui()->CallJavascriptFunction("onUploadError",
 357                                      base::StringValue(feedback));
 358   }
 359   trace_uploader_.reset();
 360 }
 361
 362 }  // namespace content