Implement host side of sync EnumerateVideoCaptureDevices

ppapi/examples/enumerate_devices/enumerate_devices.cc

Index: ppapi/examples/enumerate_devices/enumerate_devices.cc
diff --git a/ppapi/examples/enumerate_devices/enumerate_devices.cc b/ppapi/examples/enumerate_devices/enumerate_devices.cc
new file mode 100644
index 0000000000000000000000000000000000000000..af8cf7d65c79edec589cb1412bc7acc18f7f81f5
--- /dev/null
+++ b/ppapi/examples/enumerate_devices/enumerate_devices.cc
@@ -0,0 +1,129 @@
+// 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 <vector>
+
+#include "ppapi/c/dev/ppb_video_capture_dev.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/cpp/dev/device_ref_dev.h"
+#include "ppapi/cpp/dev/video_capture_dev.h"
+#include "ppapi/cpp/dev/video_capture_client_dev.h"
+#include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/module.h"
+#include "ppapi/cpp/private/flash.h"
+#include "ppapi/cpp/var.h"
+#include "ppapi/utility/completion_callback_factory.h"
+
+// When compiling natively on Windows, PostMessage can be #define-d to
+// something else.
+#ifdef PostMessage
+#undef PostMessage
+#endif
+
+namespace {
+
+// This object is the global object representing this plugin library as long
+// as it is loaded.
+class EnumerateDevicesDemoModule : public pp::Module {
+ public:
+  EnumerateDevicesDemoModule() : pp::Module() {}
+  virtual ~EnumerateDevicesDemoModule() {}
+  virtual pp::Instance* CreateInstance(PP_Instance instance);
+};
+
+class EnumerateDevicesDemoInstance : public pp::Instance,
+                                     public pp::VideoCaptureClient_Dev {
+ public:
+  EnumerateDevicesDemoInstance(PP_Instance instance, pp::Module* module);
+  virtual ~EnumerateDevicesDemoInstance();
+
+  // pp::Instance implementation (see PPP_Instance).
+  virtual void DidChangeView(const pp::Rect& position,

[yzshen1, 2012/10/10 18:17:39]

No need to define it if it is empty.

[raymes, 2012/10/11 18:39:26]

Done.

+                             const pp::Rect& clip_ignored) {}
+  virtual void HandleMessage(const pp::Var& message_data);
+
+  // pp::VideoCaptureClient_Dev implementation.
+  virtual void OnDeviceInfo(PP_Resource resource,
+                            const PP_VideoCaptureDeviceInfo_Dev& info,
+                            const std::vector<pp::Buffer_Dev>& buffers) {}
+  virtual void OnStatus(PP_Resource resource, uint32_t status) {}
+  virtual void OnError(PP_Resource resource, uint32_t error) {}
+  virtual void OnBufferReady(PP_Resource resource, uint32_t buffer) {}
+
+ private:
+  void EnumerateDevicesFinished(int32_t result,
+                                std::vector<pp::DeviceRef_Dev>& devices);
+
+  pp::VideoCapture_Dev video_capture_;
+  pp::CompletionCallbackFactory<EnumerateDevicesDemoInstance> callback_factory_;
+
+  std::vector<pp::DeviceRef_Dev> devices_;
+};
+
+EnumerateDevicesDemoInstance::EnumerateDevicesDemoInstance(PP_Instance instance,
+                                                           pp::Module* module)
+    : pp::Instance(instance),
+      pp::VideoCaptureClient_Dev(this),
+      video_capture_(this),
+      callback_factory_(this) {
+}
+
+EnumerateDevicesDemoInstance::~EnumerateDevicesDemoInstance() {
+}
+
+void EnumerateDevicesDemoInstance::HandleMessage(const pp::Var& message_data) {
+  if (message_data.is_string()) {
+    std::string event = message_data.AsString();
+    if (event == "EnumerateDevicesAsync") {
+      pp::CompletionCallbackWithOutput<std::vector<pp::DeviceRef_Dev> >
+          callback = callback_factory_.NewCallbackWithOutput(
+              &EnumerateDevicesDemoInstance::EnumerateDevicesFinished);
+      video_capture_.EnumerateDevices(callback);
+    } else if (event == "EnumerateDevicesSync") {
+      std::vector<pp::DeviceRef_Dev> devices;
+      int32_t result = pp::flash::Flash::EnumerateVideoDevicesSync(
+          this, video_capture_, &devices);
+      EnumerateDevicesFinished(result, devices);
+    }
+  }
+}
+
+void EnumerateDevicesDemoInstance::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("EnumerationSuccess" + device_names));
+  } else {
+    PostMessage(pp::Var("EnumerationFailed"));
+  }
+}
+
+pp::Instance* EnumerateDevicesDemoModule::CreateInstance(PP_Instance instance) {
+  return new EnumerateDevicesDemoInstance(instance, this);
+}
+
+}  // anonymous namespace
+
+namespace pp {
+// Factory function for your specialization of the Module object.
+Module* CreateModule() {
+  return new EnumerateDevicesDemoModule();
+}
+}  // namespace pp