[Media, Video] Enable the video track for a new renderer.

media/blink/webmediaplayer_impl.cc

 // Copyright 2013 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/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 182 matching lines @@
       media_task_runner_(params.media_task_runner()),
       worker_task_runner_(params.worker_task_runner()),
       media_log_(params.media_log()),
       pipeline_(media_task_runner_, media_log_.get()),
       pipeline_controller_(
           &pipeline_,
           base::Bind(&WebMediaPlayerImpl::CreateRenderer,
                      base::Unretained(this)),
           base::Bind(&WebMediaPlayerImpl::OnPipelineSeeked, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnPipelineSuspended, AsWeakPtr()),
+          base::Bind(&WebMediaPlayerImpl::OnBeforePipelineResume, AsWeakPtr()),
+          base::Bind(&WebMediaPlayerImpl::OnPipelineResumed, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnError, AsWeakPtr())),
       load_type_(LoadTypeURL),
       opaque_(false),
       playback_rate_(0.0),
       paused_(true),
       paused_when_hidden_(false),
       seeking_(false),
       pending_suspend_resume_cycle_(false),
       ended_(false),
       should_notify_time_changed_(false),
@@ skipping 254 matching lines @@
   // incorrectly discard what it thinks is a seek to the existing time.
   paused_time_ =
       ended_ ? pipeline_.GetMediaDuration() : pipeline_.GetMediaTime();
 
   if (observer_)
     observer_->OnPaused();
 
   DCHECK(watch_time_reporter_);
   watch_time_reporter_->OnPaused();
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PAUSE));
+
   UpdatePlayState();
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seek(double seconds) {
   DVLOG(1) << __func__ << "(" << seconds << "s)";
@@ skipping 177 matching lines @@
                               << "]";
   pipeline_.OnEnabledAudioTracksChanged(enabledMediaTrackIds);
 }
 
 void WebMediaPlayerImpl::selectedVideoTrackChanged(
     blink::WebMediaPlayer::TrackId* selectedTrackId) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   std::ostringstream logstr;
   std::vector<MediaTrack::Id> selectedVideoMediaTrackId;
-  bool canAddVideoTrack =
-      !IsBackgroundVideoTrackOptimizationEnabled() || !IsHidden();
-  if (selectedTrackId && canAddVideoTrack) {
+  if (selectedTrackId && !video_track_disabled_) {
     selectedVideoMediaTrackId.push_back(selectedTrackId->utf8().data());
     logstr << selectedVideoMediaTrackId[0];
   }
   MEDIA_LOG(INFO, media_log_) << "Selected video track: [" << logstr.str()
                               << "]";
   pipeline_.OnSelectedVideoTrackChanged(selectedVideoMediaTrackId);
 }
 
 blink::WebSize WebMediaPlayerImpl::naturalSize() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ skipping 370 matching lines @@
     set_cdm_result_->completeWithError(
         blink::WebContentDecryptionModuleExceptionNotSupportedError, 0,
         "Unable to set ContentDecryptionModule object");
     set_cdm_result_.reset();
   }
 }
 
 void WebMediaPlayerImpl::OnPipelineSeeked(bool time_updated) {
   seeking_ = false;
   seek_time_ = base::TimeDelta();
+
   if (paused_) {
 #if defined(OS_ANDROID)  // WMPI_CAST
     if (isRemote()) {
       paused_time_ = base::TimeDelta::FromSecondsD(cast_impl_.currentTime());
     } else {
       paused_time_ = pipeline_.GetMediaTime();
     }
 #else
     paused_time_ = pipeline_.GetMediaTime();
 #endif
   } else {
     DCHECK(watch_time_reporter_);
     watch_time_reporter_->OnPlaying();
   }
   if (time_updated)
     should_notify_time_changed_ = true;
 
   // Reset underflow count upon seek; this prevents looping videos and user
   // actions from artificially inflating the underflow count.
   underflow_count_ = 0;
+
+  // Apply optimizations for the hidden videos if hidden.
+  if (IsHidden())
+    OnHidden();

[sandersd (OOO until July 31), 2017/01/10 21:34:37]

OnHidden() does a bit more than what is requested, please factor out the
relevant part.

[whywhat, 2017/01/11 19:41:30]

I think that's the point of it, no? We initialize the player as if it's shown
despite it's being hidden so when it starts and we're hidden we want all of it -
update play state, schedule idle pause and so on. I think it shouldn't change
the existing behavior with the flag being off since the media is playing at this
point.

[sandersd (OOO until July 31), 2017/01/11 21:54:51]

The target state for this code is that OnHidden() calls UpdatePlayState() and
does nothing else; I don't want to have to think about every possible transition
that WMPI can go through.

If there is something that is behaving incorrectly with regards to that, it is a
bug.

Looking at what's already in there:
  - WatchTimeReporter is constructed in the correct state.
  - Selected video track is this CL.
  - ScheduleIdlePauseTimer() is probably buggy. I'm not fully up to date on
autoplay cases so I'm not sure what behavior we want, but this should move into
UpdatePlayState() eventually.

 }
 
 void WebMediaPlayerImpl::OnPipelineSuspended() {
 #if defined(OS_ANDROID)
   if (isRemote()) {
     scoped_refptr<VideoFrame> frame = cast_impl_.GetCastingBanner();
     if (frame)
       compositor_->PaintSingleFrame(frame);
   }
 #endif
 
   // If we're not in an aggressive buffering state, tell the data source we have
   // enough data so that it may release the connection.
   if (buffering_strategy_ !=
       MultibufferDataSource::BUFFERING_STRATEGY_AGGRESSIVE) {
     if (data_source_)
       data_source_->OnBufferingHaveEnough(true);
   }
 
   ReportMemoryUsage();
 
   if (pending_suspend_resume_cycle_) {
     pending_suspend_resume_cycle_ = false;
     UpdatePlayState();
   }
 }
 
