Add power monitoring to the Cast VideoToolbox encoder.

media/cast/sender/h264_vt_encoder.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 "media/cast/sender/h264_vt_encoder.h"
 
 #include <string>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/power_monitor/power_monitor.h"
 #include "base/synchronization/lock.h"
 #include "media/base/mac/corevideo_glue.h"
 #include "media/base/mac/video_frame_mac.h"
 #include "media/cast/sender/video_frame_factory.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
@@ skipping 267 matching lines @@
   }
 
  private:
   ~Proxy() override {}
 
   const scoped_refptr<VideoFrameFactoryImpl> video_frame_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Proxy);
 };
 
+H264VideoToolboxEncoder::PowerObserver::PowerObserver(
+    H264VideoToolboxEncoder* encoder)
+    : encoder_(encoder) {
+  DCHECK(encoder_);
+  auto power_monitor = base::PowerMonitor::Get();
+  if (!power_monitor) {
+    DLOG(WARNING) << "No power monitor. Encoder may fail if power state change "
+                     "goes undetected.";
+    return;
+  }
+  power_monitor->AddObserver(this);
+  VLOG(1) << "Registered for power state changes.";
+}
+
+H264VideoToolboxEncoder::PowerObserver::~PowerObserver() {
+  auto power_monitor = base::PowerMonitor::Get();
+  if (power_monitor)
+    power_monitor->RemoveObserver(this);
+}
+
+void H264VideoToolboxEncoder::PowerObserver::OnSuspend() {
+  VLOG(1)
+      << "OnSuspend: Emitting all frames and destroying compression session.";
+  encoder_->EmitFrames();
+  encoder_->DestroyCompressionSession();
+}
+
+void H264VideoToolboxEncoder::PowerObserver::OnResume() {
+  VLOG(1) << "OnResume: Resetting compression session.";
+  encoder_->ResetCompressionSession();
+}
+
 // static
 bool H264VideoToolboxEncoder::IsSupported(
     const VideoSenderConfig& video_config) {
   return video_config.codec == CODEC_VIDEO_H264 && VideoToolboxGlue::Get();
 }
 
 H264VideoToolboxEncoder::H264VideoToolboxEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
     const VideoSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb)
     : cast_environment_(cast_environment),
       videotoolbox_glue_(VideoToolboxGlue::Get()),
       video_config_(video_config),
       status_change_cb_(status_change_cb),
+      power_observer_(this),
       last_frame_id_(kStartFrameId),
       encode_next_frame_as_keyframe_(false),
       weak_factory_(this) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(!status_change_cb_.is_null());
 
   OperationalStatus operational_status =
       H264VideoToolboxEncoder::IsSupported(video_config)
           ? STATUS_INITIALIZED
           : STATUS_UNSUPPORTED_CODEC;
@@ skipping 370 matching lines @@
     CopySampleBufferToAnnexBBuffer(sbuf, &encoded_frame->data, keyframe);
 
   encoder->cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(request->frame_encoded_callback,
                  base::Passed(&encoded_frame)));
 }
 
 }  // namespace cast
 }  // namespace media