Introduce gpu_trace_event for gpu performance analysis.

chrome/browser/ui/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/ui/webui/gpu_internals_ui.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 17 matching lines @@
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.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 "content/browser/browser_thread.h"
 #include "content/browser/gpu_process_host.h"
+#include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.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"
 
 namespace {
 
 class GpuHTMLSource : public ChromeURLDataManager::DataSource {
@@ skipping 20 matching lines @@
       public base::SupportsWeakPtr<GpuMessageHandler> {
  public:
   GpuMessageHandler();
   virtual ~GpuMessageHandler();
 
   // WebUIMessageHandler implementation.
   virtual WebUIMessageHandler* Attach(WebUI* web_ui);
   virtual void RegisterMessages();
 
   // Mesages
+  void OnBeginTracing(const ListValue* list);
+  void OnEndTracingAsync(const ListValue* list);
   void OnBrowserBridgeInitialized(const ListValue* list);
   void OnCallAsync(const ListValue* list);
 
   // Submessages dispatched from OnCallAsync
   Value* OnRequestClientInfo(const ListValue* list);
   Value* OnRequestLogMessages(const ListValue* list);
 
+  // Callbacks.
+  void OnTraceDataCollected(const std::string& json_events);
   void OnGpuInfoUpdate();
 
   // 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);
 
   // Cache the Singleton for efficiency.
   GpuDataManager* gpu_data_manager_;
 
+  void OnEndTracingComplete();
+
   Callback0::Type* gpu_info_update_callback_;
+
+  bool trace_enabled_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // 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() : gpu_info_update_callback_(NULL) {
+GpuMessageHandler::GpuMessageHandler()
+  : gpu_info_update_callback_(NULL)
+  , trace_enabled_(false) {
   gpu_data_manager_ = GpuDataManager::GetInstance();
   DCHECK(gpu_data_manager_);
 }
 
 GpuMessageHandler::~GpuMessageHandler() {
   if (gpu_info_update_callback_) {
     gpu_data_manager_->RemoveGpuInfoUpdateCallback(gpu_info_update_callback_);
     delete gpu_info_update_callback_;
   }
+
+  if (trace_enabled_)
+    OnEndTracingAsync(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));
 
   web_ui_->RegisterMessageCallback(
+      "beginTracing",
+      NewCallback(this, &GpuMessageHandler::OnBeginTracing));
+  web_ui_->RegisterMessageCallback(
+      "endTracingAsync",
+      NewCallback(this, &GpuMessageHandler::OnEndTracingAsync));
+  web_ui_->RegisterMessageCallback(
       "browserBridgeInitialized",
       NewCallback(this, &GpuMessageHandler::OnBrowserBridgeInitialized));
   web_ui_->RegisterMessageCallback(
       "callAsync",
       NewCallback(this, &GpuMessageHandler::OnCallAsync));
 }
 
 void GpuMessageHandler::OnCallAsync(const ListValue* args) {
   DCHECK_GE(args->GetSize(), static_cast<size_t>(2));
   // unpack args into requestId, submessage and submessageArgs
@@ skipping 184 matching lines @@
   if (blacklisting_reasons)
     gpu_info_val->Set("blacklistingReasons", blacklisting_reasons);
 
   // Send GPU Info to javascript.
   web_ui_->CallJavascriptFunction("browserBridge.onGpuInfoUpdate",
       *gpu_info_val);
 
   delete gpu_info_val;
 }
 
+void GpuMessageHandler::OnBeginTracing(const ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  trace_enabled_ = true;
+  // TODO(jbates): TracingController::BeginTracing()
+}
+
+void GpuMessageHandler::OnEndTracingAsync(const ListValue* list) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(traceEnabled_);
+
+  // TODO(jbates): TracingController::OnEndTracingAsync(new
+  // Callback(this, GpuMessageHandler::OnEndTracingComplete))
+}
+
+void GpuMessageHandler::OnEndTracingComplete() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  traceEnabled_ = false;
+  web_ui_->CallJavascriptFunction("tracingController.onEndTracingComplete");
+}
+
+void GpuMessageHandler::OnTraceDataCollected(const std::string& json_events) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  std::wstring javascript;
+  javascript += L"tracingController.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);
 }
-