Trace_event upgrades

chrome/browser/webui/gpu_internals_ui.cc

 // Copyright (c) 2011 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 "chrome/browser/webui/gpu_internals_ui.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/singleton.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "base/debug/trace_event.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/dom_ui/chrome_url_data_manager.h"
 #include "chrome/browser/gpu_process_host.h"
 #include "chrome/browser/gpu_process_host_ui_shim.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/connection_tester.h"
 #include "chrome/browser/net/passive_log_collector.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/browser/renderer_host/render_process_host.h"
+#include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #include "chrome/common/url_constants.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 25 matching lines @@
  public:
   GpuMessageHandler();
   virtual ~GpuMessageHandler();
 
   // WebUIMessageHandler implementation.
   virtual WebUIMessageHandler* Attach(WebUI* web_ui);
   virtual void RegisterMessages();
 
   // Mesages
   void OnCallAsync(const ListValue* list);
+  void OnBeginTracing(const ListValue* list);
+  void OnBeginToEndTracing(const ListValue* list);
 
   // Submessages dispatched from OnCallAsync
   Value* OnRequestGpuInfo(const ListValue* list);
   Value* OnRequestClientInfo(const ListValue* list);
   Value* OnRequestLogMessages(const ListValue* list);
 
+  // Callbacks from GpuTrace or ChildProcessHosts
+  void OnTraceDataCollected(const std::string& json_events);
+
   // Executes the javascript function |function_name| in the renderer, passing
   // it the argument |value|.
   void CallJavascriptFunction(const std::wstring& function_name,
                               const Value* value);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GpuMessageHandler);
+
+  void OnEndTracingComplete();
+  friend class TaskProxy;
+
+  bool traceEnabled_;
+  int traceNumEndAcksPending_;
+};
+
+class TaskProxy : public base::RefCountedThreadSafe<TaskProxy> {
+ public:
+  TaskProxy(const base::WeakPtr<GpuMessageHandler>& handler)
+    : handler_(handler) {}
+  void OnEndTracingCompleteProxy() {
+    if(handler_) {
+      handler_->OnEndTracingComplete();
+    }
+  }
+ private:
+  base::WeakPtr<GpuMessageHandler> handler_;
+  friend class base::RefCountedThreadSafe<TaskProxy>;
+  DISALLOW_COPY_AND_ASSIGN(TaskProxy);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // GpuHTMLSource
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 GpuHTMLSource::GpuHTMLSource()
     : DataSource(chrome::kChromeUIGpuInternalsHost, MessageLoop::current()) {
@@ skipping 25 matching lines @@
 std::string GpuHTMLSource::GetMimeType(const std::string&) const {
   return "text/html";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // GpuMessageHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-GpuMessageHandler::GpuMessageHandler() {
+GpuMessageHandler::GpuMessageHandler()
+  : traceEnabled_(false)
+  , traceNumEndAcksPending_(0) {
+
 }
 
-GpuMessageHandler::~GpuMessageHandler() {}
+GpuMessageHandler::~GpuMessageHandler() {
+  if (traceEnabled_) {
+    OnBeginToEndTracing(NULL);
+  }
+}
 
 WebUIMessageHandler* GpuMessageHandler::Attach(WebUI* web_ui) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   WebUIMessageHandler* result = WebUIMessageHandler::Attach(web_ui);
   return result;
 }
 
 /* BrowserBridge.callAsync prepends a requestID to these messages. */
 void GpuMessageHandler::RegisterMessages() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 193 matching lines @@
   } else {
     return NULL;
   }
 }
 
 Value* GpuMessageHandler::OnRequestLogMessages(const ListValue*) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return GpuProcessHostUIShim::GetInstance()->logMessages();
 }
 
+void GpuMessageHandler::OnBeginTracing(const ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  traceEnabled_ = true;
+  base::debug::TraceLog::GetInstance()->SetOutputCallback(NewCallback(this,
+      &GpuMessageHandler::OnTraceDataCollected));
+  base::debug::TraceLog::GetInstance()->SetEnabled(true);
+  GpuProcessHostUIShim::GetInstance()->SetTraceEnabled(true);
+  RenderProcessHost::SetTraceEnabled(true);
+}
+
+void GpuMessageHandler::OnBeginToEndTracing(const ListValue* list) {
+  DCHECK(traceEnabled_ && !traceNumEndAcksPending_);
+
+  // To end GPU tracing, we have to end tracing on every child process
+  // and get their ack that we've recieved that data. We do this by
+  // tracking the number of ack's we're expecting.  When this number
+  // goes to zero, we know we're done.  The TRACE_ENDED ack arrives as a
+  // JSON object in the OnTraceDataCollectedAsJSON.
+  traceNumEndAcksPending_ = 1;
+  GpuProcessHostUIShim::GetInstance()->SetTraceEnabled(false);
+
+  traceNumEndAcksPending_ +=
+    RenderProcessHost::SetTraceEnabled(false);
+}
+
+void GpuMessageHandler::OnEndTracingComplete() {
+  // TODO(nduca): disable renderer processes, too
+  base::debug::TraceLog::GetInstance()->SetEnabled(false);
+  base::debug::TraceLog::GetInstance()->SetOutputCallback(NULL);
+  traceEnabled_ = false;
+  web_ui_->CallJavascriptFunction(L"tracingControl.onEndTracingComplete");
+}
+
+void GpuMessageHandler::OnTraceDataCollected(const std::string& json_events) {
+  DCHECK(traceEnabled_);
+  const char* json_complete = "['TRACE_ENDED']";
+  if(json_events == json_complete) {
+    DCHECK(traceNumEndAcksPending_);
+    traceNumEndAcksPending_ -= 1;
+    if(traceNumEndAcksPending_ == 0) {
+      TaskProxy* task = new TaskProxy(AsWeakPtr());
+      task->AddRef();
+
+      BrowserThread::PostTask(
+          BrowserThread::FILE, FROM_HERE,
+          NewRunnableMethod(
+              task, &TaskProxy::OnEndTracingCompleteProxy));
+    }
+  } else {
+
+    std::wstring javascript;
+    javascript += L"tracingControl.onTraceDataCollected(";
+    javascript += UTF8ToWide(json_events);
+    javascript += L");";
+
+    web_ui_->GetRenderViewHost()->ExecuteJavascriptInWebFrame(string16(),
+        WideToUTF16Hack(javascript));
+  }
+}
+
+
+
 }  // namespace
 
 
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // GpuInternalsUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 GpuInternalsUI::GpuInternalsUI(TabContents* contents) : WebUI(contents) {
   AddMessageHandler((new GpuMessageHandler())->Attach(this));
 
   GpuHTMLSource* html_source = new GpuHTMLSource();
 
   // Set up the chrome://gpu/ source.
   contents->profile()->GetChromeURLDataManager()->AddDataSource(html_source);
 }