Reduce number of active codecs on low end devices.

content/renderer/media/renderer_webmediaplayer_delegate.cc

 // Copyright 2015 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 "content/renderer/media/renderer_webmediaplayer_delegate.h"
 
 #include <stdint.h>
 
 #include "base/auto_reset.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics_action.h"
+#include "base/sys_info.h"
 #include "content/common/media/media_player_delegate_messages.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 
+#if defined(OS_ANDROID)
+#include "base/android/build_info.h"
+#endif
+
 namespace {
 
 void RecordAction(const base::UserMetricsAction& action) {
   content::RenderThread::Get()->RecordAction(action);
 }
 
+bool IsLowEndDevice() {

[sandersd (OOO until July 31), 2016/09/13 23:02:42]

Please comment that this check is specifically to include Jelly Bean. (Possibly
worth throwing in that JB MediaCodec is notoriously buggy.)

[DaleCurtis, 2016/09/15 23:03:55]

Done.

+#if defined(OS_ANDROID)
+  return base::android::BuildInfo::GetInstance()->sdk_int() <= 18 ||
+         base::SysInfo::IsLowEndDevice();
+#else
+  return base::SysInfo::IsLowEndDevice();
+#endif
+}
+
 }  // namespace
 
 namespace media {
 
 RendererWebMediaPlayerDelegate::RendererWebMediaPlayerDelegate(
     content::RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
+      idle_cleanup_timer_(true, true),
       default_tick_clock_(new base::DefaultTickClock()),
       tick_clock_(default_tick_clock_.get()) {
   idle_cleanup_interval_ = base::TimeDelta::FromSeconds(5);
   idle_timeout_ = base::TimeDelta::FromSeconds(15);
 }
 
 RendererWebMediaPlayerDelegate::~RendererWebMediaPlayerDelegate() {}
 
 int RendererWebMediaPlayerDelegate::AddObserver(Observer* observer) {
   const int delegate_id = id_map_.Add(observer);
@@ skipping 16 matching lines @@
     bool has_audio,
     bool is_remote,
     MediaContentType media_content_type) {
   DCHECK(id_map_.Lookup(delegate_id));
   has_played_media_ = true;
   if (has_video && !is_remote)
     playing_videos_.insert(delegate_id);
   else
     playing_videos_.erase(delegate_id);
   RemoveIdleDelegate(delegate_id);
+
+  // Upon receipt of a playback request, suspend everything that's not used.
+  if (IsLowEndDevice())
+    CleanupIdleDelegates(base::TimeDelta());
+
   Send(new MediaPlayerDelegateHostMsg_OnMediaPlaying(
       routing_id(), delegate_id, has_video, has_audio, is_remote,
       media_content_type));
 }
 
 void RendererWebMediaPlayerDelegate::DidPause(int delegate_id,
                                               bool reached_end_of_stream) {
   DCHECK(id_map_.Lookup(delegate_id));
   AddIdleDelegate(delegate_id);
   if (reached_end_of_stream)
     playing_videos_.erase(delegate_id);
   Send(new MediaPlayerDelegateHostMsg_OnMediaPaused(routing_id(), delegate_id,
                                                     reached_end_of_stream));
 }
 
 void RendererWebMediaPlayerDelegate::PlayerGone(int delegate_id) {
   DCHECK(id_map_.Lookup(delegate_id));
-  RemoveIdleDelegate(delegate_id);
   playing_videos_.erase(delegate_id);
   Send(new MediaPlayerDelegateHostMsg_OnMediaDestroyed(routing_id(),
                                                        delegate_id));
 }
 
 bool RendererWebMediaPlayerDelegate::IsHidden() {
   return render_frame()->IsHidden();
 }
 
 bool RendererWebMediaPlayerDelegate::IsPlayingBackgroundVideo() {
@@ skipping 70 matching lines @@
     double multiplier) {
   Observer* observer = id_map_.Lookup(delegate_id);
   if (observer)
     observer->OnVolumeMultiplierUpdate(multiplier);
 }
 
 void RendererWebMediaPlayerDelegate::AddIdleDelegate(int delegate_id) {
   idle_delegate_map_[delegate_id] = tick_clock_->NowTicks();
   if (!idle_cleanup_timer_.IsRunning()) {
     idle_cleanup_timer_.Start(
-        FROM_HERE, idle_cleanup_interval_, this,
-        &RendererWebMediaPlayerDelegate::CleanupIdleDelegates);
+        FROM_HERE, idle_cleanup_interval_,
+        base::Bind(&RendererWebMediaPlayerDelegate::CleanupIdleDelegates,
+                   base::Unretained(this), idle_timeout_));
   }
+
+  // When we reach the maximum number of idle players, aggressively suspend idle
+  // delegates to try and remain under the limit.
+  static const size_t kMaxIdlePlayers = IsLowEndDevice() ? 2 : 8;
+  if (idle_delegate_map_.size() > kMaxIdlePlayers)
+    CleanupIdleDelegates(idle_timeout_ / 10);

[liberato (no reviews please), 2016/09/13 15:34:28]

10? 

[DaleCurtis, 2016/09/15 23:03:55]

Just wanted something over 0, but now I don't see the point, so no additional
timeouts added.

 }
 
 void RendererWebMediaPlayerDelegate::RemoveIdleDelegate(int delegate_id) {
   // To avoid invalidating the iterator, just mark the delegate for deletion
   // using a sentinel value of an empty TimeTicks.
   if (idle_cleanup_running_) {
     idle_delegate_map_[delegate_id] = base::TimeTicks();
     return;
   }
 
   idle_delegate_map_.erase(delegate_id);
   if (idle_delegate_map_.empty())
     idle_cleanup_timer_.Stop();
 }
 
-void RendererWebMediaPlayerDelegate::CleanupIdleDelegates() {
+void RendererWebMediaPlayerDelegate::CleanupIdleDelegates(
+    base::TimeDelta idle_timeout) {

[liberato (no reviews please), 2016/09/13 15:34:28]

|idle_timeout| and |idle_timeout_| are a little confusing.  perhaps just
|timeout| here?

[DaleCurtis, 2016/09/15 23:03:55]

Done.

   // Iterate over the delegates and suspend the idle ones. Note: The call to
   // OnHidden() can trigger calls into RemoveIdleDelegate(), so for iterator
   // validity we set |idle_cleanup_running_| to true and defer deletions.
   base::AutoReset<bool> scoper(&idle_cleanup_running_, true);
   const base::TimeTicks now = tick_clock_->NowTicks();
   for (auto& idle_delegate_entry : idle_delegate_map_) {
-    if (now - idle_delegate_entry.second > idle_timeout_) {
+    if (now - idle_delegate_entry.second > idle_timeout) {
       id_map_.Lookup(idle_delegate_entry.first)->OnSuspendRequested(false);
 
       // Whether or not the player accepted the suspension, mark it for removal
       // from future polls to avoid running the timer forever.
       idle_delegate_entry.second = base::TimeTicks();
     }
   }
 
   // Take care of any removals that happened during the above iteration.
   for (auto it = idle_delegate_map_.begin(); it != idle_delegate_map_.end();) {
@@ skipping 28 matching lines @@
 #endif  // OS_ANDROID
 
   is_playing_background_video_ = is_playing;
 }
 
 void RendererWebMediaPlayerDelegate::OnDestruct() {
   delete this;
 }
 
 }  // namespace media