Remove all uses of the global Dispatcher Get function.

ppapi/proxy/ppb_url_loader_proxy.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/ppb_url_loader_proxy.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "build/build_config.h"
@@ skipping 228 matching lines @@
 void Close(PP_Resource loader_id) {
   URLLoader* loader_object;
   PluginDispatcher* dispatcher;
   if (!RoutingDataFromURLLoader(loader_id, &loader_object, &dispatcher))
     return;
 
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_Close(
       INTERFACE_ID_PPB_URL_LOADER, loader_object->host_resource()));
 }
 
-const PPB_URLLoader ppb_urlloader = {
+const PPB_URLLoader urlloader_interface = {
   &Create,
   &IsURLLoader,
   &Open,
   &FollowRedirect,
   &GetUploadProgress,
   &GetDownloadProgress,
   &GetResponseInfo,
   &ReadResponseBody,
   &FinishStreamingToFile,
   &Close
 };
 
+InterfaceProxy* CreateURLLoaderProxy(Dispatcher* dispatcher,
+                                     const void* target_interface) {
+  return new PPB_URLLoader_Proxy(dispatcher, target_interface);
+}
+
 // Plugin URLLoaderTrusted implementation --------------------------------------
 
 void GrantUniversalAccess(PP_Resource loader_id) {
   URLLoader* loader_object;
   PluginDispatcher* dispatcher;
   if (!RoutingDataFromURLLoader(loader_id, &loader_object, &dispatcher))
     return;
 
   dispatcher->Send(
       new PpapiHostMsg_PPBURLLoaderTrusted_GrantUniversalAccess(
           INTERFACE_ID_PPB_URL_LOADER_TRUSTED, loader_object->host_resource()));
 }
 
-const PPB_URLLoaderTrusted ppb_urlloader_trusted = {
+const PPB_URLLoaderTrusted urlloader_trusted_interface = {
   &GrantUniversalAccess,
   NULL,  // RegisterStatusCallback is used internally by the proxy only.
 };
 
+InterfaceProxy* CreateURLLoaderTrustedProxy(Dispatcher* dispatcher,
+                                            const void* target_interface) {
+  return new PPB_URLLoaderTrusted_Proxy(dispatcher, target_interface);
+}
+
 }  // namespace
 
 // PPB_URLLoader_Proxy ---------------------------------------------------------
 
 struct PPB_URLLoader_Proxy::ReadCallbackInfo {
   HostResource resource;
   std::string read_buffer;
 };
 
 PPB_URLLoader_Proxy::PPB_URLLoader_Proxy(Dispatcher* dispatcher,
                                          const void* target_interface)
     : InterfaceProxy(dispatcher, target_interface),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PPB_URLLoader_Proxy::~PPB_URLLoader_Proxy() {
 }
 
 // static
 PP_Resource PPB_URLLoader_Proxy::TrackPluginResource(
     const HostResource& url_loader_resource) {
   linked_ptr<URLLoader> object(new URLLoader(url_loader_resource));
   return PluginResourceTracker::GetInstance()->AddResource(object);
 }
 
-const void* PPB_URLLoader_Proxy::GetSourceInterface() const {
-  return &ppb_urlloader;
-}
-
-InterfaceID PPB_URLLoader_Proxy::GetInterfaceId() const {
-  return INTERFACE_ID_PPB_URL_LOADER;
+// static
+const InterfaceProxy::Info* PPB_URLLoader_Proxy::GetInfo() {
+  static const Info info = {
+    &urlloader_interface,
+    PPB_URLLOADER_INTERFACE,
+    INTERFACE_ID_PPB_URL_LOADER,
+    false,
+    &CreateURLLoaderProxy,
+  };
+  return &info;
 }
 
 bool PPB_URLLoader_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_URLLoader_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_Create,
                         OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_Open,
                         OnMsgOpen)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_FollowRedirect,
@@ skipping 162 matching lines @@
 
 PPB_URLLoaderTrusted_Proxy::PPB_URLLoaderTrusted_Proxy(
     Dispatcher* dispatcher,
     const void* target_interface)
     : InterfaceProxy(dispatcher, target_interface) {
 }
 
 PPB_URLLoaderTrusted_Proxy::~PPB_URLLoaderTrusted_Proxy() {
 }
 
-const void* PPB_URLLoaderTrusted_Proxy::GetSourceInterface() const {
-  return &ppb_urlloader_trusted;
-}
-
-InterfaceID PPB_URLLoaderTrusted_Proxy::GetInterfaceId() const {
-  return INTERFACE_ID_PPB_URL_LOADER_TRUSTED;
+// static
+const InterfaceProxy::Info* PPB_URLLoaderTrusted_Proxy::GetInfo() {
+  static const Info info = {
+    &urlloader_trusted_interface,
+    PPB_URLLOADERTRUSTED_INTERFACE,
+    INTERFACE_ID_PPB_URL_LOADER_TRUSTED,
+    true,
+    &CreateURLLoaderTrustedProxy,
+  };
+  return &info;
 }
 
 bool PPB_URLLoaderTrusted_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_URLLoaderTrusted_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoaderTrusted_GrantUniversalAccess,
                         OnMsgGrantUniversalAccess)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP();
   // TODO(brettw) handle bad messages!
   return handled;
 }
 
 void PPB_URLLoaderTrusted_Proxy::OnMsgGrantUniversalAccess(
     const HostResource& loader) {
   ppb_url_loader_trusted_target()->GrantUniversalAccess(loader.host_resource());
 }
 
 }  // namespace proxy
 }  // namespace pp