When a plugin calls NPN_SetException, pass the exception along to every rende...

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 <stack>
+
 #include "base/hash_tables.h"
+#include "base/lazy_instance.h"
 #include "chrome/common/child_process.h"
 #include "ipc/ipc_sync_message.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 typedef base::hash_map<std::string, scoped_refptr<PluginChannelBase> >
     PluginChannelMap;
 
 static PluginChannelMap g_plugin_channels_;
 
+static base::LazyInstance<std::stack<scoped_refptr<PluginChannelBase> > >
+    lazy_plugin_channel_stack_(base::LINKER_INITIALIZED);
 
 PluginChannelBase* PluginChannelBase::GetChannel(
     const std::string& channel_name, IPC::Channel::Mode mode,
     PluginChannelFactory factory, MessageLoop* ipc_message_loop,
     bool create_pipe_now) {
   scoped_refptr<PluginChannelBase> channel;
 
   PluginChannelMap::const_iterator iter = g_plugin_channels_.find(channel_name);
   if (iter == g_plugin_channels_.end()) {
     channel = factory();
@@ skipping 30 matching lines @@
       peer_pid_(0),
       in_remove_route_(false),
       channel_valid_(false),
       in_dispatch_(0),
       send_unblocking_only_during_dispatch_(false) {
 }
 
 PluginChannelBase::~PluginChannelBase() {
 }
 
+PluginChannelBase* PluginChannelBase::GetCurrentChannel() {
+  return lazy_plugin_channel_stack_.Pointer()->top();
+}
+
 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();
        iter != g_plugin_channels_.end();
        ++iter) {
     channels.push_back(iter->second);
   }
 
@@ skipping 28 matching lines @@
   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);
+  lazy_plugin_channel_stack_.Pointer()->push(
+      scoped_refptr<PluginChannelBase>(this));
 
   in_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_--;
+
+  lazy_plugin_channel_stack_.Pointer()->pop();
 }
 
 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 66 matching lines @@
   if (channel_valid()) {
     IPC::RemoveAndCloseChannelSocket(channel_name());
   }
 #endif
   channel_valid_ = false;
 }
 
 void PluginChannelBase::SendUnblockingOnlyDuringDispatch() {
   send_unblocking_only_during_dispatch_ = true;
 }