Added metrics for background video playback.

content/renderer/media/renderer_webmediaplayer_delegate_browsertest.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 <tuple>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
+#include "base/power_monitor/power_monitor.h"
+#include "base/power_monitor/power_monitor_source.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "base/test/histogram_tester.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/common/media/media_player_delegate_messages.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/test/render_view_test.h"
 #include "content/renderer/media/renderer_webmediaplayer_delegate.h"
 #include "content/renderer/render_process.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 11 matching lines @@
 
   // WebMediaPlayerDelegate::Observer implementation.
   MOCK_METHOD0(OnHidden, void());
   MOCK_METHOD0(OnShown, void());
   MOCK_METHOD1(OnSuspendRequested, void(bool));
   MOCK_METHOD0(OnPlay, void());
   MOCK_METHOD0(OnPause, void());
   MOCK_METHOD1(OnVolumeMultiplierUpdate, void(double));
 };
 
+class DummyPowerMonitorSource : public base::PowerMonitorSource {
+ public:
+  DummyPowerMonitorSource() {}
+  ~DummyPowerMonitorSource() override {}

[mlamouri (slow - plz ping), 2016/08/08 13:19:31]

nit: `= default;` FTW

+
+  void Suspend() { ProcessPowerEvent(SUSPEND_EVENT); }
+  void Resume() { ProcessPowerEvent(RESUME_EVENT); }
+
+ private:
+  // base::PowerMonitorSource implementation.
+  bool IsOnBatteryPowerImpl() override { return false; }
+
+  DISALLOW_COPY_AND_ASSIGN(DummyPowerMonitorSource);
+};
+
 class RendererWebMediaPlayerDelegateTest : public content::RenderViewTest {
  public:
   RendererWebMediaPlayerDelegateTest() {}
   ~RendererWebMediaPlayerDelegateTest() override {}
 
   void SetUp() override {
     RenderViewTest::SetUp();
+
+    power_monitor_source_ = new DummyPowerMonitorSource();
+    power_monitor_.reset(new base::PowerMonitor(
+        base::WrapUnique(power_monitor_source_)));
     delegate_manager_.reset(
         new RendererWebMediaPlayerDelegate(view_->GetMainRenderFrame()));
   }
 
   void TearDown() override {
     // Destruct the controller prior to any other tear down to avoid out of
     // order destruction relative to the test render frame.
     delegate_manager_.reset();
+    power_monitor_.reset();
     RenderViewTest::TearDown();
   }
 
  protected:
   IPC::TestSink& test_sink() { return render_thread_->sink(); }
 
   bool HasPlayingVideo(int delegate_id) {
     return delegate_manager_->playing_videos_.count(delegate_id);
   }
 
   void SetPlayingBackgroundVideo(bool is_playing) {
     delegate_manager_->is_playing_background_video_ = is_playing;
   }
 
   void CallOnMediaDelegatePlay(int delegate_id) {
     delegate_manager_->OnMediaDelegatePlay(delegate_id);
   }
 
   void CallOnMediaDelegatePause(int delegate_id) {
     delegate_manager_->OnMediaDelegatePause(delegate_id);
   }
 
+  void CallSetIsPlayingBackgroundVideo(bool is_playing) {
+    delegate_manager_->SetIsPlayingBackgroundVideo(is_playing);
+  }
+
+  base::TimeTicks GetBackgroundVideoPlayingStartTime() {
+    return delegate_manager_->background_video_playing_start_time_;
+  }
+
+  DummyPowerMonitorSource* power_monitor_source_ = nullptr;
+  std::unique_ptr<base::PowerMonitor> power_monitor_;
   std::unique_ptr<RendererWebMediaPlayerDelegate> delegate_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RendererWebMediaPlayerDelegateTest);
 };
 
 TEST_F(RendererWebMediaPlayerDelegateTest, SendsMessagesCorrectly) {
   testing::StrictMock<MockWebMediaPlayerDelegateObserver> observer;
   const int delegate_id = delegate_manager_->AddObserver(&observer);
 
@@ skipping 269 matching lines @@
   delegate_manager_->DidPause(delegate_id, true);
   CallOnMediaDelegatePlay(delegate_id);
   EXPECT_EQ(old_value, delegate_manager_->IsPlayingBackgroundVideo());
 
   delegate_manager_->DidPlay(
       delegate_id, true, true, false, base::TimeDelta());
   CallOnMediaDelegatePlay(delegate_id);
   EXPECT_NE(old_value, delegate_manager_->IsPlayingBackgroundVideo());
 }
 
+TEST_F(RendererWebMediaPlayerDelegateTest, Histograms) {
+  MockWebMediaPlayerDelegateObserver observer;
+  int delegate_id = delegate_manager_->AddObserver(&observer);
+  base::HistogramTester histogram_tester;
+  histogram_tester.ExpectTotalCount("Media.Session.BackgroundTime", 0);
+
+  // Pausing or showing doesn't record anything as background playback
+  // hasn't started yet.
+  delegate_manager_->DidPlay(
+      delegate_id, true, true, false, base::TimeDelta());
+  CallOnMediaDelegatePause(delegate_id);
+  histogram_tester.ExpectTotalCount("Media.Session.BackgroundTime", 0);
+
+  delegate_manager_->DidPlay(
+      delegate_id, true, true, false, base::TimeDelta());
+  delegate_manager_->WasShown();
+  histogram_tester.ExpectTotalCount("Media.Session.BackgroundTime", 0);
+
+  // Doing this things after the background playback has started should record
+  // the time.
+  delegate_manager_->DidPlay(
+      delegate_id, true, true, false, base::TimeDelta());
+  SetPlayingBackgroundVideo(true);
+  CallOnMediaDelegatePause(delegate_id);
+  histogram_tester.ExpectTotalCount("Media.Session.BackgroundTime", 1);
+
+  delegate_manager_->DidPlay(
+      delegate_id, true, true, false, base::TimeDelta());
+  SetPlayingBackgroundVideo(true);
+  delegate_manager_->WasShown();
+  histogram_tester.ExpectTotalCount("Media.Session.BackgroundTime", 2);
+}
+
+TEST_F(RendererWebMediaPlayerDelegateTest, PowerObserver) {
+  CallSetIsPlayingBackgroundVideo(true);
+  base::TimeTicks time_before_suspend = GetBackgroundVideoPlayingStartTime();
+
+  power_monitor_source_->Suspend();
+  power_monitor_source_->Resume();
+
+  EXPECT_GE(GetBackgroundVideoPlayingStartTime(), time_before_suspend);
+}
 
 }  // namespace media