Media Remoting: Exit remoting only if playback is continuously delayed.

media/remoting/remote_renderer_impl.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/remote_renderer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_math.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream_provider.h"
 #include "media/remoting/remote_demuxer_stream_adapter.h"
 #include "media/remoting/remoting_renderer_controller.h"
 #include "media/remoting/rpc/proto_enum_utils.h"
 #include "media/remoting/rpc/proto_utils.h"
 
 namespace {
 
 // The moving time window to track the media time and statistics updates.
-constexpr base::TimeDelta kTrackingWindow = base::TimeDelta::FromSeconds(3);
+constexpr base::TimeDelta kTrackingWindow = base::TimeDelta::FromSeconds(5);
 
-// The allowed delay for the remoting playback. When exceeds this limit, the
-// user experience is likely poor and the controller is notified.
+// The allowed delay for the remoting playback. When exceeds this limit
+// continuously for |kMaxNumPlaybackDelayed| times, the user experience is
+// likely poor and the controller is notified.
 constexpr base::TimeDelta kMediaPlaybackDelayThreshold =
-    base::TimeDelta::FromMilliseconds(450);
+    base::TimeDelta::FromMilliseconds(750);
+constexpr int kMaxNumPlaybackDelayed = 3;

[miu, 2017/01/19 22:00:55]

How about |kPlaybackDelayCountThreshold|?

[xjz, 2017/01/19 22:10:04]

Done.

 
 // The allowed percentage of the number of video frames dropped vs. the number
 // of the video frames decoded. When exceeds this limit, the user experience is
 // likely poor and the controller is notified.
 constexpr int kMaxNumVideoFramesDroppedPercentage = 3;
 
 // The time period to allow receiver get stable after playback rate change or
 // Flush().
 constexpr base::TimeDelta kStabilizationPeriod =
     base::TimeDelta::FromSeconds(2);
@@ skipping 695 matching lines @@
   base::TimeDelta media_duration =
       media_time_queue_.back().second - media_time_queue_.front().second;
   base::TimeDelta update_duration =
       (media_time_queue_.back().first - media_time_queue_.front().first) *
       playback_rate_;
   if ((media_duration - update_duration).magnitude() >=
       kMediaPlaybackDelayThreshold) {
     VLOG(1) << "Irregular playback detected: Media playback delayed."
             << " media_duration = " << media_duration
             << " update_duration = " << update_duration;
-    OnFatalError(remoting::PACING_TOO_SLOWLY);
+    ++num_playback_delayed_;
+    if (num_playback_delayed_ == kMaxNumPlaybackDelayed)
+      OnFatalError(remoting::PACING_TOO_SLOWLY);
+  } else {
+    num_playback_delayed_ = 0;
   }
+
   // Prune |media_time_queue_|.
   while (media_time_queue_.back().first - media_time_queue_.front().first >=
          kTrackingWindow)
     media_time_queue_.pop_front();
 }
 
 void RemoteRendererImpl::UpdateVideoStatsQueue(int video_frames_decoded,
                                                int video_frames_dropped) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   if (!flush_cb_.is_null())
@@ skipping 88 matching lines @@
          kDataFlowPollPeriod.InSecondsF()) /
         kBytesPerKilobit;
     DCHECK_GE(kilobits_per_second, 0);
     const base::CheckedNumeric<int> checked_kbps = kilobits_per_second;
     metrics_recorder_.OnVideoRateEstimate(
         checked_kbps.ValueOrDefault(std::numeric_limits<int>::max()));
   }
 }
 
 }  // namespace media