Merge M56: "Add audio only watch time metrics."

media/blink/watch_time_reporter.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/blink/watch_time_reporter.h"
 
 #include "base/power_monitor/power_monitor.h"
 
 namespace media {
 
@@ skipping 70 matching lines @@
   volume_ = volume;
 
   // We're only interesting in transitions in and out of the muted state.
   if (!old_volume && volume)
     MaybeStartReportingTimer(get_media_time_cb_.Run());
   else if (old_volume && !volume_)
     MaybeFinalizeWatchTime(FinalizeTime::ON_NEXT_UPDATE);
 }
 
 void WatchTimeReporter::OnShown() {
+  if (!has_video_)
+    return;
+
   is_visible_ = true;
   MaybeStartReportingTimer(get_media_time_cb_.Run());
 }
 
 void WatchTimeReporter::OnHidden() {
+  if (!has_video_)
+    return;
+
   is_visible_ = false;
   MaybeFinalizeWatchTime(FinalizeTime::ON_NEXT_UPDATE);
 }
 
 void WatchTimeReporter::OnPowerStateChange(bool on_battery_power) {
   if (!reporting_timer_.IsRunning())
     return;
 
   // Defer changing |is_on_battery_power_| until the next watch time report to
   // avoid momentary power changes from affecting the results.
   if (is_on_battery_power_ != on_battery_power) {
     end_timestamp_for_power_ = get_media_time_cb_.Run();
 
     // Restart the reporting timer so the full hysteresis is afforded.
     reporting_timer_.Start(FROM_HERE, reporting_interval_, this,
                            &WatchTimeReporter::UpdateWatchTime);
     return;
   }
 
   end_timestamp_for_power_ = kNoTimestamp;
 }
 
 bool WatchTimeReporter::ShouldReportWatchTime() {
-  // Only report watch time for media of sufficient size with both audio and
-  // video tracks present.
-  return has_audio_ && has_video_ &&
-         initial_video_size_.height() >= kMinimumVideoSize.height() &&
-         initial_video_size_.width() >= kMinimumVideoSize.width();
+  // Report listen time or watch time only for tracks that are audio-only or
+  // have both an audio and video track of sufficient size.
+  return (!has_video_ && has_audio_) ||
+         (has_video_ && has_audio_ &&
+          initial_video_size_.height() >= kMinimumVideoSize.height() &&
+          initial_video_size_.width() >= kMinimumVideoSize.width());
 }
 
 void WatchTimeReporter::MaybeStartReportingTimer(
     base::TimeDelta start_timestamp) {
   // Don't start the timer if any of our state indicates we shouldn't; this
   // check is important since the various event handlers do not have to care
   // about the state of other events.
   if (!ShouldReportWatchTime() || !is_playing_ || !volume_ || !is_visible_) {
     // If we reach this point the timer should already have been stopped or
     // there is a pending finalize in flight.
@@ skipping 58 matching lines @@
   // if a seek is taking some time to complete or the playback is stalled for
   // some reason.
   if (elapsed >= kMinimumElapsedWatchTime &&
       last_media_timestamp_ != current_timestamp) {
     last_media_timestamp_ = current_timestamp;
 
     std::unique_ptr<MediaLogEvent> log_event =
         media_log_->CreateEvent(MediaLogEvent::Type::WATCH_TIME_UPDATE);
 
     log_event->params.SetDoubleWithoutPathExpansion(
-        MediaLog::kWatchTimeAudioVideoAll, elapsed.InSecondsF());
+        has_video_ ? MediaLog::kWatchTimeAudioVideoAll
+                   : MediaLog::kWatchTimeAudioAll,
+        elapsed.InSecondsF());
     if (is_mse_) {
       log_event->params.SetDoubleWithoutPathExpansion(
-          MediaLog::kWatchTimeAudioVideoMse, elapsed.InSecondsF());
+          has_video_ ? MediaLog::kWatchTimeAudioVideoMse
+                     : MediaLog::kWatchTimeAudioMse,
+          elapsed.InSecondsF());
     } else {
       log_event->params.SetDoubleWithoutPathExpansion(
-          MediaLog::kWatchTimeAudioVideoSrc, elapsed.InSecondsF());
+          has_video_ ? MediaLog::kWatchTimeAudioVideoSrc
+                     : MediaLog::kWatchTimeAudioSrc,
+          elapsed.InSecondsF());
     }
     if (is_encrypted_) {
       log_event->params.SetDoubleWithoutPathExpansion(
-          MediaLog::kWatchTimeAudioVideoEme, elapsed.InSecondsF());
+          has_video_ ? MediaLog::kWatchTimeAudioVideoEme
+                     : MediaLog::kWatchTimeAudioEme,
+          elapsed.InSecondsF());
     }
 
     // Record watch time using the last known value for |is_on_battery_power_|;
     // if there's a |pending_power_change_| use that to accurately finalize the
     // last bits of time in the previous bucket.
     const base::TimeDelta elapsed_power =
         (is_power_change_pending ? end_timestamp_for_power_
                                  : current_timestamp) -
         start_timestamp_for_power_;
 
     // Again, only update watch time if enough time has elapsed; we need to
     // recheck the elapsed time here since the power source can change anytime.
     if (elapsed_power >= kMinimumElapsedWatchTime) {
       if (is_on_battery_power_) {
         log_event->params.SetDoubleWithoutPathExpansion(
-            MediaLog::kWatchTimeAudioVideoBattery, elapsed_power.InSecondsF());
+            has_video_ ? MediaLog::kWatchTimeAudioVideoBattery
+                       : MediaLog::kWatchTimeAudioBattery,
+            elapsed_power.InSecondsF());
       } else {
         log_event->params.SetDoubleWithoutPathExpansion(
-            MediaLog::kWatchTimeAudioVideoAc, elapsed_power.InSecondsF());
+            has_video_ ? MediaLog::kWatchTimeAudioVideoAc
+                       : MediaLog::kWatchTimeAudioAc,
+            elapsed_power.InSecondsF());
       }
     }
 
     if (is_finalizing)
       log_event->params.SetBoolean(MediaLog::kWatchTimeFinalize, true);
     else if (is_power_change_pending)
       log_event->params.SetBoolean(MediaLog::kWatchTimeFinalizePower, true);
 
     DVLOG(2) << "Sending watch time update.";
     media_log_->AddEvent(std::move(log_event));
   }
 
   if (is_power_change_pending) {
     // Invert battery power status here instead of using the value returned by
     // the PowerObserver since there may be a pending OnPowerStateChange().
     is_on_battery_power_ = !is_on_battery_power_;
 
     start_timestamp_for_power_ = end_timestamp_for_power_;
     end_timestamp_for_power_ = kNoTimestamp;
   }
 
   // Stop the timer if this is supposed to be our last tick.
   if (is_finalizing) {
     end_timestamp_ = kNoTimestamp;
     reporting_timer_.Stop();
   }
 }
 
 }  // namespace media