+void WebMediaPlayerImpl::OnBeforePipelineResume() {
+  // Enable video track if we disabled it in the background - this way the new
+  // renderer will attach its callbacks to the video stream properly.
+  // TODO(avayvod): Remove this when disabling and enabling video tracks in
+  // non-playing state works correctly. See https://crbug.com/678374.
+  EnableVideoTrackIfNeeded();
+  is_pipeline_resuming_ = true;
+}
+
+void WebMediaPlayerImpl::OnPipelineResumed() {
+  is_pipeline_resuming_ = false;
+
+  if (IsHidden()) {
+    DisableVideoTrackIfNeeded();
+    return;

[sandersd (OOO until July 31), 2017/01/10 21:34:37]

Nit: This may be a case where early return is more confusing than an else
branch.

(I'd go further and say this should be part of UpdatePlayState() but since the
plan is to rip it all out I won't recommend that.)

[whywhat, 2017/01/11 19:41:30]

Done. For some reason, I expect lint to complain though.

+  }
+
+  EnableVideoTrackIfNeeded();
+}
+
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   client_->mediaSourceOpened(
       new WebMediaSourceImpl(chunk_demuxer_, media_log_));
 }
 
 void WebMediaPlayerImpl::OnError(PipelineStatus status) {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(status, PIPELINE_OK);
@@ skipping 222 matching lines @@
   if (video_weblayer_)
     video_weblayer_->layer()->SetContentsOpaque(opaque_);
 }
 
 void WebMediaPlayerImpl::OnHidden() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (watch_time_reporter_)
     watch_time_reporter_->OnHidden();
 
-  if (!IsStreaming() && IsBackgroundVideoTrackOptimizationEnabled()) {
-    if (ShouldPauseWhenHidden()) {
-      // OnPause() will set |paused_when_hidden_| to false and call
-      // UpdatePlayState(), so set the flag to true after and then return.
-      OnPause();
-      paused_when_hidden_ = true;
-      return;
-    }
+  if (!paused_when_hidden_ && ShouldPauseWhenHidden()) {

[sandersd (OOO until July 31), 2017/01/10 21:34:37]

As a matter of style, I prefer idempotency wherever possible. Since in this case
running this code twice will actually result in disabling the video track, it
would be better to make the |!paused_when_hidden_| condition one level deeper.

Relatedly, ShouldDisableVideoWhenHidden() should probably return false if
ShouldPauseWhenHidden() is true.

[whywhat, 2017/01/11 19:41:30]

I think it won't because ShouldPauseWhenHidden and ShouldDisableWhenHidden are
mutually exclusive via hasAudio().

Done though.
That's already true.

+    // OnPause() will set |paused_when_hidden_| to false and call
+    // UpdatePlayState(), so set the flag to true after and then return.
+    OnPause();
+    paused_when_hidden_ = true;
+    return;
+  }
 
-    selectedVideoTrackChanged(nullptr);
-  }
+  DisableVideoTrackIfNeeded();
 
   UpdatePlayState();
 
   // Schedule suspended playing media to be paused if the user doesn't come back
   // to it within some timeout period to avoid any autoplay surprises.
   ScheduleIdlePauseTimer();
 }
 
 void WebMediaPlayerImpl::OnShown() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (watch_time_reporter_)
     watch_time_reporter_->OnShown();
 
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoFrameCompositor::SetForegroundTime,
                  base::Unretained(compositor_), base::TimeTicks::Now()));
 
