Make o.o.p. proxy handle PPP_Instance versions 0.4 and 0.5.

ppapi/proxy/host_dispatcher.cc

 // Copyright (c) 2011 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/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 57 matching lines @@
       allow_plugin_reentrancy_(false) {
   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_);
 }
@@ skipping 110 matching lines @@
   // Tell the host about the crash so it can clean up and display notification.
   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) {
-    // Already queried the plugin if it supports this interface.
-    if (plugin_interface_support_[info->id] == INTERFACE_SUPPORTED)
-      return info->interface_ptr;
-    return NULL;
+  PluginIFSupportMap::iterator iter(plugin_if_support_.find(interface));
+  if (iter == plugin_if_support_.end()) {
+    // Need to query. Cache the result so we only do this once.
+    bool supported = false;
+    Send(new PpapiMsg_SupportsInterface(interface, &supported));
+    std::pair<PluginIFSupportMap::iterator, bool> iter_success_pair;
+    iter_success_pair = plugin_if_support_.insert(
+        PluginIFSupportMap::value_type(interface,
+                                       supported ? INTERFACE_SUPPORTED :
+                                                   INTERFACE_UNSUPPORTED));
+    iter = iter_success_pair.first;
   }
-
-  // Need to re-query. Cache the result so we only do this once.
-  bool supported = false;
-  Send(new PpapiMsg_SupportsInterface(interface, &supported));
-  plugin_interface_support_[static_cast<int>(info->id)] =
-      supported ? INTERFACE_SUPPORTED : INTERFACE_UNSUPPORTED;
-
-  if (supported)
+  if (iter->second == INTERFACE_SUPPORTED)
     return info->interface_ptr;
   return NULL;
 }
 
 InterfaceProxy* HostDispatcher::GetOrCreatePPBInterfaceProxy(
     InterfaceID id) {
   InterfaceProxy* proxy = target_proxies_[id].get();
   if (!proxy) {
     const InterfaceProxy::Info* info = GetPPBInterfaceInfo(id);
     if (!info)
@@ skipping 34 matching lines @@
   dispatcher_->ppb_proxy()->AddRefModule(dispatcher_->pp_module());
 }
 
 ScopedModuleReference::~ScopedModuleReference() {
   dispatcher_->ppb_proxy()->ReleaseModule(dispatcher_->pp_module());
 }
 
 }  // namespace proxy
 }  // namespace pp