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

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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 55 matching lines @@
   virtual void RegisterMessages() OVERRIDE;
 
   // SelectFileDialog::Listener implementation
   virtual void FileSelected(const base::FilePath& path,
                             int index,
                             void* params) OVERRIDE;
   virtual void FileSelectionCanceled(void* params) OVERRIDE;
 
   // 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;
 
   // Messages.
   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);
   void OnGetKnownCategories(const base::ListValue* list);
 
   // Callbacks.
   void LoadTraceFileComplete(string16* file_contents,
                              const base::FilePath &path);
   void SaveTraceFileComplete();
 
  private:
   // The file dialog to select a file for loading or saving traces.
   scoped_refptr<ui::SelectFileDialog> select_trace_file_dialog_;
 
   // The type of the file dialog as the same one is used for loading or saving
   // traces.
   ui::SelectFileDialog::Type select_trace_file_dialog_type_;
 
   // The trace data that is to be written to the file on saving.
   scoped_ptr<std::string> trace_data_to_save_;
 
   // 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_;
 
   void OnEndSystemTracingAck(
       const scoped_refptr<base::RefCountedString>& events_str_ptr);
 
   DISALLOW_COPY_AND_ASSIGN(TracingMessageHandler);
 };
 
 // A proxy passed to the Read and Write tasks used when loading or saving trace
@@ skipping 26 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TracingMessageHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TracingMessageHandler::TracingMessageHandler()
     : select_trace_file_dialog_type_(ui::SelectFileDialog::SELECT_NONE),
       trace_enabled_(false),
+      continuous_sampling_trace_enabled_(false),
       system_trace_in_progress_(false) {
 }
 
 TracingMessageHandler::~TracingMessageHandler() {
   if (select_trace_file_dialog_.get())
     select_trace_file_dialog_->ListenerDestroyed();
 
   // If we are the current subscriber, this will result in ending tracing.
   TraceController::GetInstance()->CancelSubscriber(this);
 
@@ skipping 12 matching lines @@
 
   web_ui()->RegisterMessageCallback("tracingControllerInitialized",
       base::Bind(&TracingMessageHandler::OnTracingControllerInitialized,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("beginTracing",
       base::Bind(&TracingMessageHandler::OnBeginTracing,
                  base::Unretained(this)));
   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)));
   web_ui()->RegisterMessageCallback("loadTraceFile",
       base::Bind(&TracingMessageHandler::OnLoadTraceFile,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("saveTraceFile",
       base::Bind(&TracingMessageHandler::OnSaveTraceFile,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getKnownCategories",
@@ skipping 275 matching lines @@
     return;
 #endif
   }
 
   RenderViewHost* rvh = web_ui()->GetWebContents()->GetRenderViewHost();
   rvh->ExecuteJavascriptInWebFrame(string16(), UTF8ToUTF16(
       "tracingController.onEndTracingComplete(window.traceData);"
       "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));
 
   web_ui()->CallJavascriptFunction(
       "tracingController.onSystemTraceDataCollected",
       *scoped_ptr<base::Value>(new base::StringValue(events_str_ptr->data())));
   DCHECK(!system_trace_in_progress_);
 
   OnEndTracingComplete();
@@ skipping 10 matching lines @@
 
   // 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::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(
       "tracingController.onRequestBufferPercentFullComplete",
       *scoped_ptr<base::Value>(new base::FundamentalValue(percent_full)));
 }
 
 void TracingMessageHandler::OnGetKnownCategories(const base::ListValue* list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!TraceController::GetInstance()->GetKnownCategoryGroupsAsync(this)) {
@@ skipping 29 matching lines @@
 TracingUI::TracingUI(WebUI* web_ui) : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new TracingMessageHandler());
 
   // Set up the chrome://tracing/ source.
   BrowserContext* browser_context =
       web_ui->GetWebContents()->GetBrowserContext();
   WebUIDataSource::Add(browser_context, CreateTracingHTMLSource());
 }
 
 }  // namespace content