Allow the NaCl IPC proxy to support multiple instances.

webkit/plugins/ppapi/ppapi_plugin_instance.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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 466 matching lines @@
   live_plugin_objects_.swap(plugin_object_copy);
   for (PluginObjectSet::iterator i = plugin_object_copy.begin();
        i != plugin_object_copy.end(); ++i)
     delete *i;
 
   if (lock_mouse_callback_)
     TrackedCallback::ClearAndAbort(&lock_mouse_callback_);
 
   delegate_->InstanceDeleted(this);
   module_->InstanceDeleted(this);
+  // If we switched from the NaCl plugin module, notify it too.
+  if (nacl_module_.get())
+    nacl_module_->InstanceDeleted(this);
 
   HostGlobals::Get()->InstanceDeleted(pp_instance_);
 }
 
 // NOTE: Any of these methods that calls into the plugin needs to take into
 // account that the plugin may use Var to remove the <embed> from the DOM, which
 // will make the WebPluginImpl drop its reference, usually the last one. If a
 // method needs to access a member of the instance after the call has returned,
 // then it needs to keep its own reference on the stack.
 
 void PluginInstance::Delete() {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   // Force the MessageChannel to release its "passthrough object" which should
   // release our last reference to the "InstanceObject" and will probably
   // destroy it. We want to do this prior to calling DidDestroy in case the
   // destructor of the instance object tries to use the instance.
   message_channel_->SetPassthroughObject(NULL);
   // If this is a NaCl plugin instance, shut down the NaCl plugin by calling
   // its DidDestroy. Don't call DidDestroy on the untrusted plugin instance,
   // since there is little that it can do at this point.
-  if (nacl_plugin_instance_interface_.get())
-    nacl_plugin_instance_interface_->DidDestroy(pp_instance());
+  if (nacl_instance_interface_.get())
+    nacl_instance_interface_->DidDestroy(pp_instance());
   else
     instance_interface_->DidDestroy(pp_instance());
 
   if (fullscreen_container_) {
     fullscreen_container_->Destroy();
     fullscreen_container_ = NULL;
   }
   container_ = NULL;
 }
 
@@ skipping 1997 matching lines @@
                                                         components);
 }
 
 PP_Var PluginInstance::GetPluginInstanceURL(
     PP_Instance instance,
     PP_URLComponents_Dev* components) {
   return ::ppapi::PPB_URLUtil_Shared::GenerateURLReturn(plugin_url_,
                                                         components);
 }
 
-bool PluginInstance::ResetAsProxied() {
+bool PluginInstance::ResetAsProxied(scoped_refptr<PluginModule> module) {
+  // Save the original module and switch over to the new one now that this
+  // plugin is using the IPC-based proxy.
+  nacl_module_.swap(module_);

[dmichael (off chromium), 2012/09/04 21:21:33]

What's the benefit of using swap()? Are you just trying to save the reference
counting? I think making the code less readable probably isn't worth it here.

[bbudge, 2012/09/05 19:15:48]

Done.

+  module_.swap(module);
+
   // For NaCl instances, remember the NaCl plugin instance interface, so we
   // can shut it down by calling its DidDestroy in our Delete() method.
-  nacl_plugin_instance_interface_.reset(instance_interface_.release());
+  nacl_instance_interface_.reset(instance_interface_.release());
 
   base::Callback<const void*(const char*)> get_plugin_interface_func =
       base::Bind(&PluginModule::GetPluginInterface, module_.get());
   PPP_Instance_Combined* ppp_instance_combined =
       PPP_Instance_Combined::Create(get_plugin_interface_func);
   if (!ppp_instance_combined) {
     // The proxy must support at least one usable PPP_Instance interface.
     NOTREACHED();
     return false;
   }
@@ skipping 96 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit