Add tracing support to NaCl

content/browser/trace_message_filter.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/trace_message_filter.h"
 
 #include "content/browser/trace_controller_impl.h"
-#include "content/common/child_process_messages.h"
+#include "content/components/tracing/tracing_messages.h"
 
 namespace content {
 
 TraceMessageFilter::TraceMessageFilter() :
     has_child_(false),
     is_awaiting_end_ack_(false),
     is_awaiting_buffer_percent_full_ack_(false) {
 }
 
 void TraceMessageFilter::OnFilterAdded(IPC::Channel* channel) {
@@ skipping 14 matching lines @@
 
     TraceControllerImpl::GetInstance()->RemoveFilter(this);
   }
 }
 
 bool TraceMessageFilter::OnMessageReceived(const IPC::Message& message,
                                            bool* message_was_ok) {
   // Always on IO thread (BrowserMessageFilter guarantee).
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(TraceMessageFilter, message, *message_was_ok)
-    IPC_MESSAGE_HANDLER(ChildProcessHostMsg_ChildSupportsTracing,
+    IPC_MESSAGE_HANDLER(TracingHostMsg_ChildSupportsTracing,
                         OnChildSupportsTracing)
-    IPC_MESSAGE_HANDLER(ChildProcessHostMsg_EndTracingAck, OnEndTracingAck)
-    IPC_MESSAGE_HANDLER(ChildProcessHostMsg_TraceDataCollected,
+    IPC_MESSAGE_HANDLER(TracingHostMsg_EndTracingAck, OnEndTracingAck)
+    IPC_MESSAGE_HANDLER(TracingHostMsg_TraceDataCollected,
                         OnTraceDataCollected)
-    IPC_MESSAGE_HANDLER(ChildProcessHostMsg_TraceNotification,
+    IPC_MESSAGE_HANDLER(TracingHostMsg_TraceNotification,
                         OnTraceNotification)
-    IPC_MESSAGE_HANDLER(ChildProcessHostMsg_TraceBufferPercentFullReply,
+    IPC_MESSAGE_HANDLER(TracingHostMsg_TraceBufferPercentFullReply,
                         OnTraceBufferPercentFullReply)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
 void TraceMessageFilter::SendBeginTracing(
     const std::vector<std::string>& included_categories,
     const std::vector<std::string>& excluded_categories) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  Send(new ChildProcessMsg_BeginTracing(included_categories,
-                                        excluded_categories));
+  Send(new TracingMsg_BeginTracing(included_categories,
+                                   excluded_categories,
+                                   base::TimeTicks::NowFromSystemTraceTime()));
 }
 
 void TraceMessageFilter::SendEndTracing() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!is_awaiting_end_ack_);
   is_awaiting_end_ack_ = true;
-  Send(new ChildProcessMsg_EndTracing);
+  Send(new TracingMsg_EndTracing);
 }
 
 void TraceMessageFilter::SendGetTraceBufferPercentFull() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!is_awaiting_buffer_percent_full_ack_);
   is_awaiting_buffer_percent_full_ack_ = true;
-  Send(new ChildProcessMsg_GetTraceBufferPercentFull);
+  Send(new TracingMsg_GetTraceBufferPercentFull);
 }
 
 void TraceMessageFilter::SendSetWatchEvent(const std::string& category_name,
                                            const std::string& event_name) {
-  Send(new ChildProcessMsg_SetWatchEvent(category_name, event_name));
+  Send(new TracingMsg_SetWatchEvent(category_name, event_name));
 }
 
 void TraceMessageFilter::SendCancelWatchEvent() {
-  Send(new ChildProcessMsg_CancelWatchEvent);
+  Send(new TracingMsg_CancelWatchEvent);
 }
 
 TraceMessageFilter::~TraceMessageFilter() {}
 
 void TraceMessageFilter::OnChildSupportsTracing() {
   has_child_ = true;
   TraceControllerImpl::GetInstance()->AddFilter(this);
 }
 
 void TraceMessageFilter::OnEndTracingAck(
@@ skipping 22 matching lines @@
   if (is_awaiting_buffer_percent_full_ack_) {
     is_awaiting_buffer_percent_full_ack_ = false;
     TraceControllerImpl::GetInstance()->OnTraceBufferPercentFullReply(
         percent_full);
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace content