Enable verbose logging during PluginMsg_CreateInstance.

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 "base/bind.h"
+#include "base/debug/stack_trace.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/synchronization/waitable_event_watcher.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
 #include "ipc/ipc_sync_message.h"
 
 using base::TimeDelta;
@@ skipping 282 matching lines @@
       !SyncMessage::IsMessageReplyTo(*msg, deserializers_.back().id)) {
     return false;
   }
 
   // TODO(bauerb): Remove logging once investigation of http://crbug.com/141055
   // has finished.
   if (!msg->is_reply_error()) {
     bool send_result = deserializers_.back().deserializer->
         SerializeOutputParameters(*msg);
     deserializers_.back().send_result = send_result;
-    LOG_IF(ERROR, !send_result) << "Couldn't deserialize reply message";
+    VLOG_IF(1, !send_result) << "Couldn't deserialize reply message";
   } else {
-    LOG(ERROR) << "Received error reply";
+    VLOG(1) << "Received error reply";
   }
   deserializers_.back().done_event->Signal();
 
   return true;
 }
 
 void SyncChannel::SyncContext::Clear() {
   CancelPendingSends();
   received_sync_msgs_->RemoveContext(this);
   Context::Clear();
@@ skipping 33 matching lines @@
 
 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;
-  LOG(ERROR) << "Send timeout";
+  VLOG(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;
-  LOG(ERROR) << "Canceling pending sends";
+#if !defined(OS_ANDROID) && !defined(OS_NACL)

[piman, 2012/08/16 17:57:10]

Can you add a reference to that bug here too?

[Bernhard Bauer, 2012/08/16 19:14:18]

Done.

+  if (VLOG_IS_ON(1)) {
+    VLOG(1) << "Canceling pending sends";
+    base::debug::StackTrace trace;
+    trace.PrintBacktrace();
+  }
+#endif
   for (iter = deserializers_.begin(); iter != deserializers_.end(); iter++)
     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 {
@@ skipping 39 matching lines @@
 
 bool SyncChannel::SendWithTimeout(Message* message, int timeout_ms) {
   if (!message->is_sync()) {
     ChannelProxy::Send(message);
     return true;
   }
 
   // *this* might get deleted in WaitForReply.
   scoped_refptr<SyncContext> context(sync_context());
   if (context->shutdown_event()->IsSignaled()) {
-    LOG(ERROR) << "shutdown event is signaled";
+    VLOG(1) << "shutdown event is signaled";
     delete message;
     return false;
   }
 
   DCHECK(sync_messages_with_no_timeout_allowed_ ||
          timeout_ms != base::kNoTimeout);
   SyncMessage* sync_msg = static_cast<SyncMessage*>(message);
   context->Push(sync_msg);
   int message_id = SyncMessage::GetMessageId(*sync_msg);
   WaitableEvent* pump_messages_event = sync_msg->pump_messages_event();
@@ skipping 93 matching lines @@
   // Ideally we only want to watch this object when running a nested message
   // loop.  However, we don't know when it exits if there's another nested
   // message loop running under it or not, so we wouldn't know whether to
   // stop or keep watching.  So we always watch it, and create the event as
   // manual reset since the object watcher might otherwise reset the event
   // when we're doing a WaitMany.
   dispatch_watcher_.StartWatching(sync_context()->GetDispatchEvent(), this);
 }
 
 }  // namespace IPC