Add power monitoring to the Cast VideoToolbox encoder.

media/cast/sender/h264_vt_encoder_unittest.cc

 // Copyright 2014 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 <queue>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
+#include "base/power_monitor/power_monitor.h"
 #include "base/test/launcher/unit_test_launcher.h"
+#include "base/test/power_monitor_test_base.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/test/test_suite.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media.h"
 #include "media/base/media_switches.h"
 #include "media/cast/sender/h264_vt_encoder.h"
 #include "media/cast/sender/video_frame_factory.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "media/ffmpeg/ffmpeg_common.h"
@@ skipping 162 matching lines @@
   auto cv_pixel_buffer = video_frame->cv_pixel_buffer();
   ASSERT_TRUE(cv_pixel_buffer);
   CVPixelBufferLockBaseAddress(cv_pixel_buffer, 0);
   auto ptr = CVPixelBufferGetBaseAddressOfPlane(cv_pixel_buffer, 0);
   ASSERT_TRUE(ptr);
   memset(ptr, 0xfe, CVPixelBufferGetBytesPerRowOfPlane(cv_pixel_buffer, 0) *
                         CVPixelBufferGetHeightOfPlane(cv_pixel_buffer, 0));
   CVPixelBufferUnlockBaseAddress(cv_pixel_buffer, 0);
 }
 
