Use macros to define pepper interfaces

ppapi/proxy/ppb_url_loader_proxy.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/ppb_url_loader_proxy.h"
 
 #include <algorithm>
 #include <deque>
 #include <vector>
 
@@ skipping 52 matching lines @@
   params.instance = pp_instance;
   params.resource.SetHostResource(pp_instance, pp_resource);
   params.bytes_sent = bytes_sent;
   params.total_bytes_to_be_sent = total_bytes_to_be_sent;
   params.bytes_received = bytes_received;
   params.total_bytes_to_be_received = total_bytes_to_be_received;
   dispatcher->Send(new PpapiMsg_PPBURLLoader_UpdateProgress(
       INTERFACE_ID_PPB_URL_LOADER, params));
 }
 
-InterfaceProxy* CreateURLLoaderProxy(Dispatcher* dispatcher,
-                                     const void* target_interface) {
-  return new PPB_URLLoader_Proxy(dispatcher, target_interface);
+InterfaceProxy* CreateURLLoaderProxy(Dispatcher* dispatcher) {
+  return new PPB_URLLoader_Proxy(dispatcher);
 }
 
 }  // namespace
 
 // URLLoader -------------------------------------------------------------------
 
 class URLLoader : public Resource, public PPB_URLLoader_API {
  public:
   URLLoader(const HostResource& resource);
   virtual ~URLLoader();
@@ skipping 253 matching lines @@
                 buffer_.begin() + output_size);
 }
 
 // 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),
+PPB_URLLoader_Proxy::PPB_URLLoader_Proxy(Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       host_urlloader_trusted_interface_(NULL) {
 }
 
 PPB_URLLoader_Proxy::~PPB_URLLoader_Proxy() {
 }
 
 // static
 PP_Resource PPB_URLLoader_Proxy::TrackPluginResource(
     const HostResource& url_loader_resource) {
   return (new URLLoader(url_loader_resource))->GetReference();
 }
 
 // static
-const InterfaceProxy::Info* PPB_URLLoader_Proxy::GetInfo() {
-  static const Info info = {
-    thunk::GetPPB_URLLoader_Thunk(),
-    PPB_URLLOADER_INTERFACE,
-    INTERFACE_ID_PPB_URL_LOADER,
-    false,
-    &CreateURLLoaderProxy,
-  };
-  return &info;
-}
-
-// static
 const InterfaceProxy::Info* PPB_URLLoader_Proxy::GetTrustedInfo() {
   static const Info info = {
     thunk::GetPPB_URLLoaderTrusted_Thunk(),
     PPB_URLLOADERTRUSTED_INTERFACE,
     INTERFACE_ID_NONE,  // URL_LOADER is the canonical one.
     false,
     &CreateURLLoaderProxy
   };
   return &info;
 }
@@ skipping 48 matching lines @@
   // callback before sending any URLLoader to the plugin.
   EnterResourceNoLock<PPB_URLLoader_API> enter(resource, false);
   if (enter.succeeded())
     enter.object()->SetStatusCallback(&UpdateResourceLoadStatus);
   else
     NOTREACHED();  // Only called internally, resource should be valid.
 }
 
 void PPB_URLLoader_Proxy::OnMsgCreate(PP_Instance instance,
                                       HostResource* result) {
-  EnterFunctionNoLock<ResourceCreationAPI> enter(instance, true);
+  thunk::EnterResourceCreation enter(instance);
   if (enter.succeeded()) {
     result->SetHostResource(instance,
                             enter.functions()->CreateURLLoader(instance));
     PrepareURLLoaderForSendingToPlugin(result->host_resource());
   }
 }
 
 void PPB_URLLoader_Proxy::OnMsgOpen(const HostResource& loader,
                                     const PPB_URLRequestInfo_Data& data,
                                     uint32_t serialized_callback) {
   // Have to be careful to always issue the callback, so don't return early.
   EnterHostFromHostResource<PPB_URLLoader_API> enter(loader);
-  EnterFunctionNoLock<ResourceCreationAPI> enter_creation(
-      loader.instance(), true);
+  thunk::EnterResourceCreation enter_creation(loader.instance());
 
   PP_CompletionCallback callback = ReceiveCallback(serialized_callback);
 
   int32_t result = PP_ERROR_BADRESOURCE;
   if (enter.succeeded() && enter_creation.succeeded()) {
     ScopedPPResource request_resource(
         ScopedPPResource::PassRef(),
         enter_creation.functions()->CreateURLRequestInfo(loader.instance(),
                                                          data));
     result = enter.object()->Open(request_resource, callback);
@@ skipping 117 matching lines @@
   info->read_buffer.resize(bytes_read);
 
   dispatcher()->Send(new PpapiMsg_PPBURLLoader_ReadResponseBody_Ack(
       INTERFACE_ID_PPB_URL_LOADER, info->resource, result, info->read_buffer));
 
   delete info;
 }
 
 }  // namespace proxy
 }  // namespace ppapi