[M108 Migration][MM] Handle User Permission popup.

Code added for handling user permission popup. It will
show popup when user requested for mic and camera.

Reference: https://review.tizen.org/gerrit/279728/

Change-Id: I970f253c62fb572c6321df58c44016c33c5076cd
Signed-off-by: Koyyani Maheswari <m.koyyani@samsung.com>

diff --git a/tizen_src/ewk/efl_integration/private/ewk_user_media_private.cc b/tizen_src/ewk/efl_integration/private/ewk_user_media_private.cc
index 04b2875..9dd0f37 100644 (file)
--- a/tizen_src/ewk/efl_integration/private/ewk_user_media_private.cc
+++ b/tizen_src/ewk/efl_integration/private/ewk_user_media_private.cc
@@ -20,11 +20,17 @@ _Ewk_User_Media_Permission_Request::_Ewk_User_Media_Permission_Request(
 void _Ewk_User_Media_Permission_Request::ProceedPermissionCallback(bool allowed) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
-  if(allowed)
-    web_contents_->RequestMediaAccessAllow(request_, std::move(callback_));
-  else
-    web_contents_->RequestMediaAccessDeny(request_, std::move(callback_));
+#if defined(TIZEN_MULTIMEDIA)
+  if (callback_) {
+    Decide(allowed);
+    if (allowed)
+      web_contents_->RequestMediaAccessAllow(request_, std::move(callback_));
+    else
+      web_contents_->RequestMediaAccessDeny(request_, std::move(callback_));
+  } else {
+    LOG(WARNING) << "User Media Permission request type: "
+                 << request_.request_type << " was already resolved";
+  }
 #endif
 
   if (suspended_) {

diff --git a/tizen_src/ewk/efl_integration/public/ewk_user_media.cc b/tizen_src/ewk/efl_integration/public/ewk_user_media.cc
index ab6eb8d..78f6012 100644 (file)
--- a/tizen_src/ewk/efl_integration/public/ewk_user_media.cc
+++ b/tizen_src/ewk/efl_integration/public/ewk_user_media.cc
@@ -38,23 +38,27 @@ Eina_Bool ewk_user_media_permission_request_suspend(
 
 void ewk_user_media_permission_request_set(
     Ewk_User_Media_Permission_Request* request, Eina_Bool allowed) {
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
+#if defined(TIZEN_MULTIMEDIA)
   if(request && request->WebContents())
     request->ProceedPermissionCallback(allowed == EINA_TRUE);
+#else
+  LOG_EWK_API_MOCKUP();
 #endif
 }
 
 void ewk_user_media_permission_reply(
     Ewk_User_Media_Permission_Request* request, Eina_Bool allowed) {
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
+#if defined(TIZEN_MULTIMEDIA)
   if(request && request->WebContents())
     request->ProceedPermissionCallback(allowed == EINA_TRUE);
+#else
+  LOG_EWK_API_MOCKUP();
 #endif
 }
 
 const Ewk_Security_Origin* ewk_user_media_permission_request_origin_get(
     const Ewk_User_Media_Permission_Request* request) {
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
+#if defined(TIZEN_MULTIMEDIA)
   EINA_SAFETY_ON_NULL_RETURN_VAL(request, 0);
 
   return static_cast<const Ewk_Security_Origin*>(request->Origin());

diff --git a/tizen_src/ewk/efl_integration/web_contents_delegate_efl.cc b/tizen_src/ewk/efl_integration/web_contents_delegate_efl.cc
index c46ab42..b911043 100644 (file)
--- a/tizen_src/ewk/efl_integration/web_contents_delegate_efl.cc
+++ b/tizen_src/ewk/efl_integration/web_contents_delegate_efl.cc
@@ -46,9 +46,10 @@
 #include <app_manager.h>
 #endif
 
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
+#if defined(TIZEN_MULTIMEDIA)
+#include "base/functional/callback.h"
 #include "content/public/browser/media_capture_devices.h"
-#include "media/capture/video/tizen/video_capture_device_tizen.h"
+#include "third_party/blink/public/mojom/mediastream/media_stream.mojom.h"
 #endif
 
 #if defined(TIZEN_AUTOFILL_SUPPORT)
@@ -72,17 +73,46 @@ using namespace ui;
 
 namespace content {
 
-#if BUILDFLAG(IS_TIZEN) && defined(TIZEN_MULTIMEDIA_SUPPORT)
-static const MediaStreamDevice* GetRequestedVideoDevice(
+#if BUILDFLAG(IS_TIZEN) && defined(TIZEN_MULTIMEDIA)
+static const blink::MediaStreamDevice* GetRequestedAudioDevice(
     const std::string& device_id) {
-  const MediaStreamDevices& video_devices =
+  const blink::MediaStreamDevices& audio_devices =
+      MediaCaptureDevices::GetInstance()->GetAudioCaptureDevices();
+  if (audio_devices.empty())
+    return NULL;
+  if (device_id.length() == 0)
+    return &(*audio_devices.begin());
+
+  for (blink::MediaStreamDevices::const_iterator i = audio_devices.begin();
+       i != audio_devices.end(); i++) {
+    if (i->id.compare(device_id) == 0)
+      return &(*i);
+  }
+
+  NOTREACHED();
+  return nullptr;
+}
+
+/* LCOV_EXCL_START */
+static const blink::MediaStreamDevice* GetRequestedVideoDevice(
+    const std::string& device_id) {
+  const blink::MediaStreamDevices& video_devices =
       MediaCaptureDevices::GetInstance()->GetVideoCaptureDevices();
   if (video_devices.empty())
-    return NULL;
+    return nullptr;
   if (device_id.length() == 0)
     return &(*video_devices.begin());
-  return video_devices.FindById(device_id);
+
+  for (blink::MediaStreamDevices::const_iterator i = video_devices.begin();
+       i != video_devices.end(); i++) {
+    if (i->id.compare(device_id) == 0)
+      return &(*i);
+  }
+
+  NOTREACHED();
+  return nullptr;
 }
+/* LCOV_EXCL_STOP */
 #endif
 
 WebContentsDelegateEfl::WebContentsDelegateEfl(EWebView* view)
@@ -234,49 +264,65 @@ bool WebContentsDelegateEfl::IsFullscreenForTabOrPending(
   return is_fullscreen_;
 }
 
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
+#if defined(TIZEN_MULTIMEDIA)
+/* LCOV_EXCL_START */
 void WebContentsDelegateEfl::RequestMediaAccessAllow(
     const MediaStreamRequest& request,
     MediaResponseCallback callback) {
-  MediaStreamDevices devices;
-
-  if (request.audio_type == MEDIA_DEVICE_AUDIO_CAPTURE) {
-    devices.push_back(
-        MediaStreamDevice(request.audio_type, "default", "Default"));
+  blink::mojom::StreamDevicesSet stream_devices_set;
+  stream_devices_set.stream_devices.emplace_back(
+      blink::mojom::StreamDevices::New());
+  blink::mojom::StreamDevices& stream_devices =
+      *stream_devices_set.stream_devices[0];
+
+  if (request.audio_type ==
+      blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE) {
+    const blink::MediaStreamDevice* audio_device =
+        GetRequestedAudioDevice(request.requested_audio_device_id);
+    if (audio_device) {
+      stream_devices.audio_device = *audio_device;
+    } else {
+      std::move(callback).Run(
+          blink::mojom::StreamDevicesSet(),
+          blink::mojom::MediaStreamRequestResult::NOT_SUPPORTED,
+          std::unique_ptr<MediaStreamUI>());
+      return;
+    }
   }
 
-  if (request.video_type == MEDIA_DEVICE_VIDEO_CAPTURE) {
-#if BUILDFLAG(IS_TIZEN)
-    const MediaStreamDevice* video_device =
+  if (request.video_type ==
+      blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE) {
+    const blink::MediaStreamDevice* video_device =
         GetRequestedVideoDevice(request.requested_video_device_id);
     if (video_device) {
-      devices.push_back(*video_device);
+      stream_devices.video_device = *video_device;
     } else {
-      std::move(callback).Run(MediaStreamDevices(), MEDIA_DEVICE_NOT_SUPPORTED,
-                              std::unique_ptr<MediaStreamUI>());
+      std::move(callback).Run(
+          blink::mojom::StreamDevicesSet(),
+          blink::mojom::MediaStreamRequestResult::NOT_SUPPORTED,
+          std::unique_ptr<MediaStreamUI>());
+      return;
     }
-#else
-    devices.push_back(
-        MediaStreamDevice(request.video_type, "/dev/video0", "1"));
-#endif
   }
 
-  std::move(callback).Run(devices, MEDIA_DEVICE_OK,
+  std::move(callback).Run(stream_devices_set,
+                          blink::mojom::MediaStreamRequestResult::OK,
                           std::unique_ptr<MediaStreamUI>());
 }
+/* LCOV_EXCL_STOP */
 
 void WebContentsDelegateEfl::RequestMediaAccessDeny(
     const MediaStreamRequest& request,
     MediaResponseCallback callback) {
-  LOG(ERROR) << __FUNCTION__ << " Decline request with empty list";
-  std::move(callback).Run(MediaStreamDevices(), MEDIA_DEVICE_NOT_SUPPORTED,
+  std::move(callback).Run(blink::mojom::StreamDevicesSet(),
+                          blink::mojom::MediaStreamRequestResult::NOT_SUPPORTED,
                           std::unique_ptr<MediaStreamUI>());
 }
 
 bool WebContentsDelegateEfl::CheckMediaAccessPermission(
-    WebContents* web_contents,
+    RenderFrameHost* render_frame_host,
     const GURL& security_origin,
-    MediaStreamType type) {
+    blink::mojom::MediaStreamType type) {
   return true;
 }
 
@@ -291,18 +337,19 @@ void WebContentsDelegateEfl::RequestMediaAccessPermission(
   Eina_Bool callback_result = EINA_FALSE;
   if (!web_view_->InvokeViewUserMediaPermissionCallback(
           media_permission_request.get(), &callback_result)) {
-    web_view_->SmartCallback<EWebViewCallbacks::UserMediaPermission>().call(
-        media_permission_request.get());
+    web_view_->SmartCallback<EWebViewCallbacks::UserMediaPermission>()
+        .call(  // LCOV_EXCL_LINE
+            media_permission_request.get());
   }
 
   // if policy is suspended, the API takes over the policy object lifetime
   // and policy will be deleted after decision is made
   if (media_permission_request->IsSuspended())
-    ignore_result(media_permission_request.release());
-  else if (!media_permission_request->IsDecided()) {
-    callback.Run(MediaStreamDevices(), MEDIA_DEVICE_NOT_SUPPORTED,
-                 std::unique_ptr<MediaStreamUI>());
-  }
+    std::ignore = media_permission_request.release();
+  /* LCOV_EXCL_START */
+  else if (!media_permission_request->IsDecided())
+    media_permission_request->ProceedPermissionCallback(false);
+  /* LCOV_EXCL_STOP */
 }
 #endif
 

diff --git a/tizen_src/ewk/efl_integration/web_contents_delegate_efl.h b/tizen_src/ewk/efl_integration/web_contents_delegate_efl.h
index 3979005..4fbbb1f 100644 (file)
--- a/tizen_src/ewk/efl_integration/web_contents_delegate_efl.h
+++ b/tizen_src/ewk/efl_integration/web_contents_delegate_efl.h
@@ -117,17 +117,18 @@ class WebContentsDelegateEfl : public WebContentsDelegate {
                       const GURL& url,
                       LoginDelegateEfl* login_delegate);
 
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
-  virtual bool CheckMediaAccessPermission(WebContents* web_contents,
-                                          const GURL& security_origin,
-                                          MediaStreamType type) override;
+#if defined(TIZEN_MULTIMEDIA)
+  bool CheckMediaAccessPermission(RenderFrameHost* render_frame_host,
+                                  const GURL& security_origin,
+                                  blink::mojom::MediaStreamType type) override;
+
+  void RequestMediaAccessPermission(WebContents* web_contents,
+                                    const MediaStreamRequest& request,
+                                    MediaResponseCallback callback) override;
 
-  virtual void RequestMediaAccessPermission(
-      WebContents* web_contents,
-      const MediaStreamRequest& request,
-      MediaResponseCallback callback) override;
   void RequestMediaAccessAllow(const MediaStreamRequest& request,
                                MediaResponseCallback callback);
+
   void RequestMediaAccessDeny(const MediaStreamRequest& request,
                               MediaResponseCallback callback);
 #endif