Add tracing events to track sync ipc blocker

ipc/ipc_sync_channel.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 "ipc/ipc_sync_channel.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 299 matching lines @@
   }
 
   if (!msg->is_reply_error()) {
     bool send_result = deserializers_.back().deserializer->
         SerializeOutputParameters(*msg);
     deserializers_.back().send_result = send_result;
     DVLOG_IF(1, !send_result) << "Couldn't deserialize reply message";
   } else {
     DVLOG(1) << "Received error reply";
   }
-  deserializers_.back().done_event->Signal();
+
+  base::WaitableEvent* done_event = deserializers_.back().done_event;
+  TRACE_EVENT_FLOW_BEGIN0(
+      TRACE_DISABLED_BY_DEFAULT("ipc.flow"),
+      "SyncChannel::SyncContext::TryToUnblockListener", done_event);
+
+  done_event->Signal();
 
   return true;
 }
 
 void SyncChannel::SyncContext::Clear() {
   CancelPendingSends();
   received_sync_msgs_->RemoveContext(this);
   Context::Clear();
 }
 
@@ skipping 31 matching lines @@
                  base::Unretained(this)));
   Context::OnChannelOpened();
 }
 
 void SyncChannel::SyncContext::OnChannelClosed() {
   CancelPendingSends();
   shutdown_watcher_.StopWatching();
   Context::OnChannelClosed();
 }
 
-void SyncChannel::SyncContext::OnSendTimeout(int message_id) {
-  base::AutoLock auto_lock(deserializers_lock_);
-  PendingSyncMessageQueue::iterator iter;
-  DVLOG(1) << "Send timeout";
-  for (iter = deserializers_.begin(); iter != deserializers_.end(); iter++) {
-    if (iter->id == message_id) {
-      iter->done_event->Signal();
-      break;
-    }
-  }
-}
-
 void SyncChannel::SyncContext::CancelPendingSends() {
   base::AutoLock auto_lock(deserializers_lock_);
   PendingSyncMessageQueue::iterator iter;
   DVLOG(1) << "Canceling pending sends";
-  for (iter = deserializers_.begin(); iter != deserializers_.end(); iter++)
+  for (iter = deserializers_.begin(); iter != deserializers_.end(); iter++) {
+    TRACE_EVENT_FLOW_BEGIN0(TRACE_DISABLED_BY_DEFAULT("ipc.flow"),
+                            "SyncChannel::SyncContext::CancelPendingSends",
+                            iter->done_event);
     iter->done_event->Signal();
+  }
 }
 
 void SyncChannel::SyncContext::OnWaitableEventSignaled(WaitableEvent* event) {
   if (event == shutdown_event_) {
     // Process shut down before we can get a reply to a synchronous message.
     // Cancel pending Send calls, which will end up setting the send done event.
     CancelPendingSends();
   } else {
     // We got the reply, timed out or the process shutdown.
     DCHECK_EQ(GetSendDoneEvent(), event);
@@ skipping 96 matching lines @@
   SyncMessage* sync_msg = static_cast<SyncMessage*>(message);
   context->Push(sync_msg);
   WaitableEvent* pump_messages_event = sync_msg->pump_messages_event();
 
   ChannelProxy::Send(message);
 
   // Wait for reply, or for any other incoming synchronous messages.
   // *this* might get deleted, so only call static functions at this point.
   WaitForReply(context.get(), pump_messages_event);
 
+  TRACE_EVENT_FLOW_END0(TRACE_DISABLED_BY_DEFAULT("ipc.flow"),
+                        "SyncChannel::Send", context->GetSendDoneEvent());
+
   return context->Pop();
 }
 
 void SyncChannel::WaitForReply(
     SyncContext* context, WaitableEvent* pump_messages_event) {
   context->DispatchMessages();
   while (true) {
     WaitableEvent* objects[] = {
       context->GetDispatchEvent(),
       context->GetSendDoneEvent(),
@@ skipping 80 matching lines @@
 
 void SyncChannel::OnChannelInit() {
   for (const auto& filter : pre_init_sync_message_filters_) {
     filter->set_is_channel_send_thread_safe(
         context()->IsChannelSendThreadSafe());
   }
   pre_init_sync_message_filters_.clear();
 }
 
 }  // namespace IPC