Implement proxying for FileRef and FileChooser....

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"
@@ skipping 76 matching lines @@
   InterfaceProxy* proxy = target_proxies_[msg.routing_id()].get();
   if (!proxy) {
     // Autocreate any proxy objects to handle requests from the plugin. Since
     // we always support all known PPB_* interfaces (modulo the trusted bit),
     // there's very little checking necessary.
     const InterfaceProxy::Info* info = GetPPBInterfaceInfo(
         static_cast<InterfaceID>(msg.routing_id()));
     if (!info ||
         (info->is_trusted && disallow_trusted_interfaces()))
       return true;
-
-    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 true;
-    }
-
-    proxy = info->create_proxy(this, local_interface);
-    target_proxies_[info->id].reset(proxy);
+    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());
@@ skipping 17 matching lines @@
   bool supported = false;
   Send(new PpapiMsg_SupportsInterface(interface, &supported));
   plugin_interface_support_[static_cast<int>(info->id)] =
       supported ? INTERFACE_SUPPORTED : INTERFACE_UNSUPPORTED;
 
   if (supported)
     return info->interface;
   return NULL;
 }
 
+InterfaceProxy* HostDispatcher::GetOrCreatePPBInterfaceProxy(
+    InterfaceID id) {
+  InterfaceProxy* proxy = target_proxies_[id].get();
+  if (!proxy) {
+    const InterfaceProxy::Info* info = GetPPBInterfaceInfo(id);
+    if (!info)
+      return NULL;
+
+    // Sanity check. This function won't normally be called for trusted
+    // interfaces, but in case somebody does this, we don't want to then give
+    // 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