Handle media access permission callback.

Patch handles the user permission of accesing the video input device.

Issue Id: CBMM-21

Change-Id: Iac2e8af1800e3dfd35dd0f6effd35ee1654545a0

diff --git a/tizen_src/impl/API/ewk_user_media_private.h b/tizen_src/impl/API/ewk_user_media_private.h
index 41d0c23..2bf58b2 100644 (file)
--- a/tizen_src/impl/API/ewk_user_media_private.h
+++ b/tizen_src/impl/API/ewk_user_media_private.h
@@ -26,21 +26,28 @@
 #ifndef ewk_user_media_private_h
 #define ewk_user_media_private_h
 
+#include "base/callback.h"
 #include "content/public/common/media_stream_request.h"
+#include "web_contents_delegate_efl.h"
 
 #include <Evas.h>
 
 class EWebView;
 
 struct _Ewk_User_Media_Permission_Request {
-  _Ewk_User_Media_Permission_Request(EWebView* ewkView, const content::MediaStreamRequest& media_request)
-      : view(ewkView),
-        request(media_request),
-        isDecided(false),
-        isSuspended(false) { }
+  _Ewk_User_Media_Permission_Request(
+    EWebView* ewkView,
+    const content::MediaStreamRequest& media_request,
+    content::WebContentsDelegateEfl* web_contents)
+    : view(ewkView)
+    , request(media_request)
+    , web_contents(web_contents)
+    , isDecided(false)
+    , isSuspended(false) { }
 
   EWebView* view;
   const content::MediaStreamRequest& request;
+  content::WebContentsDelegateEfl* web_contents;
   bool isDecided;
   bool isSuspended;
 };

diff --git a/tizen_src/impl/web_contents_delegate_efl.cc b/tizen_src/impl/web_contents_delegate_efl.cc
index 28ccc5e..951210e 100755 (executable)
--- a/tizen_src/impl/web_contents_delegate_efl.cc
+++ b/tizen_src/impl/web_contents_delegate_efl.cc
@@ -142,47 +142,64 @@ void WebContentsDelegateEfl::RegisterProtocolHandler(WebContents* web_contents,
   web_view_->SmartCallback<EWebViewCallbacks::RegisterProtocolHandler>().call(protocol_data.get());
 }
 
