Change the cpp wrappers of audio input/video capture to use CompletionCallbackWithOutput.

ppapi/examples/video_capture/video_capture.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 <assert.h>
 #include <string.h>
 
 #include <map>
 #include <vector>
 
@@ skipping 100 matching lines @@
 
   // GL-related functions.
   void InitGL();
   GLuint CreateTexture(int32_t width, int32_t height, int unit);
   void CreateGLObjects();
   void CreateShader(GLuint program, GLenum type, const char* source, int size);
   void PaintFinished(int32_t result);
   void CreateYUVTextures();
 
   void Open(const pp::DeviceRef_Dev& device);
-  void EnumerateDevicesFinished(int32_t result);
+  void EnumerateDevicesFinished(int32_t result,
+                                std::vector<pp::DeviceRef_Dev>& devices);
   void OpenFinished(int32_t result);
 
   pp::Size position_size_;
   bool is_painting_;
   bool needs_paint_;
   GLuint texture_y_;
   GLuint texture_u_;
   GLuint texture_v_;
   pp::VideoCapture_Dev video_capture_;
   PP_VideoCaptureDeviceInfo_Dev capture_info_;
@@ skipping 46 matching lines @@
   // Initialize graphics.
   InitGL();
 
   Render();
 }
 
 void VCDemoInstance::HandleMessage(const pp::Var& message_data) {
   if (message_data.is_string()) {
     std::string event = message_data.AsString();
     if (event == "PageInitialized") {
-      pp::CompletionCallback callback = callback_factory_.NewCallback(
-          &VCDemoInstance::EnumerateDevicesFinished);
-      video_capture_.EnumerateDevices(&devices_, callback);
+      pp::CompletionCallbackWithOutput<std::vector<pp::DeviceRef_Dev> >
+          callback = callback_factory_.NewCallbackWithOutput(
+              &VCDemoInstance::EnumerateDevicesFinished);
+      video_capture_.EnumerateDevices(callback);
     } else if (event == "UseDefault") {
       Open(pp::DeviceRef_Dev());
     } else if (event == "UseDefault(v0.1)") {
       const PPB_VideoCapture_Dev_0_1* video_capture_0_1 =
           static_cast<const PPB_VideoCapture_Dev_0_1*>(
               pp::Module::Get()->GetBrowserInterface(
                   PPB_VIDEOCAPTURE_DEV_INTERFACE_0_1));
       video_capture_0_1->StartCapture(video_capture_.pp_resource(),
                                       &capture_info_, 4);
     } else if (event == "Stop") {
@@ skipping 195 matching lines @@
   texture_u_ = CreateTexture(width, height, 1);
   texture_v_ = CreateTexture(width, height, 2);
 }
 
 void VCDemoInstance::Open(const pp::DeviceRef_Dev& device) {
   pp::CompletionCallback callback = callback_factory_.NewCallback(
       &VCDemoInstance::OpenFinished);
   video_capture_.Open(device, capture_info_, 4, callback);
 }
 
-void VCDemoInstance::EnumerateDevicesFinished(int32_t result) {
+void VCDemoInstance::EnumerateDevicesFinished(
+    int32_t result,
+    std::vector<pp::DeviceRef_Dev>& devices) {
   static const char* const kDelimiter = "#__#";
 
   if (result == PP_OK) {
+    devices_.swap(devices);
     std::string device_names;
     for (size_t index = 0; index < devices_.size(); ++index) {
       pp::Var name = devices_[index].GetName();
       assert(name.is_string());
 
       if (index != 0)
         device_names += kDelimiter;
       device_names += name.AsString();
     }
     PostMessage(pp::Var(device_names));
@@ skipping 15 matching lines @@
 }
 
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new VCDemoModule();
 }
 }  // namespace pp