Don't histogram paint time after ending or seeking.

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 535 matching lines @@
                                 AsWeakPtr(), BUFFERING_HAVE_ENOUGH));
     }
     return;
   }
 
   // Call this before setting |seeking_| so that the current media time can be
   // recorded by the reporter.
   if (watch_time_reporter_)
     watch_time_reporter_->OnSeeking();
 
+  // Clear any new frame processed callbacks on seek; otherwise we'll end up
+  // logging a time long after the seek completes.
+  frame_time_report_cb_.Cancel();
+
   // TODO(sandersd): Move |seeking_| to PipelineController.
   // TODO(sandersd): Do we want to reset the idle timer here?
   delegate_->SetIdle(delegate_id_, false);
   ended_ = false;
   seeking_ = true;
   seek_time_ = time;
   if (paused_)
     paused_time_ = time;
   pipeline_controller_.Seek(time, time_updated);
 
@@ skipping 659 matching lines @@
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // Ignore state changes until we've completed all outstanding operations.
   if (!pipeline_controller_.IsStable())
     return;
 
   ended_ = true;
   client_->timeChanged();
 
+  // Clear any new frame processed callbacks on end; otherwise we'll end up
+  // logging a time long after playback ends.
+  frame_time_report_cb_.Cancel();
+
   // We don't actually want this to run until |client_| calls seek() or pause(),
   // but that should have already happened in timeChanged() and so this is
   // expected to be a no-op.
   UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnMetadata(PipelineMetadata metadata) {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
@@ skipping 210 matching lines @@
   video_locked_when_paused_when_hidden_ = false;
 
   if (watch_time_reporter_)
     watch_time_reporter_->OnShown();
 
   // Only track the time to the first frame if playing or about to play because
   // of being shown and only for videos we would optimize background playback
   // for.
   if ((!paused_ && IsBackgroundOptimizationCandidate()) ||
       paused_when_hidden_) {
-    VideoFrameCompositor::OnNewProcessedFrameCB new_processed_frame_cb =
-        BindToCurrentLoop(base::Bind(
-            &WebMediaPlayerImpl::ReportTimeFromForegroundToFirstFrame,
-            AsWeakPtr(), base::TimeTicks::Now()));
+    frame_time_report_cb_.Reset(
+        base::Bind(&WebMediaPlayerImpl::ReportTimeFromForegroundToFirstFrame,
+                   AsWeakPtr(), base::TimeTicks::Now()));
     compositor_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&VideoFrameCompositor::SetOnNewProcessedFrameCallback,
-                   base::Unretained(compositor_), new_processed_frame_cb));
+                   base::Unretained(compositor_),
+                   BindToCurrentLoop(frame_time_report_cb_.callback())));
   }
 
   EnableVideoTrackIfNeeded();
 
   if (paused_when_hidden_) {
     paused_when_hidden_ = false;
     OnPlay();  // Calls UpdatePlayState() so return afterwards.
     return;
   }
 
@@ skipping 842 matching lines @@
 
 void WebMediaPlayerImpl::RecordUnderflowDuration(base::TimeDelta duration) {
   DCHECK(data_source_ || chunk_demuxer_);
   if (data_source_)
     UMA_HISTOGRAM_TIMES("Media.UnderflowDuration", duration);
   else
     UMA_HISTOGRAM_TIMES("Media.UnderflowDuration.MSE", duration);
 }
 
 }  // namespace media