Merge 32397 - Only clears the unblock flag on sync IPCs during other sync dis...

chrome/plugin/plugin_channel_base.cc

 // Copyright (c) 2006-2008 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/plugin/plugin_channel_base.h"
 
 #include "base/hash_tables.h"
 #include "chrome/common/child_process.h"
 #include "ipc/ipc_sync_message.h"
 
@@ skipping 42 matching lines @@
     iter->second->Send(new IPC::Message(*message));
   }
   delete message;
 }
 
 PluginChannelBase::PluginChannelBase()
     : plugin_count_(0),
       peer_pid_(0),
       in_remove_route_(false),
       channel_valid_(false),
-      in_dispatch_(0),
-      send_unblocking_only_during_dispatch_(false) {
+      in_sync_dispatch_(0),
+      send_unblocking_only_during_sync_dispatch_(false) {
 }
 
 PluginChannelBase::~PluginChannelBase() {
 }
 
 void PluginChannelBase::CleanupChannels() {
   // Make a copy of the references as we can't iterate the map since items will
   // be removed from it as we clean them up.
   std::vector<scoped_refptr<PluginChannelBase> > channels;
   for (PluginChannelMap::const_iterator iter = g_plugin_channels_.begin();
@@ skipping 18 matching lines @@
   channel_valid_ = true;
   return true;
 }
 
 bool PluginChannelBase::Send(IPC::Message* message) {
   if (!channel_.get()) {
     delete message;
     return false;
   }
 
-  if (send_unblocking_only_during_dispatch_ && in_dispatch_ == 0 &&
+  if (send_unblocking_only_during_sync_dispatch_ && in_sync_dispatch_ == 0 &&
       message->is_sync()) {
     message->set_unblock(false);
   }
 
   return channel_->Send(message);
 }
 
 int PluginChannelBase::Count() {
   return static_cast<int>(g_plugin_channels_.size());
 }
 
 void PluginChannelBase::OnMessageReceived(const IPC::Message& message) {
   // This call might cause us to be deleted, so keep an extra reference to
   // ourself so that we can send the reply and decrement back in_dispatch_.
   scoped_refptr<PluginChannelBase> me(this);
 
-  in_dispatch_++;
+  if (message.is_sync())
+    in_sync_dispatch_++;
   if (message.routing_id() == MSG_ROUTING_CONTROL) {
     OnControlMessageReceived(message);
   } else {
     bool routed = router_.RouteMessage(message);
     if (!routed && message.is_sync()) {
       // The listener has gone away, so we must respond or else the caller will
       // hang waiting for a reply.
       IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
       reply->set_reply_error();
       Send(reply);
     }
   }
-  in_dispatch_--;
+  if (message.is_sync())
+    in_sync_dispatch_--;
 }
 
 void PluginChannelBase::OnChannelConnected(int32 peer_pid) {
   peer_pid_ = peer_pid;
 }
 
 void PluginChannelBase::AddRoute(int route_id,
                                  IPC::Channel::Listener* listener,
                                  bool npobject) {
   if (npobject) {
@@ skipping 63 matching lines @@
 
 void PluginChannelBase::OnChannelError() {
 #if defined(OS_POSIX)
   if (channel_valid()) {
     IPC::RemoveAndCloseChannelSocket(channel_name());
   }
 #endif
   channel_valid_ = false;
 }
 
-void PluginChannelBase::SendUnblockingOnlyDuringDispatch() {
-  send_unblocking_only_during_dispatch_ = true;
+void PluginChannelBase::SendUnblockingOnlyDuringSyncDispatch() {
+  send_unblocking_only_during_sync_dispatch_ = true;
 }