+void NoopFrameEncodedCallback(

[miu, 2015/04/24 20:38:40]

FYI--No change needed here, but just so you know: hubbe@'s fixing the need for
"no-op" deleter functions like this
(https://codereview.chromium.org/1074963003/).  Just letting you know here for
your future code changes.

[jfroy, 2015/04/24 20:42:26]

Acknowledged.

+    scoped_ptr<media::cast::EncodedFrame> /*encoded_frame*/) {
+}
+
+class TestPowerSource : public base::PowerMonitorSource {
+ public:
+  void GenerateSuspendEvent() {
+    ProcessPowerEvent(SUSPEND_EVENT);
+    base::MessageLoop::current()->RunUntilIdle();
+  }
+  void GenerateResumeEvent() {
+    ProcessPowerEvent(RESUME_EVENT);
+    base::MessageLoop::current()->RunUntilIdle();
+  }
+
+ private:
+  bool IsOnBatteryPowerImpl() override { return false; }
+};
+
 class H264VideoToolboxEncoderTest : public ::testing::Test {
  protected:
-  H264VideoToolboxEncoderTest()
-      : operational_status_(STATUS_UNINITIALIZED) {
-    frame_->set_timestamp(base::TimeDelta());
-  }
+  H264VideoToolboxEncoderTest() = default;
 
   void SetUp() override {
     clock_ = new base::SimpleTestTickClock();
     clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
 
+    power_source_ = new TestPowerSource();
+    power_monitor_.reset(
+        new base::PowerMonitor(scoped_ptr<TestPowerSource>(power_source_)));
+
     cast_environment_ = new CastEnvironment(
         scoped_ptr<base::TickClock>(clock_).Pass(),
         message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(),
         message_loop_.message_loop_proxy());
     encoder_.reset(new H264VideoToolboxEncoder(
-        cast_environment_,
-        video_sender_config_,
+        cast_environment_, video_sender_config_,
         base::Bind(&SaveOperationalStatus, &operational_status_)));
     message_loop_.RunUntilIdle();
     EXPECT_EQ(STATUS_INITIALIZED, operational_status_);
   }
 
   void TearDown() override {
     encoder_.reset();
     message_loop_.RunUntilIdle();
+    power_monitor_.reset();
   }
 
   void AdvanceClockAndVideoFrameTimestamp() {
     clock_->Advance(base::TimeDelta::FromMilliseconds(33));
     frame_->set_timestamp(frame_->timestamp() +
                           base::TimeDelta::FromMilliseconds(33));
   }
 
   static void SetUpTestCase() {
     // Reusable test data.
     video_sender_config_ = GetDefaultVideoSenderConfig();
     video_sender_config_.codec = CODEC_VIDEO_H264;
     const gfx::Size size(kVideoWidth, kVideoHeight);
     frame_ = media::VideoFrame::CreateFrame(
         VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta());
     PopulateVideoFrame(frame_.get(), 123);
   }
 
   static void TearDownTestCase() { frame_ = nullptr; }
 
   static scoped_refptr<media::VideoFrame> frame_;
   static VideoSenderConfig video_sender_config_;
 
   base::SimpleTestTickClock* clock_;  // Owned by CastEnvironment.
   base::MessageLoop message_loop_;
   scoped_refptr<CastEnvironment> cast_environment_;
   scoped_ptr<VideoEncoder> encoder_;
   OperationalStatus operational_status_;
+  TestPowerSource* power_source_;  // Owned by the power monitor.
+  scoped_ptr<base::PowerMonitor> power_monitor_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(H264VideoToolboxEncoderTest);
 };
 
 // static
 scoped_refptr<media::VideoFrame> H264VideoToolboxEncoderTest::frame_;
 VideoSenderConfig H264VideoToolboxEncoderTest::video_sender_config_;
 
 TEST_F(H264VideoToolboxEncoderTest, CheckFrameMetadataSequence) {
@@ skipping 50 matching lines @@
   // The first call to |MaybeCreateFrame| will return null but post a task to
   // the encoder to initialize for the specified frame size. We then drain the
   // message loop. After that, the encoder should have initialized and we
   // request a frame again.
   ASSERT_FALSE(video_frame_factory->MaybeCreateFrame(
       gfx::Size(kVideoWidth, kVideoHeight), base::TimeDelta()));
   message_loop_.RunUntilIdle();
   CreateFrameAndMemsetPlane(video_frame_factory.get());
 }
 
+TEST_F(H264VideoToolboxEncoderTest, CheckPowerMonitoring) {
+  // Encode a frame, suspend, encode a frame, resume, encode a frame.
+
+  VideoEncoder::FrameEncodedCallback cb = base::Bind(&NoopFrameEncodedCallback);
+  EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
+  power_source_->GenerateSuspendEvent();
+  EXPECT_FALSE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
+  power_source_->GenerateResumeEvent();
+  EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
+}
+
+TEST_F(H264VideoToolboxEncoderTest, CheckPowerMonitoringNoInitialFrame) {
+  // Suspend, encode a frame, resume, encode a frame.
+
+  VideoEncoder::FrameEncodedCallback cb = base::Bind(&NoopFrameEncodedCallback);
+  power_source_->GenerateSuspendEvent();
+  EXPECT_FALSE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
+  power_source_->GenerateResumeEvent();
+  EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
+}
+
+TEST_F(H264VideoToolboxEncoderTest, CheckPowerMonitoringVideoFrameFactory) {
+  VideoEncoder::FrameEncodedCallback cb = base::Bind(&NoopFrameEncodedCallback);
+  auto video_frame_factory = encoder_->CreateVideoFrameFactory();
+  ASSERT_TRUE(video_frame_factory.get());
+
+  // The first call to |MaybeCreateFrame| will return null but post a task to
+  // the encoder to initialize for the specified frame size. We then drain the
+  // message loop. After that, the encoder should have initialized and we
+  // request a frame again.
+  ASSERT_FALSE(video_frame_factory->MaybeCreateFrame(
+      gfx::Size(kVideoWidth, kVideoHeight), base::TimeDelta()));
+  message_loop_.RunUntilIdle();
+  CreateFrameAndMemsetPlane(video_frame_factory.get());
+
+  // After a power suspension, the factory should not produce frames.
+  power_source_->GenerateSuspendEvent();
+
+  ASSERT_FALSE(video_frame_factory->MaybeCreateFrame(
+      gfx::Size(kVideoWidth, kVideoHeight), base::TimeDelta()));
+  message_loop_.RunUntilIdle();
+  ASSERT_FALSE(video_frame_factory->MaybeCreateFrame(
+      gfx::Size(kVideoWidth, kVideoHeight), base::TimeDelta()));
+
+  // After a power resume event, the factory should produce frames right away
+  // because the encoder re-initializes on its own.
+  power_source_->GenerateResumeEvent();
+  CreateFrameAndMemsetPlane(video_frame_factory.get());
+}
+
+TEST_F(H264VideoToolboxEncoderTest,
+       CheckPowerMonitoringVideoFrameFactoryNoInitialFrame) {
+  VideoEncoder::FrameEncodedCallback cb = base::Bind(&NoopFrameEncodedCallback);
+  auto video_frame_factory = encoder_->CreateVideoFrameFactory();
+  ASSERT_TRUE(video_frame_factory.get());
+
+  // After a power suspension, the factory should not produce frames.
+  power_source_->GenerateSuspendEvent();
+
+  ASSERT_FALSE(video_frame_factory->MaybeCreateFrame(
+      gfx::Size(kVideoWidth, kVideoHeight), base::TimeDelta()));
+  message_loop_.RunUntilIdle();
+  ASSERT_FALSE(video_frame_factory->MaybeCreateFrame(
+      gfx::Size(kVideoWidth, kVideoHeight), base::TimeDelta()));
+
+  // After a power resume event, the factory should produce frames right away
+  // because the encoder re-initializes on its own.
+  power_source_->GenerateResumeEvent();
+  CreateFrameAndMemsetPlane(video_frame_factory.get());
+}
+
 }  // namespace cast
 }  // namespace media