Corresponding change in Pepper since EnumerateDevices contract is changed.

ppapi/proxy/ppb_audio_input_proxy.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/proxy/ppb_audio_input_proxy.h"
 
 #include "base/compiler_specific.h"
 #include "ppapi/c/dev/ppb_audio_input_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_audio_config.h"
@@ skipping 28 matching lines @@
       scoped_refptr<TrackedCallback> create_callback) OVERRIDE;
   virtual int32_t GetSyncSocket(int* sync_socket) OVERRIDE;
   virtual int32_t GetSharedMemory(int* shm_handle, uint32_t* shm_size) OVERRIDE;
   virtual const std::vector<DeviceRefData>& GetDeviceRefData() const OVERRIDE;
 
  private:
   // PPB_AudioInput_Shared implementation.
   virtual int32_t InternalEnumerateDevices(
       PP_Resource* devices,
       scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t InternalStopEnumerateDevices(PP_Resource* devices) OVERRIDE;
   virtual int32_t InternalOpen(
       const std::string& device_id,
       PP_AudioSampleRate sample_rate,
       uint32_t sample_frame_count,
       scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual PP_Bool InternalStartCapture() OVERRIDE;
   virtual PP_Bool InternalStopCapture() OVERRIDE;
   virtual void InternalClose() OVERRIDE;
 
   PluginDispatcher* GetDispatcher() const {
@@ skipping 35 matching lines @@
 int32_t AudioInput::InternalEnumerateDevices(
     PP_Resource* devices,
     scoped_refptr<TrackedCallback> callback) {
   devices_ = devices;
   enumerate_devices_callback_ = callback;
   GetDispatcher()->Send(new PpapiHostMsg_PPBAudioInput_EnumerateDevices(
       API_ID_PPB_AUDIO_INPUT_DEV, host_resource()));
   return PP_OK_COMPLETIONPENDING;
 }
 
+int32_t AudioInput::InternalStopEnumerateDevices(PP_Resource* devices) {
+  if (devices_ == devices) {
+    GetDispatcher()->Send(new PpapiHostMsg_PPBAudioInput_EnumerateDevices(
+        API_ID_PPB_AUDIO_INPUT_DEV, host_resource()));
+  }
+  return PP_OK;
+}
+
 int32_t AudioInput::InternalOpen(const std::string& device_id,
                                  PP_AudioSampleRate sample_rate,
                                  uint32_t sample_frame_count,
                                  scoped_refptr<TrackedCallback> callback) {
   open_callback_ = callback;
   GetDispatcher()->Send(new PpapiHostMsg_PPBAudioInput_Open(
       API_ID_PPB_AUDIO_INPUT_DEV, host_resource(), device_id, sample_rate,
       sample_frame_count));
   return PP_OK_COMPLETIONPENDING;
 }
@@ skipping 66 matching lines @@
 
   return (new AudioInput(result))->GetReference();
 }
 
 bool PPB_AudioInput_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_AudioInput_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudioInput_Create, OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudioInput_EnumerateDevices,
                         OnMsgEnumerateDevices)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudioInput_StopEnumerateDevices,
+                        OnMsgStopEnumerateDevices)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudioInput_Open, OnMsgOpen)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudioInput_StartOrStop,
                         OnMsgStartOrStop)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudioInput_Close, OnMsgClose)
 
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBAudioInput_EnumerateDevicesACK,
                         OnMsgEnumerateDevicesACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBAudioInput_OpenACK, OnMsgOpenACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 14 matching lines @@
 void PPB_AudioInput_Proxy::OnMsgEnumerateDevices(
     const ppapi::HostResource& audio_input) {
   EnterHostFromHostResourceForceCallback<PPB_AudioInput_API> enter(
       audio_input, callback_factory_,
       &PPB_AudioInput_Proxy::EnumerateDevicesACKInHost, audio_input);
 
   if (enter.succeeded())
     enter.SetResult(enter.object()->EnumerateDevices(NULL, enter.callback()));
 }
 
+void PPB_AudioInput_Proxy::OnMsgStopEnumerateDevices(
+    const ppapi::HostResource& audio_input) {
+  EnterHostFromHostResource<PPB_AudioInput_API> enter(audio_input);
+  if (enter.succeeded())
+    enter.object()->StopEnumerateDevices(NULL);
+}
+
 void PPB_AudioInput_Proxy::OnMsgOpen(const ppapi::HostResource& audio_input,
                                      const std::string& device_id,
                                      int32_t sample_rate,
                                      uint32_t sample_frame_count) {
   // The ...ForceCallback class will help ensure the callback is always called.
   // All error cases must call SetResult on this class.
   EnterHostFromHostResourceForceCallback<PPB_AudioInput_API> enter(
       audio_input, callback_factory_, &PPB_AudioInput_Proxy::OpenACKInHost,
       audio_input);
   if (enter.failed())
@@ skipping 136 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