1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "components/tracing/child_trace_message_filter.h"
6
7#include "base/debug/trace_event.h"
8#include "base/message_loop/message_loop_proxy.h"
9#include "components/tracing/tracing_messages.h"
10#include "ipc/ipc_channel.h"
11
12using base::debug::TraceLog;
13
14namespace tracing {
15
16ChildTraceMessageFilter::ChildTraceMessageFilter(
17    base::MessageLoopProxy* ipc_message_loop)
18    : sender_(NULL),
19      ipc_message_loop_(ipc_message_loop) {}
20
21void ChildTraceMessageFilter::OnFilterAdded(IPC::Sender* sender) {
22  sender_ = sender;
23  sender_->Send(new TracingHostMsg_ChildSupportsTracing());
24}
25
26void ChildTraceMessageFilter::OnFilterRemoved() {
27  sender_ = NULL;
28}
29
30bool ChildTraceMessageFilter::OnMessageReceived(const IPC::Message& message) {
31  bool handled = true;
32  IPC_BEGIN_MESSAGE_MAP(ChildTraceMessageFilter, message)
33    IPC_MESSAGE_HANDLER(TracingMsg_BeginTracing, OnBeginTracing)
34    IPC_MESSAGE_HANDLER(TracingMsg_EndTracing, OnEndTracing)
35    IPC_MESSAGE_HANDLER(TracingMsg_EnableMonitoring, OnEnableMonitoring)
36    IPC_MESSAGE_HANDLER(TracingMsg_DisableMonitoring, OnDisableMonitoring)
37    IPC_MESSAGE_HANDLER(TracingMsg_CaptureMonitoringSnapshot,
38                        OnCaptureMonitoringSnapshot)
39    IPC_MESSAGE_HANDLER(TracingMsg_GetTraceBufferPercentFull,
40                        OnGetTraceBufferPercentFull)
41    IPC_MESSAGE_HANDLER(TracingMsg_SetWatchEvent, OnSetWatchEvent)
42    IPC_MESSAGE_HANDLER(TracingMsg_CancelWatchEvent, OnCancelWatchEvent)
43    IPC_MESSAGE_UNHANDLED(handled = false)
44  IPC_END_MESSAGE_MAP()
45  return handled;
46}
47
48ChildTraceMessageFilter::~ChildTraceMessageFilter() {}
49
50void ChildTraceMessageFilter::OnBeginTracing(
51    const std::string& category_filter_str,
52    base::TimeTicks browser_time,
53    const std::string& options) {
54#if defined(__native_client__)
55  // NaCl and system times are offset by a bit, so subtract some time from
56  // the captured timestamps. The value might be off by a bit due to messaging
57  // latency.
58  base::TimeDelta time_offset = base::TimeTicks::NowFromSystemTraceTime() -
59      browser_time;
60  TraceLog::GetInstance()->SetTimeOffset(time_offset);
61#endif
62  base::debug::TraceOptions trace_options;
63  trace_options.SetFromString(options);
64  TraceLog::GetInstance()->SetEnabled(
65      base::debug::CategoryFilter(category_filter_str),
66      base::debug::TraceLog::RECORDING_MODE,
67      trace_options);
68}
69
70void ChildTraceMessageFilter::OnEndTracing() {
71  TraceLog::GetInstance()->SetDisabled();
72
73  // Flush will generate one or more callbacks to OnTraceDataCollected
74  // synchronously or asynchronously. EndTracingAck will be sent in the last
75  // OnTraceDataCollected. We are already on the IO thread, so the
76  // OnTraceDataCollected calls will not be deferred.
77  TraceLog::GetInstance()->Flush(
78      base::Bind(&ChildTraceMessageFilter::OnTraceDataCollected, this));
79}
80
81void ChildTraceMessageFilter::OnEnableMonitoring(
82    const std::string& category_filter_str,
83    base::TimeTicks browser_time,
84    const std::string& options) {
85  base::debug::TraceOptions trace_options;
86  trace_options.SetFromString(options);
87  TraceLog::GetInstance()->SetEnabled(
88      base::debug::CategoryFilter(category_filter_str),
89      base::debug::TraceLog::MONITORING_MODE,
90      trace_options);
91}
92
93void ChildTraceMessageFilter::OnDisableMonitoring() {
94  TraceLog::GetInstance()->SetDisabled();
95}
96
97void ChildTraceMessageFilter::OnCaptureMonitoringSnapshot() {
98  // Flush will generate one or more callbacks to
99  // OnMonitoringTraceDataCollected. It's important that the last
100  // OnMonitoringTraceDataCollected gets called before
101  // CaptureMonitoringSnapshotAck below. We are already on the IO thread,
102  // so the OnMonitoringTraceDataCollected calls will not be deferred.
103  TraceLog::GetInstance()->FlushButLeaveBufferIntact(
104      base::Bind(&ChildTraceMessageFilter::OnMonitoringTraceDataCollected,
105                 this));
106}
107
108void ChildTraceMessageFilter::OnGetTraceBufferPercentFull() {
109  float bpf = TraceLog::GetInstance()->GetBufferPercentFull();
110
111  sender_->Send(new TracingHostMsg_TraceBufferPercentFullReply(bpf));
112}
113
114void ChildTraceMessageFilter::OnSetWatchEvent(const std::string& category_name,
115                                              const std::string& event_name) {
116  TraceLog::GetInstance()->SetWatchEvent(
117      category_name, event_name,
118      base::Bind(&ChildTraceMessageFilter::OnWatchEventMatched, this));
119}
120
121void ChildTraceMessageFilter::OnCancelWatchEvent() {
122  TraceLog::GetInstance()->CancelWatchEvent();
123}
124
125void ChildTraceMessageFilter::OnWatchEventMatched() {
126  if (!ipc_message_loop_->BelongsToCurrentThread()) {
127    ipc_message_loop_->PostTask(FROM_HERE,
128        base::Bind(&ChildTraceMessageFilter::OnWatchEventMatched, this));
129    return;
130  }
131  sender_->Send(new TracingHostMsg_WatchEventMatched);
132}
133
134void ChildTraceMessageFilter::OnTraceDataCollected(
135    const scoped_refptr<base::RefCountedString>& events_str_ptr,
136    bool has_more_events) {
137  if (!ipc_message_loop_->BelongsToCurrentThread()) {
138    ipc_message_loop_->PostTask(FROM_HERE,
139        base::Bind(&ChildTraceMessageFilter::OnTraceDataCollected, this,
140                   events_str_ptr, has_more_events));
141    return;
142  }
143  if (events_str_ptr->data().size()) {
144    sender_->Send(new TracingHostMsg_TraceDataCollected(
145        events_str_ptr->data()));
146  }
147  if (!has_more_events) {
148    std::vector<std::string> category_groups;
149    TraceLog::GetInstance()->GetKnownCategoryGroups(&category_groups);
150    sender_->Send(new TracingHostMsg_EndTracingAck(category_groups));
151  }
152}
153
154void ChildTraceMessageFilter::OnMonitoringTraceDataCollected(
155     const scoped_refptr<base::RefCountedString>& events_str_ptr,
156     bool has_more_events) {
157  if (!ipc_message_loop_->BelongsToCurrentThread()) {
158    ipc_message_loop_->PostTask(FROM_HERE,
159        base::Bind(&ChildTraceMessageFilter::
160                   OnMonitoringTraceDataCollected,
161                   this,
162                   events_str_ptr,
163                   has_more_events));
164    return;
165  }
166  sender_->Send(new TracingHostMsg_MonitoringTraceDataCollected(
167      events_str_ptr->data()));
168
169  if (!has_more_events)
170    sender_->Send(new TracingHostMsg_CaptureMonitoringSnapshotAck());
171}
172
173}  // namespace tracing
174