Add a template to handle properly issuing completion callbacks. This fixes

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/threading/simple_thread.h"
 #include "ppapi/c/pp_errors.h"

[cpu_(ooo_6.6-7.5), 2011/08/03 00:57:21]

noticing it is not including compiler_specific.h for the overrides.

 #include "ppapi/c/ppb_audio.h"
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/trusted/ppb_audio_trusted.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/interface_id.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/audio_impl.h"
 #include "ppapi/thunk/ppb_audio_config_api.h"
-#include "ppapi/thunk/ppb_audio_trusted_api.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/resource_creation_api.h"
 #include "ppapi/thunk/thunk.h"
 
-using ::ppapi::thunk::PPB_Audio_API;
+using ppapi::thunk::EnterResourceNoLock;
+using ppapi::thunk::PPB_Audio_API;
+using ppapi::thunk::PPB_AudioConfig_API;
 
 namespace pp {
 namespace proxy {
 
 class Audio : public PluginResource, public ppapi::AudioImpl {
  public:
   Audio(const HostResource& audio_id,
         PP_Resource config_id,
         PPB_Audio_Callback callback,
         void* user_data);
   virtual ~Audio();
 
   // ResourceObjectBase overrides.
   virtual PPB_Audio_API* AsPPB_Audio_API();
 
   // PPB_Audio_API implementation.
   virtual PP_Resource GetCurrentConfig() OVERRIDE;
   virtual PP_Bool StartPlayback() OVERRIDE;
   virtual PP_Bool StopPlayback() OVERRIDE;
+  virtual int32_t OpenTrusted(PP_Resource config_id,
+                              PP_CompletionCallback create_callback) OVERRIDE;
+  virtual int32_t GetSyncSocket(int* sync_socket) OVERRIDE;
+  virtual int32_t GetSharedMemory(int* shm_handle, uint32_t* shm_size) OVERRIDE;
 
  private:
   // Owning reference to the current config object. This isn't actually used,
   // we just dish it out as requested by the plugin.
   PP_Resource config_;
 
   DISALLOW_COPY_AND_ASSIGN(Audio);
 };
 
 Audio::Audio(const HostResource& audio_id,
@@ skipping 33 matching lines @@
 PP_Bool Audio::StopPlayback() {
   if (!playing())
     return PP_TRUE;
   PluginDispatcher::GetForInstance(instance())->Send(
       new PpapiHostMsg_PPBAudio_StartOrStop(
           INTERFACE_ID_PPB_AUDIO, host_resource(), false));
   SetStopPlaybackState();
   return PP_TRUE;
 }
 
+int32_t Audio::OpenTrusted(PP_Resource config_id,
+                           PP_CompletionCallback create_callback) {
+  return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
+}
+
+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.
@@ skipping 32 matching lines @@
 // 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;
 
-  ::ppapi::thunk::EnterResourceNoLock< ::ppapi::thunk::PPB_AudioConfig_API>
-      config(config_id, true);
+  EnterResourceNoLock<PPB_AudioConfig_API> config(config_id, true);
   if (config.failed())
     return 0;
 
   HostResource result;
   dispatcher->Send(new PpapiHostMsg_PPBAudio_Create(
       INTERFACE_ID_PPB_AUDIO, instance_id,
       config.object()->GetSampleRate(), config.object()->GetSampleFrameCount(),
       &result));
   if (result.is_null())
     return 0;
@@ skipping 24 matching lines @@
       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())
     return;
-  ::ppapi::thunk::EnterResourceNoLock< ::ppapi::thunk::PPB_AudioTrusted_API>
-      trusted_audio(result->host_resource(), false);
-  if (trusted_audio.failed())
-    return;
+
+  // At this point, we've set the result resource, and this is a sync request.
+  // Anything below this point must issue the AudioChannelConnected callback
+  // to the browser. Since that's an async message, it will be issued back to
+  // the plugin after the Create function returns (which is good because it
+  // would be weird to get a connected message with a failure code for a
+  // resource you haven't finished creating yet).
+  //
+  // The ...ForceCallback class will help ensure the callback is always called.
+  // All error cases must call SetResult on this class.
+  EnterHostFromHostResourceForceCallback<PPB_Audio_API> enter(
+      *result, callback_factory_,
+      &PPB_Audio_Proxy::AudioChannelConnected, *result);
+  if (enter.failed())
+    return;  // When enter fails, it will internally schedule the callback.
 
   // Make an audio config object.
   PP_Resource audio_config_res =
       resource_creation.functions()->CreateAudioConfig(
           instance_id, static_cast<PP_AudioSampleRate>(sample_rate),
           sample_frame_count);
-  if (!audio_config_res)
+  if (!audio_config_res) {
+    enter.SetResult(PP_ERROR_FAILED);
     return;
+  }
 
   // Initiate opening the audio object.
-  CompletionCallback callback = callback_factory_.NewOptionalCallback(
-      &PPB_Audio_Proxy::AudioChannelConnected, *result);
-  int32_t open_error = trusted_audio.object()->OpenTrusted(
-      audio_config_res, callback.pp_completion_callback());
-  if (open_error != PP_OK_COMPLETIONPENDING)
-    callback.Run(open_error);
+  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));
   core->ReleaseResource(audio_config_res);
 }
 
 void PPB_Audio_Proxy::OnMsgStartOrStop(const HostResource& audio_id,
                                        bool play) {
   if (play)
@@ skipping 47 matching lines @@
   dispatcher()->Send(new PpapiMsg_PPBAudio_NotifyAudioStreamCreated(
       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 trusted audio interface which will give us the handles.
-  ::ppapi::thunk::EnterResourceNoLock< ::ppapi::thunk::PPB_AudioTrusted_API>
-      trusted_audio(resource.host_resource(), false);
-  if (trusted_audio.failed())
+  // Get the audio interface which will give us the handles.
+  EnterResourceNoLock<PPB_Audio_API> enter(resource.host_resource(), false);
+  if (enter.failed())
     return PP_ERROR_NOINTERFACE;
 
   // Get the socket handle for signaling.
   int32_t socket_handle;
-  int32_t result = trusted_audio.object()->GetSyncSocket(&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.
   *foreign_socket_handle = dispatcher()->ShareHandleWithRemote(
       IntToPlatformFile(socket_handle), false);
   if (*foreign_socket_handle == IPC::InvalidPlatformFileForTransit())
     return PP_ERROR_FAILED;
 
   // Get the shared memory for the buffer.
   int shared_memory_handle;
-  result = trusted_audio.object()->GetSharedMemory(&shared_memory_handle,
-                                                   shared_memory_length);
+  result = enter.object()->GetSharedMemory(&shared_memory_handle,
+                                           shared_memory_length);
   if (result != PP_OK)
     return result;
 
   // shared_memory_handle doesn't belong to us: don't close it.
   *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 pp