Corresponding change in Pepper since EnumerateDevices contract is changed.

ppapi/shared_impl/ppb_audio_input_shared.cc

 // Copyright (c) 2012 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/shared_impl/ppb_audio_input_shared.h"
 
 #include "base/logging.h"
 #include "media/audio/audio_parameters.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
@@ skipping 44 matching lines @@
 
 int32_t PPB_AudioInput_Shared::EnumerateDevices(
     PP_Resource* devices,
     scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(enumerate_devices_callback_))
     return PP_ERROR_INPROGRESS;
 
   return InternalEnumerateDevices(devices, callback);
 }
 
+int32_t PPB_AudioInput_Shared::StopEnumerateDevices(PP_Resource* devices) {
+  devices_ = NULL;
+  enumerate_devices_callback_ = NULL;
+  return InternalStopEnumerateDevices(devices);
+}
+
 int32_t PPB_AudioInput_Shared::Open(
     const std::string& device_id,
     PP_Resource config,
     PPB_AudioInput_Callback audio_input_callback,
     void* user_data,
     scoped_refptr<TrackedCallback> callback) {
   if (!audio_input_callback)
     return PP_ERROR_BADARGUMENT;
 
   return CommonOpen(device_id, config, audio_input_callback, user_data,
@@ skipping 56 matching lines @@
 
 void PPB_AudioInput_Shared::OnEnumerateDevicesComplete(
     int32_t result,
     const std::vector<DeviceRefData>& devices) {
   DCHECK(TrackedCallback::IsPending(enumerate_devices_callback_));
 
   if (result == PP_OK && devices_) {
     *devices_ = PPB_DeviceRef_Shared::CreateResourceArray(
         resource_object_type_, pp_instance(), devices);
   }
-  devices_ = NULL;
 
-  TrackedCallback::ClearAndRun(&enumerate_devices_callback_, result);
+  enumerate_devices_callback_->Run(result);

[viettrungluu, 2012/08/02 02:36:14]

You can't use a completion callback any more. Completion callbacks are, by
definition, always run *exactly* once.

You have to define a version of the Pepper APIs, and support the old version,
providing exact (including semantic) backwards compatibility.

(So, for the implementation of the old version, in OnEnumerateDevicesComplete(),
you would still ClearAndRun(), but you would also need to stop enumeration ...
being careful to avoid/handle races.)

 }
 
 void PPB_AudioInput_Shared::OnOpenComplete(
     int32_t result,
     base::SharedMemoryHandle shared_memory_handle,
     size_t shared_memory_size,
     base::SyncSocket::Handle socket_handle) {
   if (open_state_ == BEFORE_OPEN && result == PP_OK) {
     open_state_ = OPENED;
     SetStreamInfo(shared_memory_handle, shared_memory_size, socket_handle);
@@ skipping 115 matching lines @@
 
   config_ = config;
   audio_input_callback_ = audio_input_callback;
   user_data_ = user_data;
 
   return InternalOpen(device_id, enter_config.object()->GetSampleRate(),
                       enter_config.object()->GetSampleFrameCount(), callback);
 }
 
 }  // namespace ppapi