Monitor the intersection of video and viewport.

media/remoting/remoting_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_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "media/remoting/rpc/proto_utils.h"
 #include "media/remoting/rpc/rpc_broker.h"
 
+namespace {
+
+// Video may be rendered remotely when it covers the viewport with the ratio
+// larger than this threshold.
+constexpr float kViewportRatioVideoRenderingThreshold = 0.85;
+
+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()) *
+                         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 {
 
 RemotingController::RemotingController(
     mojom::RemotingSourceRequest source_request,
     mojom::RemoterPtr remoter)
     : binding_(this, std::move(source_request)),
       remoter_(std::move(remoter)),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_factory_(this) {
   DCHECK(remoter_);
@@ skipping 110 matching lines @@
   UpdateAndMaybeSwitch();
 }
 
 void RemotingController::OnExitedFullscreen() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   is_fullscreen_ = false;
   UpdateAndMaybeSwitch();
 }
 
+void RemotingController::OnVideoViewportIntersectionChanged(
+    const ViewportIntersectionInfo& info) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  // 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) {
+    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(&RemotingController::OnViewportMostlyFilledAndUnchanging,
+                   weak_factory_.GetWeakPtr()));
+  }
+}
+
+void RemotingController::OnViewportMostlyFilledAndUnchanging() {
+  is_mostly_filling_viewport_ = true;

[Z_DONOTUSE, 2016/11/17 06:19:05]

If the video is mostly filling the viewport, then 2 seconds later it's not,
we'll set is_mostly_filling_viewport_ to false on line 177, but then hit this
callback and set it to true. I think that's not what you're intending? Or am I
reading the code wrong or is that how it's supposed to work?

I think you want to set is_mostly_filling_viewport_ to true when you schedule
the callback (i.e. on line 186). Then this function would do:

if (is_mostly_filling_viewport)
  UpdateAndMaybeSwitch();

[xjz, 2016/11/17 07:15:18]

Before setting |is_mostly_filling_viewport_| to false on Line 177, the timer is
stopped in Line 171, and this callback will not be hit. 

+  UpdateAndMaybeSwitch();
+}
+
 void RemotingController::OnSetCdm(CdmContext* cdm_context) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // TODO(xjz): Not implemented. Will add in up-coming change.
   NOTIMPLEMENTED();
 }
 
 void RemotingController::SetSwitchRendererCallback(
     const SwitchRendererCallback& cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 70 matching lines @@
 
 bool RemotingController::ShouldBeRemoting() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // TODO(xjz): The control logic for EME will be added in a later CL.
   if (is_encrypted_)
     return false;
 
   if (!is_sink_available_)
     return false;
-  if (!is_fullscreen_)
-    return false;
   if (has_video_ && !IsVideoCodecSupported())
     return false;
   if (has_audio_ && !IsAudioCodecSupported())
     return false;
-  return true;
+  return is_fullscreen_ || is_mostly_filling_viewport_;
 }
 
 void RemotingController::UpdateAndMaybeSwitch() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // TODO(xjz): The switching logic for encrypted content will be added in a
   // later CL.
 
   // Demuxer is not initialized yet.
   if (!has_audio_ && !has_video_)
@@ skipping 11 matching lines @@
     // |swithc_renderer_cb_.Run()| will be called after remoting is started
     // successfully.
     remoter_->Start();
   } else {
     switch_renderer_cb_.Run();
     remoter_->Stop(mojom::RemotingStopReason::LOCAL_PLAYBACK);
   }
 }
 
 }  // namespace media