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/devtools/devtools_tracing_handler.h"
6
7#include <cmath>
8
9#include "base/bind.h"
10#include "base/debug/trace_event_impl.h"
11#include "base/strings/string_split.h"
12#include "base/strings/stringprintf.h"
13#include "base/time/time.h"
14#include "base/timer/timer.h"
15#include "base/values.h"
16#include "content/browser/devtools/devtools_http_handler_impl.h"
17#include "content/browser/devtools/devtools_protocol_constants.h"
18#include "content/public/browser/browser_thread.h"
19#include "content/public/browser/tracing_controller.h"
20
21namespace content {
22
23namespace {
24
25const char kRecordUntilFull[]   = "record-until-full";
26const char kRecordContinuously[] = "record-continuously";
27const char kRecordAsMuchAsPossible[] = "record-as-much-as-possible";
28const char kEnableSampling[] = "enable-sampling";
29
30class DevToolsTraceSinkProxy : public TracingController::TraceDataSink {
31 public:
32  explicit DevToolsTraceSinkProxy(base::WeakPtr<DevToolsTracingHandler> handler)
33      : tracing_handler_(handler) {}
34
35  virtual void AddTraceChunk(const std::string& chunk) OVERRIDE {
36    if (DevToolsTracingHandler* h = tracing_handler_.get())
37      h->OnTraceDataCollected(chunk);
38  }
39  virtual void Close() OVERRIDE {
40    if (DevToolsTracingHandler* h = tracing_handler_.get())
41      h->OnTraceComplete();
42  }
43
44 private:
45  virtual ~DevToolsTraceSinkProxy() {}
46
47  base::WeakPtr<DevToolsTracingHandler> tracing_handler_;
48};
49
50}  // namespace
51
52const char* DevToolsTracingHandler::kDefaultCategories =
53    "-*,disabled-by-default-devtools.timeline*";
54const double DevToolsTracingHandler::kDefaultReportingInterval = 1000.0;
55const double DevToolsTracingHandler::kMinimumReportingInterval = 250.0;
56
57DevToolsTracingHandler::DevToolsTracingHandler(
58    DevToolsTracingHandler::Target target)
59    : target_(target), is_recording_(false), weak_factory_(this) {
60  RegisterCommandHandler(devtools::Tracing::start::kName,
61                         base::Bind(&DevToolsTracingHandler::OnStart,
62                                    base::Unretained(this)));
63  RegisterCommandHandler(devtools::Tracing::end::kName,
64                         base::Bind(&DevToolsTracingHandler::OnEnd,
65                                    base::Unretained(this)));
66  RegisterCommandHandler(devtools::Tracing::getCategories::kName,
67                         base::Bind(&DevToolsTracingHandler::OnGetCategories,
68                                    base::Unretained(this)));
69}
70
71DevToolsTracingHandler::~DevToolsTracingHandler() {
72}
73
74void DevToolsTracingHandler::OnTraceDataCollected(
75    const std::string& trace_fragment) {
76  // Hand-craft protocol notification message so we can substitute JSON
77  // that we already got as string as a bare object, not a quoted string.
78  std::string message =
79      base::StringPrintf("{ \"method\": \"%s\", \"params\": { \"%s\": [",
80                         devtools::Tracing::dataCollected::kName,
81                         devtools::Tracing::dataCollected::kParamValue);
82  const size_t messageSuffixSize = 10;
83  message.reserve(message.size() + trace_fragment.size() + messageSuffixSize);
84  message += trace_fragment;
85  message += "] } }", SendRawMessage(message);
86}
87
88void DevToolsTracingHandler::OnTraceComplete() {
89  SendNotification(devtools::Tracing::tracingComplete::kName, NULL);
90}
91
92base::debug::TraceOptions DevToolsTracingHandler::TraceOptionsFromString(
93    const std::string& options) {
94  std::vector<std::string> split;
95  std::vector<std::string>::iterator iter;
96  base::debug::TraceOptions ret;
97
98  base::SplitString(options, ',', &split);
99  for (iter = split.begin(); iter != split.end(); ++iter) {
100    if (*iter == kRecordUntilFull) {
101      ret.record_mode = base::debug::RECORD_UNTIL_FULL;
102    } else if (*iter == kRecordContinuously) {
103      ret.record_mode = base::debug::RECORD_CONTINUOUSLY;
104    } else if (*iter == kRecordAsMuchAsPossible) {
105      ret.record_mode = base::debug::RECORD_AS_MUCH_AS_POSSIBLE;
106    } else if (*iter == kEnableSampling) {
107      ret.enable_sampling = true;
108    }
109  }
110  return ret;
111}
112
113scoped_refptr<DevToolsProtocol::Response>
114DevToolsTracingHandler::OnStart(
115    scoped_refptr<DevToolsProtocol::Command> command) {
116  if (is_recording_) {
117    return command->InternalErrorResponse("Tracing is already started");
118  }
119  is_recording_ = true;
120
121  std::string categories;
122  base::debug::TraceOptions options;
123  double usage_reporting_interval = 0.0;
124
125  base::DictionaryValue* params = command->params();
126  if (params) {
127    params->GetString(devtools::Tracing::start::kParamCategories, &categories);
128    std::string options_param;
129    if (params->GetString(devtools::Tracing::start::kParamOptions,
130                          &options_param)) {
131      options = TraceOptionsFromString(options_param);
132    }
133    params->GetDouble(
134        devtools::Tracing::start::kParamBufferUsageReportingInterval,
135        &usage_reporting_interval);
136  }
137
138  SetupTimer(usage_reporting_interval);
139
140  // If inspected target is a render process Tracing.start will be handled by
141  // tracing agent in the renderer.
142  if (target_ == Renderer) {
143    TracingController::GetInstance()->EnableRecording(
144        base::debug::CategoryFilter(categories),
145        options,
146        TracingController::EnableRecordingDoneCallback());
147    return NULL;
148  }
149
150  TracingController::GetInstance()->EnableRecording(
151      base::debug::CategoryFilter(categories),
152      options,
153      base::Bind(&DevToolsTracingHandler::OnRecordingEnabled,
154                 weak_factory_.GetWeakPtr(),
155                 command));
156  return command->AsyncResponsePromise();
157}
158
159void DevToolsTracingHandler::SetupTimer(double usage_reporting_interval) {
160  if (usage_reporting_interval == 0) return;
161
162  if (usage_reporting_interval < kMinimumReportingInterval)
163      usage_reporting_interval = kMinimumReportingInterval;
164
165  base::TimeDelta interval = base::TimeDelta::FromMilliseconds(
166      std::ceil(usage_reporting_interval));
167  buffer_usage_poll_timer_.reset(new base::Timer(
168      FROM_HERE,
169      interval,
170      base::Bind(
171          base::IgnoreResult(&TracingController::GetTraceBufferPercentFull),
172          base::Unretained(TracingController::GetInstance()),
173          base::Bind(&DevToolsTracingHandler::OnBufferUsage,
174                     weak_factory_.GetWeakPtr())),
175      true));
176  buffer_usage_poll_timer_->Reset();
177}
178
179void DevToolsTracingHandler::OnRecordingEnabled(
180    scoped_refptr<DevToolsProtocol::Command> command) {
181  SendAsyncResponse(command->SuccessResponse(NULL));
182}
183
184void DevToolsTracingHandler::OnBufferUsage(float usage) {
185  base::DictionaryValue* params = new base::DictionaryValue();
186  params->SetDouble(devtools::Tracing::bufferUsage::kParamValue, usage);
187  SendNotification(devtools::Tracing::bufferUsage::kName, params);
188}
189
190scoped_refptr<DevToolsProtocol::Response>
191DevToolsTracingHandler::OnEnd(
192    scoped_refptr<DevToolsProtocol::Command> command) {
193  if (!is_recording_) {
194    return command->InternalErrorResponse("Tracing is not started");
195  }
196  DisableRecording(false);
197  // If inspected target is a render process Tracing.end will be handled by
198  // tracing agent in the renderer.
199  if (target_ == Renderer)
200    return NULL;
201  return command->SuccessResponse(NULL);
202}
203
204void DevToolsTracingHandler::DisableRecording(bool abort) {
205  is_recording_ = false;
206  buffer_usage_poll_timer_.reset();
207  TracingController::GetInstance()->DisableRecording(
208      abort ? NULL : new DevToolsTraceSinkProxy(weak_factory_.GetWeakPtr()));
209}
210
211void DevToolsTracingHandler::OnClientDetached() {
212  if (is_recording_)
213    DisableRecording(true);
214}
215
216scoped_refptr<DevToolsProtocol::Response>
217DevToolsTracingHandler::OnGetCategories(
218    scoped_refptr<DevToolsProtocol::Command> command) {
219  TracingController::GetInstance()->GetCategories(
220      base::Bind(&DevToolsTracingHandler::OnCategoriesReceived,
221                 weak_factory_.GetWeakPtr(),
222                 command));
223  return command->AsyncResponsePromise();
224}
225
226void DevToolsTracingHandler::OnCategoriesReceived(
227    scoped_refptr<DevToolsProtocol::Command> command,
228    const std::set<std::string>& category_set) {
229  base::DictionaryValue* response = new base::DictionaryValue;
230  base::ListValue* category_list = new base::ListValue;
231  for (std::set<std::string>::const_iterator it = category_set.begin();
232       it != category_set.end(); ++it) {
233    category_list->AppendString(*it);
234  }
235
236  response->Set(devtools::Tracing::getCategories::kResponseCategories,
237                category_list);
238  SendAsyncResponse(command->SuccessResponse(response));
239}
240
241}  // namespace content
242