Corresponding change in Pepper since EnumerateDevices contract is changed.

ppapi/proxy/ppb_video_capture_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_video_capture_proxy.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 147 matching lines @@
   void SetBufferInUse(uint32_t buffer) {
     DCHECK(buffer < buffer_in_use_.size());
     buffer_in_use_[buffer] = true;
   }
 
  private:
   // PPB_VideoCapture_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,
       const PP_VideoCaptureDeviceInfo_Dev& requested_info,
       uint32_t buffer_count,
       scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t InternalStartCapture() OVERRIDE;
   virtual int32_t InternalReuseBuffer(uint32_t buffer) OVERRIDE;
   virtual int32_t InternalStopCapture() OVERRIDE;
   virtual void InternalClose() OVERRIDE;
   virtual int32_t InternalStartCapture0_1(
@@ skipping 38 matching lines @@
 int32_t VideoCapture::InternalEnumerateDevices(
     PP_Resource* devices,
     scoped_refptr<TrackedCallback> callback) {
   devices_ = devices;
   enumerate_devices_callback_ = callback;
   GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_EnumerateDevices(
       API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource()));
   return PP_OK_COMPLETIONPENDING;
 }
 
+int32_t VideoCapture::InternalStopEnumerateDevices(PP_Resource* devices) {
+  if (devices_ == devices) {
+    GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_StopEnumerateDevices(
+        API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource()));
+  }
+  return PP_OK;
+}
+
 int32_t VideoCapture::InternalOpen(
     const std::string& device_id,
     const PP_VideoCaptureDeviceInfo_Dev& requested_info,
     uint32_t buffer_count,
     scoped_refptr<TrackedCallback> callback) {
   open_callback_ = callback;
   GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_Open(
       API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource(), device_id, requested_info,
       buffer_count));
   return PP_OK_COMPLETIONPENDING;
@@ skipping 64 matching lines @@
     return 0;
   return (new VideoCapture(result))->GetReference();
 }
 
 bool PPB_VideoCapture_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_VideoCapture_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_Create, OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_EnumerateDevices,
                         OnMsgEnumerateDevices)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_StopEnumerateDevices,
+                        OnMsgStopEnumerateDevices)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_Open, OnMsgOpen)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_StartCapture,
                         OnMsgStartCapture)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_ReuseBuffer,
                         OnMsgReuseBuffer)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_StopCapture,
                         OnMsgStopCapture)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_Close, OnMsgClose)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_StartCapture0_1,
                         OnMsgStartCapture0_1)
@@ skipping 21 matching lines @@
 void PPB_VideoCapture_Proxy::OnMsgEnumerateDevices(
     const HostResource& resource) {
   EnterHostFromHostResourceForceCallback<PPB_VideoCapture_API> enter(
       resource, callback_factory_,
       &PPB_VideoCapture_Proxy::EnumerateDevicesACKInHost, resource);
 
   if (enter.succeeded())
     enter.SetResult(enter.object()->EnumerateDevices(NULL, enter.callback()));
 }
 
+void PPB_VideoCapture_Proxy::OnMsgStopEnumerateDevices(
+    const HostResource& resource) {
+  EnterHostFromHostResource<PPB_VideoCapture_API> enter(resource);
+  if (enter.succeeded())
+    enter.object()->StopEnumerateDevices(NULL);
+}
+
 void PPB_VideoCapture_Proxy::OnMsgOpen(
     const ppapi::HostResource& resource,
     const std::string& device_id,
     const PP_VideoCaptureDeviceInfo_Dev& info,
     uint32_t buffers) {
   EnterHostFromHostResourceForceCallback<PPB_VideoCapture_API> enter(
       resource, callback_factory_, &PPB_VideoCapture_Proxy::OpenACKInHost,
       resource);
 
   if (enter.succeeded()) {
@@ skipping 173 matching lines @@
     return;
 
   VideoCapture* capture = static_cast<VideoCapture*>(enter.object());
   capture->SetBufferInUse(buffer);
   ppp_video_capture_impl_->OnBufferReady(
       host_resource.instance(), capture->pp_resource(), buffer);
 }
 
 }  // namespace proxy
 }  // namespace ppapi