Ensure that PP_Instance values are unique within a plugin process in addition...

ppapi/proxy/host_dispatcher.cc

 // Copyright (c) 2010 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 "ppapi/proxy/host_dispatcher.h"
 
 #include <map>
 
 #include "base/logging.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/proxy/host_var_serialization_rules.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
 typedef std::map<PP_Instance, HostDispatcher*> InstanceToDispatcherMap;
 InstanceToDispatcherMap* g_instance_to_dispatcher = NULL;
 
+typedef std::map<PP_Module, HostDispatcher*> ModuleToDispatcherMap;
+ModuleToDispatcherMap* g_module_to_dispatcher = NULL;
+
+PP_Bool ReserveInstanceID(PP_Module module, PP_Instance instance) {
+  // Default to returning true (usable) failure. Otherwise, if there's some
+  // kind of communication error or the plugin just crashed, we'll get into an
+  // infinite loop generating new instnace IDs since we think they're all in
+  // use.
+  ModuleToDispatcherMap::const_iterator found =
+      g_module_to_dispatcher->find(module);
+  if (found == g_module_to_dispatcher->end()) {
+    NOTREACHED();
+    return PP_TRUE;
+  }
+
+  bool usable = true;
+  if (!found->second->Send(new PpapiMsg_ReserveInstanceId(instance, &usable)))
+    return PP_TRUE;
+  return BoolToPPBool(usable);
+}
+
 }  // namespace
 
 HostDispatcher::HostDispatcher(base::ProcessHandle remote_process_handle,
                                PP_Module module,
                                GetInterfaceFunc local_get_interface)
     : Dispatcher(remote_process_handle, local_get_interface),
       pp_module_(module),
       ppb_proxy_(NULL) {
+  if (!g_module_to_dispatcher)
+    g_module_to_dispatcher = new ModuleToDispatcherMap;
+  (*g_module_to_dispatcher)[pp_module_] = this;
+
   const PPB_Var_Deprecated* var_interface =
       static_cast<const PPB_Var_Deprecated*>(
           local_get_interface(PPB_VAR_DEPRECATED_INTERFACE));
   SetSerializationRules(new HostVarSerializationRules(var_interface, module));
 
   memset(plugin_interface_support_, 0,
          sizeof(PluginInterfaceSupport) * INTERFACE_ID_COUNT);
+
+  ppb_proxy_ = reinterpret_cast<const PPB_Proxy_Private*>(
+      GetLocalInterface(PPB_PROXY_PRIVATE_INTERFACE));
+  DCHECK(ppb_proxy_) << "The proxy interface should always be supported.";
+
+  ppb_proxy_->SetReserveInstanceIDCallback(pp_module_, &ReserveInstanceID);
 }
 
 HostDispatcher::~HostDispatcher() {
+  g_module_to_dispatcher->erase(pp_module_);
 }
 
 // static
 HostDispatcher* HostDispatcher::GetForInstance(PP_Instance instance) {
   if (!g_instance_to_dispatcher)
     return NULL;
   InstanceToDispatcherMap::iterator found = g_instance_to_dispatcher->find(
       instance);
   if (found == g_instance_to_dispatcher->end())
     return NULL;
@@ skipping 46 matching lines @@
     proxy = CreatePPBInterfaceProxy(info);
   }
 
   return proxy->OnMessageReceived(msg);
 }
 
 void HostDispatcher::OnChannelError() {
   Dispatcher::OnChannelError();  // Stop using the channel.
 
   // Tell the host about the crash so it can clean up.
-  GetPPBProxy()->PluginCrashed(pp_module());
+  ppb_proxy_->PluginCrashed(pp_module());
 }
 
 const void* HostDispatcher::GetProxiedInterface(const std::string& interface) {
   // First see if we even have a proxy for this interface.
   const InterfaceProxy::Info* info = GetPPPInterfaceInfo(interface);
   if (!info)
     return NULL;
 
   if (plugin_interface_support_[static_cast<int>(info->id)] !=
       INTERFACE_UNQUERIED) {
@@ skipping 27 matching lines @@
     // the plugin the ability to call that trusted interface (since the
     // checking occurs at proxy-creation time).
     if (info->is_trusted && disallow_trusted_interfaces())
       return NULL;
 
     proxy = CreatePPBInterfaceProxy(info);
   }
   return proxy;
 }
 
-const PPB_Proxy_Private* HostDispatcher::GetPPBProxy() {
-  if (!ppb_proxy_) {
-    ppb_proxy_ = reinterpret_cast<const PPB_Proxy_Private*>(
-        GetLocalInterface(PPB_PROXY_PRIVATE_INTERFACE));
-  }
-  return ppb_proxy_;
-}
-
 InterfaceProxy* HostDispatcher::CreatePPBInterfaceProxy(
     const InterfaceProxy::Info* info) {
   const void* local_interface = GetLocalInterface(info->name);
   if (!local_interface) {
     // This should always succeed since the browser should support the stuff
     // the proxy does. If this happens, something is out of sync.
     NOTREACHED();
     return NULL;
   }
 
   InterfaceProxy* proxy = info->create_proxy(this, local_interface);
   target_proxies_[info->id].reset(proxy);
   return proxy;
 }
 
 }  // namespace proxy
 }  // namespace pp