Telemetry / Devtools TraceHandler: exposes tracing via dev tools.

content/browser/debugger/devtools_trace_domain_handler.cc

Index: content/browser/debugger/devtools_trace_domain_handler.cc
diff --git a/content/browser/debugger/devtools_trace_domain_handler.cc b/content/browser/debugger/devtools_trace_domain_handler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c9a71d10fbacfd306b92b32a9665e3e7cb3dc3c7
--- /dev/null
+++ b/content/browser/debugger/devtools_trace_domain_handler.cc
@@ -0,0 +1,94 @@
+// 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/debugger/devtools_trace_domain_handler.h"
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/location.h"
+#include "base/values.h"
+#include "content/browser/debugger/devtools_http_handler_impl.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/trace_controller.h"
+#include "content/public/browser/trace_subscriber.h"
+
+namespace content {
+
+DevToolsTraceDomainHandler::DevToolsTraceDomainHandler()

[pfeldman, 2012/12/14 10:39:33]

I think it should be called *TracingHandler

[bulach, 2012/12/14 16:03:52]

Done.

+    : has_completed_(false) {
+}
+
+DevToolsTraceDomainHandler::~DevToolsTraceDomainHandler() {
+}
+
+void DevToolsTraceDomainHandler::OnEndTracingComplete() {
+  has_completed_ = true;
+}
+
+void DevToolsTraceDomainHandler::OnTraceDataCollected(
+    const scoped_refptr<base::RefCountedString>& trace_fragment) {
+  if (!buffer_.empty())
+    buffer_.append(",");
+  buffer_.append(trace_fragment->data());

[pfeldman, 2012/12/14 10:39:33]

nit: You might want to store them in a vector of strings for the efficiency?

[bulach, 2012/12/14 16:03:52]

good point. although it requires more memory when copying it out, it's more
efficient for collection indeed. done.

+}
+
+base::Value* DevToolsTraceDomainHandler::OnProtocolCommand(
+    int connection_id,

[pfeldman, 2012/12/14 10:39:33]

So no connection_id, no request_id usage here!

[bulach, 2012/12/14 16:03:52]

Done.

+    int request_id,
+    const std::string& method,
+    const base::DictionaryValue* params) {
+  if (method == "Trace.BeginTracing")

[pfeldman, 2012/12/14 10:39:33]

Tracing.start / end

[bulach, 2012/12/14 16:03:52]

Done.

+    return BeginTracing(params);
+  else if (method == "Trace.EndTracingAsync")
+    return EndTracingAsync(params);
+  else if (method == "Trace.HasCompleted")
+    return HasCompleted(params);

[pfeldman, 2012/12/14 10:39:33]

Why would you need this one? We typically rely upon clients holding consistent
state.

[bulach, 2012/12/14 16:03:52]

the trouble is that the stop is asynchronous, so better to have the client check
for completion..

[pfeldman, 2012/12/14 18:35:05]

So are you saying that you will poll for hasCompleted? It does not sound right.
Remote debugging protocol has notifications for that. So, for example, if you
want to send entire trace after every "Tracing.end" call, you simply send a
notification (like
https://developers.google.com/chrome-developer-tools/docs/protocol/1.0/dom#ev...)
from within OnEndTracingComplete (what thread is it called on btw?).

Notifications are simply commands with no requestIds. Unfortunately, it will
require you to push server sink into the handler. That sink would need to check
for connection being asynchronously closed / server shut down.

Now I remember you had something like that and I made you remove it. I did not
pay attention to the fact that you already need notifications and now I feel
sorry. So I am suggesting that I do it for you in a subsequent patch in order to
not put much stress on you. But you will need to help me updating the telemetry
client.

+  else if (method == "Trace.GetAndResetTrace")

[pfeldman, 2012/12/14 10:39:33]

Tracing.getTraceAndReset ?

[bulach, 2012/12/14 16:03:52]

Done.

+    return GetAndResetTrace(params);
+  return NULL;
+}
+
+
+base::Value* DevToolsTraceDomainHandler::BeginTracing(
+    const base::DictionaryValue* params) {
+  std::string categories;
+  if (params && params->HasKey("categories"))
+    params->GetString("categories", &categories);
+  TraceController::GetInstance()->BeginTracing(this, categories);
+
+  DictionaryValue* response = new DictionaryValue();
+  response->Set("result", base::Value::CreateBooleanValue(true));
+  return response;

[pfeldman, 2012/12/14 10:39:33]

I think you want to return base::Value::CreateBooleanValue(true) here and wrap
it with the result on the caller side. Otherwise same code all over the place.

[bulach, 2012/12/14 16:03:52]

yeah, I was originally thinking this level could potentially return objects with
errors, but it doesn't seem to be the case..

+}
+
+base::Value* DevToolsTraceDomainHandler::EndTracingAsync(
+    const base::DictionaryValue* /* params */) {
+  TraceController::GetInstance()->EndTracingAsync(this);
+
+  DictionaryValue* response = new DictionaryValue();
+  response->Set("result", base::Value::CreateBooleanValue(true));
+  return response;
+}
+
+
+base::Value* DevToolsTraceDomainHandler::HasCompleted(

[pfeldman, 2012/12/14 10:39:33]

I don't think you need this.

[bulach, 2012/12/14 16:03:52]

as above, line 67 is async, so we need some mechanism to know when to actually
fetch the data..

+    const base::DictionaryValue* /* params */) {
+
+  DictionaryValue* response = new DictionaryValue();
+  response->Set("result", base::Value::CreateBooleanValue(has_completed_));
+  return response;
+}
+
+base::Value* DevToolsTraceDomainHandler::GetAndResetTrace(
+    const base::DictionaryValue* /* params */) {
+  std::string ret(buffer_);
+  buffer_.clear();
+  has_completed_ = false;
+
+  DictionaryValue* response = new DictionaryValue();
+  response->Set("result", base::Value::CreateStringValue(ret));
+  return response;
+}
+
+}  // namespace content