-void WebContentsDelegateEfl::RequestMediaAccessPermission(
-        WebContents* web_contents,
-        const MediaStreamRequest& request,
-        const MediaResponseCallback& callback) {
-#if 0
-  _Ewk_User_Media_Permission_Request* media_permission_request =
-      new _Ewk_User_Media_Permission_Request(web_view_, request);
+WebContentsDelegateEfl::PendingAccessRequest::PendingAccessRequest(
+  const content::MediaStreamRequest& request,
+  const content::MediaResponseCallback& callback)
+  : request(request)
+  , callback(callback) {
+}
+
+WebContentsDelegateEfl::PendingAccessRequest::~PendingAccessRequest() {
+}
 
-  web_view_->SmartCallback<EWebViewCallbacks::UserMediaPermission>().call(media_permission_request);
+void WebContentsDelegateEfl::OnAccessRequestResponse(Eina_Bool allowed) {
+#warning "[M37] Fix media permissions"
+#if 0
   MediaStreamDevices devices;
-  if (media_permission_request->isDecided) {
-    // TODO: we have to re-look at this when we actually connect to camera and mic (user media)
-    // and how it is used in engine side. sending dummy data for now.
-    // How do we construct a MediaStreamDevice?
-    MediaStreamDevice audio_device(request.audio_type,
-        request.requested_audio_device_id /*id*/,
-        request.requested_audio_device_id/*name*/);
-    MediaStreamDevice video_device(request.video_type,
-            request.requested_video_device_id /*id*/,
-            request.requested_video_device_id/*name*/);
-    devices.push_back(audio_device);
-    devices.push_back(video_device);
-    //FIXME: This crashes somewhere inside, so we return an empty list for now.
-    callback.Run(MediaStreamDevices(), scoped_ptr<MediaStreamUI>());
+  DVLOG(1) << __FUNCTION__ << " Queue Size: " << requests_Queue_.size();
+  if (requests_Queue_.empty()) {
+    DVLOG(1) << __FUNCTION__ << " Empty Queue ";
+    return;
+  }
+  PendingAccessRequest pending_request = requests_Queue_.front();
+  if (pending_request.callback.is_null()) {
+    requests_Queue_.pop_front();
+    DVLOG(1) << __FUNCTION__ << " Invalid Callback ";
+    return;
   }
-  else {
-    // Nothing was approved by user, so send an empty list.
-    callback.Run(MediaStreamDevices(), scoped_ptr<MediaStreamUI>());
+  if (allowed) {
+    if (pending_request.request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE) {
+      DVLOG(1) << __FUNCTION__ << "Added Audio Device";
+      devices.push_back(MediaStreamDevice(pending_request.request.audio_type,
+                                          "default", "Default"));
+    }
+    if (pending_request.request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE) {
+      DVLOG(1) << __FUNCTION__ << " Added Video Device";
+      devices.push_back(MediaStreamDevice(pending_request.request.video_type,
+                                          "1", "1"));
+    }
+    pending_request.callback.Run(devices, scoped_ptr<MediaStreamUI>());
+  } else {
+    DVLOG(1) << __FUNCTION__ << " Decline request with empty list";
+    pending_request.callback.Run(MediaStreamDevices(),
+                                 scoped_ptr<MediaStreamUI>());
   }
-#else
-  // FIXME This should be changed to the devices to which the user has granted
-  //       access.
-  MediaStreamDevices devices;
-  if (request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE)
-    devices.push_back(MediaStreamDevice(request.audio_type, "default", "Default"));
-  if (request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE)
-    devices.push_back(MediaStreamDevice(request.video_type, "1", "1"));
-  callback.Run(devices, scoped_ptr<MediaStreamUI>());
+  requests_Queue_.pop_front();
 #endif
 }
 
+void WebContentsDelegateEfl::RequestMediaAccessPermission(
+        WebContents* web_contents,
+        const MediaStreamRequest& request,
+        const MediaResponseCallback& callback) {
+  //send callback to application to request for user permission.
+  _Ewk_User_Media_Permission_Request* media_permission_request =
+    new _Ewk_User_Media_Permission_Request(web_view_, request,this);
+  requests_Queue_.push_back(PendingAccessRequest(request, callback));
+  web_view_->SmartCallback<EWebViewCallbacks::UserMediaPermission>().call(
+    media_permission_request);
+}
+
 void WebContentsDelegateEfl::OnAuthRequired(net::URLRequest* request,
                                             const std::string& realm,
                                             LoginDelegateEfl* login_delegate) {

diff --git a/tizen_src/impl/web_contents_delegate_efl.h b/tizen_src/impl/web_contents_delegate_efl.h
index 564d2b5..c3789d9 100755 (executable)
--- a/tizen_src/impl/web_contents_delegate_efl.h
+++ b/tizen_src/impl/web_contents_delegate_efl.h
@@ -1,6 +1,8 @@
 #ifndef WEB_CONTENTS_DELEGATE_EFL
 #define WEB_CONTENTS_DELEGATE_EFL
 
+#include <deque>
+
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "content/public/browser/browser_context.h"
@@ -153,6 +155,7 @@ class WebContentsDelegateEfl
                                    const base::string16& source_id) OVERRIDE;
   void RunFileChooser(WebContents* web_contents, const FileChooserParams& params);
   ColorChooser* OpenColorChooser(WebContents* web_contents, SkColor color, const std::vector<ColorSuggestion>& suggestions);
+  void OnAccessRequestResponse(Eina_Bool allowed);
 
  private:
   void OnGetContentSecurityPolicy(IPC::Message* reply_msg);
@@ -173,6 +176,17 @@ class WebContentsDelegateEfl
     Ewk_CSP_Header_Type header_type;
   };
 
+  // Structure to hold media request and its callback.
+  struct PendingAccessRequest {
+    PendingAccessRequest(const content::MediaStreamRequest& request,
+                         const content::MediaResponseCallback& callback);
+    ~PendingAccessRequest();
+    content::MediaStreamRequest request;
+    content::MediaResponseCallback callback;
+  };
+
+  //Queue to hold all pending request for requesting user permissions.
+  std::deque<PendingAccessRequest> requests_Queue_;
   scoped_ptr<ContentSecurityPolicy> pending_content_security_policy_;
   bool document_created_;
   bool should_open_new_window_;