PPAPI: Make GetProxiedInterface not re-enter the plugin

ppapi/proxy/host_dispatcher.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 "ppapi/proxy/host_dispatcher.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/c/ppb_var.h"
@@ skipping 206 matching lines @@
   const void* proxied_interface =
       InterfaceList::GetInstance()->GetInterfaceForPPP(iface_name);
   if (!proxied_interface)
     return NULL;  // Don't have a proxy for this interface, don't query further.
 
   PluginSupportedMap::iterator iter(plugin_supported_.find(iface_name));
   if (iter == plugin_supported_.end()) {
     // Need to query. Cache the result so we only do this once.
     bool supported = false;
 
-    bool previous_reentrancy_value = allow_plugin_reentrancy_;
-    allow_plugin_reentrancy_ = true;
-    Send(new PpapiMsg_SupportsInterface(iface_name, &supported));
-    allow_plugin_reentrancy_ = previous_reentrancy_value;
+    Send(new PpapiMsg_IsInterfaceSupported(iface_name, &supported));
 
     std::pair<PluginSupportedMap::iterator, bool> iter_success_pair;
     iter_success_pair = plugin_supported_.insert(
         PluginSupportedMap::value_type(iface_name, supported));
     iter = iter_success_pair.first;
   }
   if (iter->second)
     return proxied_interface;
   return NULL;
 }
@@ skipping 26 matching lines @@
                                             const std::string& value) {
   PP_LogLevel level = static_cast<PP_LogLevel>(int_log_level);
   if (instance) {
     PpapiGlobals::Get()->LogWithSource(instance, level, source, value);
   } else {
     PpapiGlobals::Get()->BroadcastLogWithSource(pp_module_, level,
                                                 source, value);
   }
 }
 
+void HostDispatcher::OnHostMsgPluginSupportsInterface(
+    const std::string& interface_name) {
+  plugin_supported_[interface_name] = true;
+}
+
 // ScopedModuleReference -------------------------------------------------------
 
 ScopedModuleReference::ScopedModuleReference(Dispatcher* dispatcher)
     : dispatcher_(NULL) {
   if (!dispatcher->IsPlugin()) {
     dispatcher_ = static_cast<HostDispatcher*>(dispatcher);
     dispatcher_->ppb_proxy()->AddRefModule(dispatcher_->pp_module());
   }
 }
 
 ScopedModuleReference::~ScopedModuleReference() {
   if (dispatcher_)
     dispatcher_->ppb_proxy()->ReleaseModule(dispatcher_->pp_module());
 }
 
 }  // namespace proxy
 }  // namespace ppapi