Implement about:tracing UI for the sampling profiler (Chromium part)

content/browser/tracing/tracing_ui.cc

Index: content/browser/tracing/tracing_ui.cc
diff --git a/content/browser/tracing/tracing_ui.cc b/content/browser/tracing/tracing_ui.cc
index aab652d5bf1f2dc3ae2886460b84a159fde202b0..9b49e70a30167c0ef2ebe5714548091e76679990 100644
--- a/content/browser/tracing/tracing_ui.cc
+++ b/content/browser/tracing/tracing_ui.cc
@@ -73,8 +73,11 @@ class TracingMessageHandler
 
   // TraceSubscriber implementation.
   virtual void OnEndTracingComplete() OVERRIDE;
+  virtual void OnShowContinuousSamplingTracingComplete() OVERRIDE;
   virtual void OnTraceDataCollected(
       const scoped_refptr<base::RefCountedString>& trace_fragment) OVERRIDE;
+  virtual void OnContinuousSamplingTraceDataCollected(
+      const scoped_refptr<base::RefCountedString>& trace_fragment) OVERRIDE;
   virtual void OnTraceBufferPercentFullReply(float percent_full) OVERRIDE;
   virtual void OnKnownCategoriesCollected(
       const std::set<std::string>& known_categories) OVERRIDE;
@@ -83,6 +86,9 @@ class TracingMessageHandler
   void OnTracingControllerInitialized(const base::ListValue* list);
   void OnBeginTracing(const base::ListValue* list);
   void OnEndTracingAsync(const base::ListValue* list);
+  void OnBeginContinuousSamplingTracing(const base::ListValue* list);
+  void OnEndContinuousSamplingTracing(const base::ListValue* list);
+  void OnShowContinuousSamplingTracingAsync(const base::ListValue* list);
   void OnBeginRequestBufferPercentFull(const base::ListValue* list);
   void OnLoadTraceFile(const base::ListValue* list);
   void OnSaveTraceFile(const base::ListValue* list);
@@ -107,6 +113,9 @@ class TracingMessageHandler
   // True while tracing is active.
   bool trace_enabled_;
 
+  // True while continuous sampling is active.
+  bool continuous_sampling_trace_enabled_;
+
   // True while system tracing is active.
   bool system_trace_in_progress_;
 
@@ -153,6 +162,7 @@ class TaskProxy : public base::RefCountedThreadSafe<TaskProxy> {
 TracingMessageHandler::TracingMessageHandler()
     : select_trace_file_dialog_type_(ui::SelectFileDialog::SELECT_NONE),
       trace_enabled_(false),
+      continuous_sampling_trace_enabled_(false),
       system_trace_in_progress_(false) {
 }
 
@@ -185,6 +195,15 @@ void TracingMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("endTracingAsync",
       base::Bind(&TracingMessageHandler::OnEndTracingAsync,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("beginContinuousSamplingTracing",
+      base::Bind(&TracingMessageHandler::OnBeginContinuousSamplingTracing,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("endContinuousSamplingTracing",
+      base::Bind(&TracingMessageHandler::OnEndContinuousSamplingTracing,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("showContinuousSamplingTracingAsync",
+      base::Bind(&TracingMessageHandler::OnShowContinuousSamplingTracingAsync,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback("beginRequestBufferPercentFull",
       base::Bind(&TracingMessageHandler::OnBeginRequestBufferPercentFull,
                  base::Unretained(this)));
@@ -480,6 +499,52 @@ void TracingMessageHandler::OnEndTracingComplete() {
       "delete window.traceData;"));
 }
 
+void TracingMessageHandler::OnBeginContinuousSamplingTracing(
+    const base::ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_EQ(args->GetSize(), (size_t) 0);
+
+  continuous_sampling_trace_enabled_ = true;
+  TraceController::GetInstance()->BeginContinuousSamplingTracing(this);
+}
+
+void TracingMessageHandler::OnEndContinuousSamplingTracing(
+    const base::ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_EQ(args->GetSize(), (size_t) 0);
+
+  continuous_sampling_trace_enabled_ = false;
+  TraceController::GetInstance()->EndContinuousSamplingTracing(this);
+}
+
+void TracingMessageHandler::OnShowContinuousSamplingTracingAsync(
+    const base::ListValue* list) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // When this function yields, we expect to get some number of
+  // OnContinuousSamplingTraceDataCollected callbacks, which will append data
+  // to window.continuousSamplingTraceData. To set up for this, set
+  // window.continuousSamplingTraceData to the empty string.
+  web_ui()->GetWebContents()->GetRenderViewHost()->
+    ExecuteJavascriptInWebFrame(string16(),
+        UTF8ToUTF16("window.continuousSamplingTraceData = '';"));
+
+  if (!TraceController::GetInstance()->ShowContinuousSamplingTracingAsync(
+          this)) {
+    OnShowContinuousSamplingTracingComplete();
+  }
+}
+
+void TracingMessageHandler::OnShowContinuousSamplingTracingComplete() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  RenderViewHost* rvh = web_ui()->GetWebContents()->GetRenderViewHost();
+  rvh->ExecuteJavascriptInWebFrame(string16(), UTF8ToUTF16(
+      "tracingController.onShowContinuousSamplingTracingComplete"
+      "(window.continuousSamplingTraceData);"
+      "delete window.continuousSamplingTraceData;"));
+}
+
 void TracingMessageHandler::OnEndSystemTracingAck(
     const scoped_refptr<base::RefCountedString>& events_str_ptr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ -510,6 +575,24 @@ void TracingMessageHandler::OnTraceDataCollected(
     ExecuteJavascriptInWebFrame(string16(), UTF8ToUTF16(javascript));
 }
 
+void TracingMessageHandler::OnContinuousSamplingTraceDataCollected(
+    const scoped_refptr<base::RefCountedString>& trace_fragment) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  std::string javascript;
+  javascript.reserve(trace_fragment->size() * 2);
+  javascript.append("window.continuousSamplingTraceData += \"");
+  base::JsonDoubleQuote(trace_fragment->data(), false, &javascript);
+
+  // Intentionally append a , to the traceData. This technically causes all
+  // traceData that we pass back to JS to end with a comma, but that is actually
+  // something the JS side strips away anyway
+  javascript.append(",\";");
+
+  web_ui()->GetWebContents()->GetRenderViewHost()->
+    ExecuteJavascriptInWebFrame(string16(), UTF8ToUTF16(javascript));
+}
+
 void TracingMessageHandler::OnTraceBufferPercentFullReply(float percent_full) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   web_ui()->CallJavascriptFunction(