-  if (!IsStreaming() && IsBackgroundVideoTrackOptimizationEnabled()) {
-    if (paused_when_hidden_) {
-      paused_when_hidden_ = false;
-      OnPlay();  // Calls UpdatePlayState() so return afterwards.
-      return;
-    }
+  if (paused_when_hidden_) {

[sandersd (OOO until July 31), 2017/01/10 21:34:37]

By the same reasoning, this should go right before UpdatePlayState() so that all
the other state changes are idempotent. (And |must_suspend_| is important to
update in any case.)

[whywhat, 2017/01/11 19:41:30]

Moved the state update above the new logic.

I don't want to check if the video "should be paused/disabled" here though since
it may change since it has been paused/disabled and we must unpause/enable it
anyway. (not sure if you meant that or not).

We could have a hidden state enum instead of two bools to enforce exclusiveness
of being either paused or without video track but not both.

+    paused_when_hidden_ = false;
+    OnPlay();  // Calls UpdatePlayState() so return afterwards.
+    return;
+  }
 
-    if (client_->hasSelectedVideoTrack()) {
-      WebMediaPlayer::TrackId trackId = client_->getSelectedVideoTrackId();
-      selectedVideoTrackChanged(&trackId);
-    }
-  }
+  EnableVideoTrackIfNeeded();
 
   must_suspend_ = false;
   background_pause_timer_.Stop();
 
   UpdatePlayState();
 }
 
 bool WebMediaPlayerImpl::OnSuspendRequested(bool must_suspend) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
@@ skipping 666 matching lines @@
   return pipeline_metadata_.video_rotation == VIDEO_ROTATION_0;
 }
 
 void WebMediaPlayerImpl::ActivateViewportIntersectionMonitoring(bool activate) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   client_->activateViewportIntersectionMonitoring(activate);
 }
 
 bool WebMediaPlayerImpl::ShouldPauseWhenHidden() const {
+  DCHECK(IsHidden());
+// Don't pause videos being Cast (Android only) or if the background video
+// optimizations are off (desktop only).
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote())
     return false;
-#endif  // defined(OS_ANDROID)  // WMPI_CAST
+#else   // defined(OS_ANDROID)
+  if (!IsBackgroundVideoTrackOptimizationEnabled())
+    return false;
+#endif  // defined(OS_ANDROID)
 
   return hasVideo() && !hasAudio();

[sandersd (OOO until July 31), 2017/01/10 21:34:37]

Probably worth a comment somewhere: these conditions imply that
ShouldPauseWHenHidden() and ShouldDisableVideoWhenHidden() return false before
Start() is called.

They don't quite imply that they return false until Start() has finished, but
|seeking_| does.

[whywhat, 2017/01/11 19:41:30]

Should I make an even stronger comment that they will be false until the demuxer
is initialized and OnMetadata is called? Or is it the same thing essentially?
|seeking_| implies that tracks won't be disabled in the methods below, but these
methods can return true already if OnMetadata was called, right?

Added comments in the header.
Didn't find anything I could easily DCHECK.

[sandersd (OOO until July 31), 2017/01/11 21:54:51]

OnMetadata is called after demuxer initialization, seeking completes after
decoder initialization. Exactly what to document depends on what is relevant to
track changes: I assumed it was decoder, but that may be stricter than
necessary.

 }
 
+bool WebMediaPlayerImpl::ShouldDisableVideoWhenHidden() const {
+  DCHECK(IsHidden());
+  return IsBackgroundVideoTrackOptimizationEnabled() && hasVideo() &&
+         hasAudio() && !IsStreaming();
+}
+
+void WebMediaPlayerImpl::EnableVideoTrackIfNeeded() {
+  DCHECK(!IsHidden());
+
+  // Don't change video track while the pipeline is resuming or seeking.
+  if (is_pipeline_resuming_ || seeking_)
+    return;
+
+  if (video_track_disabled_) {
+    video_track_disabled_ = false;
+    if (client_->hasSelectedVideoTrack()) {
+      WebMediaPlayer::TrackId trackId = client_->getSelectedVideoTrackId();
+      selectedVideoTrackChanged(&trackId);
+    }
+  }
+}
+
+void WebMediaPlayerImpl::DisableVideoTrackIfNeeded() {
+  DCHECK(IsHidden());
+
+  // Don't change video track while the pipeline is resuming or seeking.
+  if (is_pipeline_resuming_ || seeking_)
+    return;
+
+  if (!video_track_disabled_ && ShouldDisableVideoWhenHidden()) {
+    video_track_disabled_ = true;
+    selectedVideoTrackChanged(nullptr);
+  }
+}
+
 }  // namespace media