Add power monitoring to the Cast VideoToolbox encoder.

media/cast/sender/h264_vt_encoder.h

 // 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.
 
 #ifndef MEDIA_CAST_SENDER_H264_VT_ENCODER_H_
 #define MEDIA_CAST_SENDER_H264_VT_ENCODER_H_
 
 #include "base/mac/scoped_cftyperef.h"
+#include "base/power_monitor/power_observer.h"
 #include "base/threading/thread_checker.h"
 #include "media/base/mac/videotoolbox_glue.h"
 #include "media/cast/sender/size_adaptable_video_encoder_base.h"
 #include "media/cast/sender/video_encoder.h"
 
 namespace media {
 namespace cast {
 
 // VideoToolbox implementation of the media::cast::VideoEncoder interface.
 // VideoToolbox makes no guarantees that it is thread safe, so this object is
 // pinned to the thread on which it is constructed. Supports changing frame
 // sizes directly.
 class H264VideoToolboxEncoder : public VideoEncoder {
   typedef CoreMediaGlue::CMSampleBufferRef CMSampleBufferRef;
   typedef VideoToolboxGlue::VTCompressionSessionRef VTCompressionSessionRef;
   typedef VideoToolboxGlue::VTEncodeInfoFlags VTEncodeInfoFlags;
 
  public:
-  // VideoFrameFactory tied to the VideoToolbox encoder.
-  class VideoFrameFactoryImpl;
-
   // Returns true if the current platform and system configuration supports
   // using H264VideoToolboxEncoder with the given |video_config|.
   static bool IsSupported(const VideoSenderConfig& video_config);
 
   H264VideoToolboxEncoder(
       const scoped_refptr<CastEnvironment>& cast_environment,
       const VideoSenderConfig& video_config,
       const StatusChangeCallback& status_change_cb);
   ~H264VideoToolboxEncoder() override;
 
@@ skipping 31 matching lines @@
   bool SetSessionProperty(CFStringRef key, bool value);
   bool SetSessionProperty(CFStringRef key, CFStringRef value);
 
   // Compression session callback function to handle compressed frames.
   static void CompressionCallback(void* encoder_opaque,
                                   void* request_opaque,
                                   OSStatus status,
                                   VTEncodeInfoFlags info,
                                   CMSampleBufferRef sbuf);
 
+  // VideoFrameFactory tied to the encoder.
+  class VideoFrameFactoryImpl;
+
+  // PowerObserver tied to the encoder. Emits all frames and destroys the
+  // compression session on suspend and resets the compression session on
+  // resume.
+  class PowerObserver : public base::PowerObserver {

[miu, 2015/04/22 04:02:58]

Instead of a nested class, how about making H264VideoToolboxEncoder extend
base::PowerObserver itself and implement the OnSuspend() and OnResume() methods?

[jfroy, 2015/04/22 04:18:45]

I considered that but decided to use an auxiliary class because of the rather
generic name of the interface methods.

I'll move the implementation directly in the encoder though since you seem to
prefer that.

+   public:
+    explicit PowerObserver(H264VideoToolboxEncoder* encoder);
+    virtual ~PowerObserver();
+    void OnSuspend() override;
+    void OnResume() override;
+
+   private:
+    H264VideoToolboxEncoder* encoder_;
+    DISALLOW_COPY_AND_ASSIGN(PowerObserver);
+  };
+
   // The cast environment (contains worker threads & more).
   const scoped_refptr<CastEnvironment> cast_environment_;
 
   // VideoToolboxGlue provides access to VideoToolbox at runtime.
   const VideoToolboxGlue* const videotoolbox_glue_;
 
   // VideoSenderConfig copy so we can create compression sessions on demand.
   // This is needed to recover from backgrounding and other events that can
   // invalidate compression sessions.
   const VideoSenderConfig video_config_;
 
   // Frame size of the current compression session. Can be changed by submitting
   // a frame of a different size, which will cause a compression session reset.
   gfx::Size frame_size_;
 
   // Callback used to report initialization status and runtime errors.
   const StatusChangeCallback status_change_cb_;
 
   // Thread checker to enforce that this object is used on a specific thread.
   base::ThreadChecker thread_checker_;
 
+  // PowerObserver tied to the encoder.
+  const PowerObserver power_observer_;
+
   // The compression session.
   base::ScopedCFTypeRef<VTCompressionSessionRef> compression_session_;
 
   // Video frame factory tied to the encoder.
   scoped_refptr<VideoFrameFactoryImpl> video_frame_factory_;
 
   // The ID of the last frame that was emitted.
   uint32 last_frame_id_;
 
   // Force next frame to be a keyframe.
   bool encode_next_frame_as_keyframe_;
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<H264VideoToolboxEncoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(H264VideoToolboxEncoder);
 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_SENDER_H264_VT_ENCODER_H_