Use macros to define pepper interfaces

ppapi/proxy/ppb_audio_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_audio_proxy.h"
 
 #include "base/compiler_specific.h"
 #include "base/threading/simple_thread.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_audio.h"
@@ skipping 98 matching lines @@
 int32_t Audio::GetSyncSocket(int* sync_socket) {
   return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
 }
 
 int32_t Audio::GetSharedMemory(int* shm_handle, uint32_t* shm_size) {
   return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
 }
 
 namespace {
 
-InterfaceProxy* CreateAudioProxy(Dispatcher* dispatcher,
-                                 const void* target_interface) {
-  return new PPB_Audio_Proxy(dispatcher, target_interface);
-}
-
 base::PlatformFile IntToPlatformFile(int32_t handle) {
   // TODO(piman/brettw): Change trusted interface to return a PP_FileHandle,
   // those casts are ugly.
 #if defined(OS_WIN)
   return reinterpret_cast<HANDLE>(static_cast<intptr_t>(handle));
 #elif defined(OS_POSIX)
   return handle;
 #else
   #error Not implemented.
 #endif
 }
 
 }  // namespace
 
-PPB_Audio_Proxy::PPB_Audio_Proxy(Dispatcher* dispatcher,
-                                 const void* target_interface)
-    : InterfaceProxy(dispatcher, target_interface),
+PPB_Audio_Proxy::PPB_Audio_Proxy(Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PPB_Audio_Proxy::~PPB_Audio_Proxy() {
 }
 
 // static
-const InterfaceProxy::Info* PPB_Audio_Proxy::GetInfo() {
-  static const Info info = {
-    thunk::GetPPB_Audio_Thunk(),
-    PPB_AUDIO_INTERFACE,
-    INTERFACE_ID_PPB_AUDIO,
-    false,
-    &CreateAudioProxy,
-  };
-  return &info;
-}
-
-// static
 PP_Resource PPB_Audio_Proxy::CreateProxyResource(
     PP_Instance instance_id,
     PP_Resource config_id,
     PPB_Audio_Callback audio_callback,
     void* user_data) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance_id);
   if (!dispatcher)
     return 0;
 
   EnterResourceNoLock<PPB_AudioConfig_API> config(config_id, true);
@@ skipping 21 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBAudio_NotifyAudioStreamCreated,
                         OnMsgNotifyAudioStreamCreated)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PPB_Audio_Proxy::OnMsgCreate(PP_Instance instance_id,
                                   int32_t sample_rate,
                                   uint32_t sample_frame_count,
                                   HostResource* result) {

[noelallen_use_chromium, 2011/09/07 21:16:57]

Does this need:
  thunk::EnterResourceCreation enter(instance);

I didn't see a trusted version of this interface in the CL.

[brettw, 2011/09/08 05:34:29]

This is mostly touching the proxy and AudioTrusted isn't proxied (it's used to
implement the proxy).

   thunk::EnterFunction<thunk::ResourceCreationAPI> resource_creation(
       instance_id, true);
   if (resource_creation.failed())
     return;
 
   // Make the resource and get the API pointer to its trusted interface.
   result->SetHostResource(
       instance_id,
       resource_creation.functions()->CreateAudioTrusted(instance_id));
   if (result->is_null())
@@ skipping 23 matching lines @@
     enter.SetResult(PP_ERROR_FAILED);
     return;
   }
 
   // Initiate opening the audio object.
   enter.SetResult(enter.object()->OpenTrusted(audio_config_res,
                                               enter.callback()));
 
   // Clean up the temporary audio config resource we made.
   const PPB_Core* core = static_cast<const PPB_Core*>(
-      dispatcher()->GetLocalInterface(PPB_CORE_INTERFACE));
+      dispatcher()->local_get_interface()(PPB_CORE_INTERFACE));
   core->ReleaseResource(audio_config_res);
 }
 
 void PPB_Audio_Proxy::OnMsgStartOrStop(const HostResource& audio_id,
                                        bool play) {
+  EnterHostFromHostResource<PPB_Audio_API> enter(audio_id);
+  if (enter.failed())
+    return;
   if (play)
-    ppb_audio_target()->StartPlayback(audio_id.host_resource());
+    enter.object()->StartPlayback();
   else
-    ppb_audio_target()->StopPlayback(audio_id.host_resource());
+    enter.object()->StopPlayback();
 }
 
 // Processed in the plugin (message from host).
 void PPB_Audio_Proxy::OnMsgNotifyAudioStreamCreated(
     const HostResource& audio_id,
     int32_t result_code,
     IPC::PlatformFileForTransit socket_handle,
     base::SharedMemoryHandle handle,
     uint32_t length) {
   EnterPluginFromHostResource<PPB_Audio_API> enter(audio_id);
@@ skipping 35 matching lines @@
       INTERFACE_ID_PPB_AUDIO, resource, result_code, socket_handle,
       shared_memory, shared_memory_length));
 }
 
 int32_t PPB_Audio_Proxy::GetAudioConnectedHandles(
     const HostResource& resource,
     IPC::PlatformFileForTransit* foreign_socket_handle,
     base::SharedMemoryHandle* foreign_shared_memory_handle,
     uint32_t* shared_memory_length) {
   // Get the audio interface which will give us the handles.
-  EnterResourceNoLock<PPB_Audio_API> enter(resource.host_resource(), false);
+  EnterHostFromHostResource<PPB_Audio_API> enter(resource);
   if (enter.failed())
     return PP_ERROR_NOINTERFACE;
 
   // Get the socket handle for signaling.
   int32_t socket_handle;
   int32_t result = enter.object()->GetSyncSocket(&socket_handle);
   if (result != PP_OK)
     return result;
 
   // socket_handle doesn't belong to us: don't close it.
@@ skipping 13 matching lines @@
   *foreign_shared_memory_handle = dispatcher()->ShareHandleWithRemote(
       IntToPlatformFile(shared_memory_handle), false);
   if (*foreign_shared_memory_handle == IPC::InvalidPlatformFileForTransit())
     return PP_ERROR_FAILED;
 
   return PP_OK;
 }
 
 }  // namespace proxy
 }  // namespace ppapi