VR: Poll media access flags

chrome/browser/android/vr_shell/vr_shell.cc

 // Copyright 2016 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 "chrome/browser/android/vr_shell/vr_shell.h"
 
 #include <android/native_window_jni.h>
 
 #include <string>
 #include <utility>
@@ skipping 12 matching lines @@
 #include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/ui_scene_manager.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
 #include "chrome/browser/android/vr_shell/vr_controller_model.h"
 #include "chrome/browser/android/vr_shell/vr_gl_thread.h"
 #include "chrome/browser/android/vr_shell/vr_input_manager.h"
 #include "chrome/browser/android/vr_shell/vr_shell_delegate.h"
 #include "chrome/browser/android/vr_shell/vr_shell_gl.h"
 #include "chrome/browser/android/vr_shell/vr_usage_monitor.h"
 #include "chrome/browser/android/vr_shell/vr_web_contents_observer.h"
+#include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
+#include "chrome/browser/media/webrtc/media_stream_capture_indicator.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/referrer.h"
 #include "device/vr/android/gvr/gvr_device.h"
 #include "device/vr/android/gvr/gvr_device_provider.h"
@@ skipping 11 matching lines @@
 #include "ui/gfx/native_widget_types.h"
 
 using base::android::JavaParamRef;
 using base::android::JavaRef;
 
 namespace vr_shell {
 
 namespace {
 vr_shell::VrShell* g_instance;
 
+constexpr base::TimeDelta poll_media_access_interval_ =
+    base::TimeDelta::FromSecondsD(0.01);
+
 void SetIsInVR(content::WebContents* contents, bool is_in_vr) {
   if (contents && contents->GetRenderWidgetHostView())
     contents->GetRenderWidgetHostView()->SetIsInVR(is_in_vr);
 }
 
 void LoadControllerModelTask(
     base::WeakPtr<VrShell> weak_vr_shell,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner) {
   auto controller_model = VrControllerModel::LoadFromComponent();
   if (controller_model) {
@@ skipping 431 matching lines @@
 
 void VrShell::OnVRVsyncProviderRequest(
     device::mojom::VRVSyncProviderRequest request) {
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::OnRequest,
                                      gl_thread_->GetVrShellGl(),
                                      base::Passed(&request)));
 }
 
 void VrShell::UpdateVSyncInterval(int64_t timebase_nanos,
                                   double interval_seconds) {
+  PollMediaAccessFlag();
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::UpdateVSyncInterval,
                                      gl_thread_->GetVrShellGl(), timebase_nanos,
                                      interval_seconds));
 }
 
+void VrShell::PollMediaAccessFlag() {
+  poll_capturing_media_task_.Cancel();
+
+  poll_capturing_media_task_.Reset(base::Bind(&VrShell::PollMediaAccessFlag,
+                                              weak_ptr_factory_.GetWeakPtr()));

[mthiesse, 2017/05/12 22:43:59]

No need for weakptr, just cancel the callback in the destructor.

[asimjour1, 2017/05/12 22:57:04]

Done.

+  main_thread_task_runner_->PostDelayedTask(
+      FROM_HERE, poll_capturing_media_task_.callback(),
+      poll_media_access_interval_);
+
+  scoped_refptr<MediaStreamCaptureIndicator> indicator =
+      MediaCaptureDevicesDispatcher::GetInstance()
+          ->GetMediaStreamCaptureIndicator();
+  bool is_capturing_audio = indicator->IsCapturingAudio(web_contents_);
+  if (is_capturing_audio != is_capturing_audio_)
+    PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetAudioCapturingWarning,
+                                       gl_thread_->GetVrShellGl(),
+                                       is_capturing_audio));
+  is_capturing_audio_ = is_capturing_audio;
+
+  bool is_capturing_video = indicator->IsCapturingVideo(web_contents_);
+  if (is_capturing_video != is_capturing_video_)
+    PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetVideoCapturingWarning,
+                                       gl_thread_->GetVrShellGl(),
+                                       is_capturing_video));
+  is_capturing_video_ = is_capturing_video;
+
+  bool is_capturing_screen = indicator->IsBeingMirrored(web_contents_);
+  if (is_capturing_screen != is_capturing_screen_)
+    PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetScreenCapturingWarning,
+                                       gl_thread_->GetVrShellGl(),
+                                       is_capturing_screen));
+  is_capturing_screen_ = is_capturing_screen;
+}
+
 void VrShell::SetContentCssSize(float width, float height, float dpr) {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_setContentCssSize(env, j_vr_shell_.obj(), width, height,
                                      dpr);
 }
 
 void VrShell::ProcessContentGesture(
     std::unique_ptr<blink::WebInputEvent> event) {
   if (input_manager_) {
     input_manager_->ProcessUpdatedGesture(std::move(event));
@@ skipping 35 matching lines @@
            jboolean for_web_vr,
            jlong gvr_api,
            jboolean reprojected_rendering) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, reinterpret_cast<ui::WindowAndroid*>(window_android),
       for_web_vr, VrShellDelegate::GetNativeVrShellDelegate(env, delegate),
       reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell