webview: add permission-request event

atom/browser/web_contents_permission_helper.cc

@@ -0,0 +1,114 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/web_contents_permission_helper.h"
+
+#include <string>
+
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "content/public/browser/media_capture_devices.h"
+
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(atom::WebContentsPermissionHelper);
+
+namespace atom {
+
+namespace {
+
+const content::MediaStreamDevice* FindDeviceWithId(
+    const content::MediaStreamDevices& devices,
+    const std::string& device_id) {
+  if (device_id.empty())
+    return &(*devices.begin());
+  for (const auto& iter : devices)
+    if (iter.id == device_id)
+      return &(iter);
+  return nullptr;
+}
+
+void MediaAccessAllowed(
+    const content::MediaStreamRequest& request,
+    const content::MediaResponseCallback& callback) {
+  content::MediaStreamDevices devices;
+  content::MediaStreamRequestResult result = content::MEDIA_DEVICE_NO_HARDWARE;
+
+  if (request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE) {
+    const content::MediaStreamDevices& audio_devices =
+        content::MediaCaptureDevices::GetInstance()->GetAudioCaptureDevices();
+    const content::MediaStreamDevice* audio_device =
+        FindDeviceWithId(audio_devices, request.requested_audio_device_id);
+    if (audio_device)
+      devices.push_back(*audio_device);
+  }
+
+  if (request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE) {
+    const content::MediaStreamDevices& video_devices =
+        content::MediaCaptureDevices::GetInstance()->GetVideoCaptureDevices();
+    const content::MediaStreamDevice* video_device =
+        FindDeviceWithId(video_devices, request.requested_video_device_id);
+    if (video_device)
+      devices.push_back(*video_device);
+  }
+
+  if (!devices.empty())
+    result = content::MEDIA_DEVICE_OK;
+
+  callback.Run(devices, result, scoped_ptr<content::MediaStreamUI>());
+}
+
+}  // namespace
+
+WebContentsPermissionHelper::WebContentsPermissionHelper(
+    content::WebContents* web_contents,
+    api::WebContents* api_web_contents)
+    : api_web_contents_(api_web_contents) {
+  web_contents->SetUserData(UserDataKey(), this);
+}
+
+WebContentsPermissionHelper::~WebContentsPermissionHelper() {
+}
+
+void WebContentsPermissionHelper::RequestMediaAccessPermission(
+    const content::MediaStreamRequest& request,
+    const content::MediaResponseCallback& callback) {
+  if (api_web_contents_->IsGuest()) {
+    const std::string& permission = "media";
+    permission_map_[permission] = base::Bind(&MediaAccessAllowed,
+                                             request,
+                                             callback);
+    api_web_contents_->Emit(
+        "permission-request",
+        permission,
+        base::Bind(&WebContentsPermissionHelper::OnPermissionResponse,
+                   base::Unretained(this), permission));
+    return;
+  }
+  MediaAccessAllowed(request, callback);
+}
+
+void WebContentsPermissionHelper::RequestWebNotificationPermission(
+    const base::Closure& callback) {
+  if (api_web_contents_->IsGuest()) {
+    const std::string& permission = "webNotification";
+    permission_map_[permission] = callback;
+    api_web_contents_->Emit(
+        "permission-request",
+        permission,
+        base::Bind(&WebContentsPermissionHelper::OnPermissionResponse,
+                   base::Unretained(this), permission));
+    return;
+  }
+  callback.Run();
+}
+
+void WebContentsPermissionHelper::OnPermissionResponse(
+    const std::string& permission, bool allowed) {
+  auto it = permission_map_.find(permission);
+  if (it != permission_map_.end()) {
+    if (allowed)
+      it->second.Run();
+    permission_map_.erase(permission);
+  }
+}
+
+}  // namespace atom