Detect change on the intersection of video and viewport.

media/remoting/remoting_renderer_controller.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 "media/remoting/remoting_renderer_controller.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/threading/thread_checker.h"
 #include "media/remoting/remoting_cdm_context.h"
 
+namespace {
+
+// Video may be rendered remotely when it covers the viewport with the ratio
+// larger than this threshold.
+constexpr float kViewportRatioVideoRenderingThreshold = 0.85f;

[miu, 2016/11/21 21:07:03]

naming accuracy: How about kViewportFillActivationThreshold?

[xjz, 2016/11/21 23:58:42]

Done.

+
+float GetVideoViewportRatio(const gfx::Rect& root_rect,
+                            const gfx::Rect& intersect_rect) {
+  if (root_rect.IsEmpty() || intersect_rect.IsEmpty())
+    return 0;
+
+  float intersect_area = static_cast<float>(intersect_rect.width()) *

[miu, 2016/11/21 21:07:03]

To simplify: Instead of width*height, you can call GetArea() on these rects.

[xjz, 2016/11/21 23:58:42]

Removed this helper as suggested in the below comment.

+                         static_cast<float>(intersect_rect.height());
+  float root_area = static_cast<float>(root_rect.width()) *
+                    static_cast<float>(root_rect.height());
+  return intersect_area / root_area;
+}
+
+}  // namespace
+
 namespace media {
 
 RemotingRendererController::RemotingRendererController(
     scoped_refptr<RemotingSourceImpl> remoting_source)
     : remoting_source_(remoting_source), weak_factory_(this) {
   remoting_source_->AddClient(this);
 }
 
 RemotingRendererController::~RemotingRendererController() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 31 matching lines @@
   UpdateAndMaybeSwitch();
 }
 
 void RemotingRendererController::OnExitedFullscreen() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   is_fullscreen_ = false;
   UpdateAndMaybeSwitch();
 }
 
+void RemotingRendererController::OnVideoViewportIntersectionChanged(
+    const ViewportIntersectionInfo& info) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Reset on any notification, since this indicates the user is scrolling
+  // around in the document, the document is changing layout, etc.
+  viewport_fill_debouncer_timer_.Stop();
+
+  float ratio = GetVideoViewportRatio(info.root_rect, info.intersect_rect);
+  // Dropping below the threshold should instantly stop remote rendering.
+  if (ratio < kViewportRatioVideoRenderingThreshold) {

[miu, 2016/11/21 21:07:03]

To simplify: You can avoid both the floating-point math and the separate helper
needed for a divide-by-zero check by doing a little algebra here (to devise a
new conditional expression):

    ratio < 0.85

--> (intersect_rect.GetArea() / root_rect.GetArea()) < (85 / 100)

--> (100 * intersect_rect.GetArea()) < (85 * root_rect.GetArea())

Now, even if either area is zero, the expression evaluates to the right answer:

  constexpr int64_t kOneHundredPercent = 100;
  constexpr int64_t kFillActivationThresholdPercent = 85;

  if ((kOneHundredPercent * info.intersect_rect.GetArea()) <
      (kFillActivationThresholdPercent * info.root_rect.GetArea()) {
    ...

[xjz, 2016/11/21 23:58:42]

Done.

+    if (is_mostly_filling_viewport_) {
+      is_mostly_filling_viewport_ = false;
+      UpdateAndMaybeSwitch();
+    }
+    return;
+  }
+
+  // Meeting/Exceeding the threshold should hold steady for 5 seconds before
+  // starting remote rendering.
+  if (!is_mostly_filling_viewport_) {
+    viewport_fill_debouncer_timer_.Start(
+        FROM_HERE, base::TimeDelta::FromSeconds(5),
+        base::Bind(
+            &RemotingRendererController::OnViewportMostlyFilledAndUnchanging,
+            weak_factory_.GetWeakPtr()));
+  }
+}
+
+void RemotingRendererController::OnViewportMostlyFilledAndUnchanging() {
+  is_mostly_filling_viewport_ = true;
+  UpdateAndMaybeSwitch();
+}
+
 void RemotingRendererController::OnSetCdm(CdmContext* cdm_context) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   auto* remoting_cdm_context = RemotingCdmContext::From(cdm_context);
   if (!remoting_cdm_context)
     return;
 
   remoting_source_->RemoveClient(this);
   remoting_source_ = remoting_cdm_context->GetRemotingSource();
   remoting_source_->AddClient(this);  // Calls OnSessionStateChanged().
@@ skipping 115 matching lines @@
       break;  // Media remoting is possible, assuming other requirments are met.
     case SESSION_STOPPING:
     case SESSION_PERMANENTLY_STOPPED:
       return false;  // Use local rendering after stopping remoting.
   }
   if ((!has_audio() && !has_video()) ||
       (has_video() && !IsVideoCodecSupported()) ||
       (has_audio() && !IsAudioCodecSupported()))
     return false;
 
-  // Normally, entering fullscreen is the signal that starts remote rendering.
-  // However, current technical limitations require encrypted content be remoted
-  // without waiting for a user signal.
-  return is_fullscreen_;
+  // Normally, entering fullscreen or filling most of the viewport is the signal
+  // that starts remote rendering. However, current technical limitations
+  // require encrypted content be remoted without waiting for a user signal.
+  return is_fullscreen_ || is_mostly_filling_viewport_;
 }
 
 void RemotingRendererController::UpdateAndMaybeSwitch() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   bool should_be_remoting = ShouldBeRemoting();
 
   if (remote_rendering_started_ == should_be_remoting)
     return;
 
@@ skipping 15 matching lines @@
     // and never back to the local renderer. The RemotingCdmController will
     // force-stop the session when remoting has ended; so no need to call
     // StopRemoting() from here.
     DCHECK(!is_encrypted_);
     switch_renderer_cb_.Run();
     remoting_source_->StopRemoting(this);
   }
 }
 
 }  // namespace media