Fix some bugs with incorrect ! (both missing and extra) in the proxy error ha...

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"
 #include "ppapi/c/ppb_audio.h"
 #include "ppapi/c/trusted/ppb_audio_trusted.h"
@@ skipping 167 matching lines @@
 void PPB_Audio_Proxy::OnMsgStartOrStop(const HostResource& audio_id,
                                        bool play) {
   if (play)
     ppb_audio_target()->StartPlayback(audio_id.host_resource());
   else
     ppb_audio_target()->StopPlayback(audio_id.host_resource());
 }
 
 // Processed in the plugin (message from host).
 void PPB_Audio_Proxy::OnMsgNotifyAudioStreamCreated(
-    const PPBAudio_NotifyAudioStreamCreated_Params& params) {
+    const HostResource& audio_id,
+    int32_t result_code,
+    IPC::PlatformFileForTransit socket_handle,
+    base::SharedMemoryHandle handle,
+    uint32_t length) {
   PP_Resource plugin_resource =
       PluginResourceTracker::GetInstance()->PluginResourceForHostResource(
-          params.audio_id);
+          audio_id);
   Audio* object = plugin_resource ?
       PluginResource::GetAs<Audio>(plugin_resource) : NULL;
-  if (!object || params.result_code != PP_OK) {
+  if (!object || result_code != PP_OK) {
     // The caller may still have given us these handles in the failure case.
     // The easiest way to clean these up is to just put them in the objects
     // and then close them. This failure case is not performance critical.
     base::SyncSocket temp_socket(
-        IPC::PlatformFileForTransitToPlatformFile(params.socket_handle));
-    base::SharedMemory temp_mem(params.handle, false);
+        IPC::PlatformFileForTransitToPlatformFile(socket_handle));
+    base::SharedMemory temp_mem(handle, false);
     return;
   }
   object->SetStreamInfo(
-      params.handle, params.length,
-      IPC::PlatformFileForTransitToPlatformFile(params.socket_handle));
+      handle, length, IPC::PlatformFileForTransitToPlatformFile(socket_handle));
 }
 
 void PPB_Audio_Proxy::AudioChannelConnected(
     int32_t result,
     const HostResource& resource) {
   IPC::PlatformFileForTransit socket_handle =
       IPC::InvalidPlatformFileForTransit();
 #if defined(OS_WIN)
   base::SharedMemoryHandle shared_memory = NULL;
 #elif defined(OS_POSIX)
   base::SharedMemoryHandle shared_memory(-1, false);
 #else
   #error Not implemented.
 #endif
   uint32_t shared_memory_length = 0;
 
   int32_t result_code = result;
   if (result_code == PP_OK) {
     result_code = GetAudioConnectedHandles(resource, &socket_handle,
                                            &shared_memory,
                                            &shared_memory_length);
   }
 
   // Send all the values, even on error. This simplifies some of our cleanup
   // code since the handles will be in the other process and could be
   // inconvenient to clean up. Our IPC code will automatically handle this for
   // us, as long as the remote side always closes the handles it receives
   // (in OnMsgNotifyAudioStreamCreated), even in the failure case.
-  PPBAudio_NotifyAudioStreamCreated_Params params;
-  params.audio_id = resource;
-  params.result_code = result;
-  params.socket_handle = socket_handle;
-  params.handle = shared_memory;
-  params.length = shared_memory_length;
   dispatcher()->Send(new PpapiMsg_PPBAudio_NotifyAudioStreamCreated(
-      INTERFACE_ID_PPB_AUDIO, params));
+      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.
   const PPB_AudioTrusted* audio_trusted =
       reinterpret_cast<const PPB_AudioTrusted*>(
@@ skipping 44 matching lines @@
   // close the source handle.
   if (!shared_memory.GiveToProcess(dispatcher()->remote_process_handle(),
                                    foreign_shared_memory_handle))
     return PP_ERROR_FAILED;
 
   return PP_OK;
 }
 
 }  // namespace proxy
 }  // namespace pp