Refactoring: Merge VideoSenderConfig and AudioSenderConfig.

media/cast/sender/size_adaptable_video_encoder_base.h

 // Copyright 2015 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_SIZE_ADAPTABLE_VIDEO_ENCODER_BASE_H_
 #define MEDIA_CAST_SENDER_SIZE_ADAPTABLE_VIDEO_ENCODER_BASE_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 12 matching lines @@
 
 // Creates and owns a VideoEncoder instance.  The owned instance is an
 // implementation that does not support changing frame sizes, and so
 // SizeAdaptableVideoEncoderBase acts as a proxy to automatically detect when
 // the owned instance should be replaced with one that can handle the new frame
 // size.
 class SizeAdaptableVideoEncoderBase : public VideoEncoder {
  public:
   SizeAdaptableVideoEncoderBase(
       const scoped_refptr<CastEnvironment>& cast_environment,
-      const VideoSenderConfig& video_config,
+      const FrameSenderConfig& video_config,
       const StatusChangeCallback& status_change_cb);
 
   ~SizeAdaptableVideoEncoderBase() override;
 
   // VideoEncoder implementation.
   bool EncodeVideoFrame(
       const scoped_refptr<media::VideoFrame>& video_frame,
       const base::TimeTicks& reference_time,
       const FrameEncodedCallback& frame_encoded_callback) final;
   void SetBitRate(int new_bit_rate) final;
   void GenerateKeyFrame() final;
   std::unique_ptr<VideoFrameFactory> CreateVideoFrameFactory() final;
   void EmitFrames() final;
 
  protected:
   // Accessors for subclasses.
   CastEnvironment* cast_environment() const {
     return cast_environment_.get();
   }
-  const VideoSenderConfig& video_config() const {
-    return video_config_;
-  }
+  const FrameSenderConfig& video_config() const { return video_config_; }
   const gfx::Size& frame_size() const {
     return frame_size_;
   }
   FrameId next_frame_id() const { return next_frame_id_; }
 
   // Returns a callback that calls OnEncoderStatusChange().  The callback is
   // canceled by invalidating its bound weak pointer just before a replacement
   // encoder is instantiated.  In this scheme, OnEncoderStatusChange() can only
   // be called by the most-recent encoder.
   StatusChangeCallback CreateEncoderStatusChangeCallback();
@@ skipping 20 matching lines @@
   void OnEncoderStatusChange(OperationalStatus status);
 
   // Called by the |encoder_| with the next EncodedFrame.
   void OnEncodedVideoFrame(const FrameEncodedCallback& frame_encoded_callback,
                            std::unique_ptr<SenderEncodedFrame> encoded_frame);
 
   const scoped_refptr<CastEnvironment> cast_environment_;
 
   // This is not const since |video_config_.starting_bitrate| is modified by
   // SetBitRate(), for when a replacement encoder is spawned.
-  VideoSenderConfig video_config_;
+  FrameSenderConfig video_config_;
 
   // Run whenever the underlying encoder reports a status change.
   const StatusChangeCallback status_change_cb_;
 
   // The underlying platform video encoder and the frame size it expects.
   std::unique_ptr<VideoEncoder> encoder_;
   gfx::Size frame_size_;
 
   // The number of frames in |encoder_|'s pipeline.  If this is set to
   // kEncoderIsInitializing, |encoder_| is not yet ready to accept frames.
   enum { kEncoderIsInitializing = -1 };
   int frames_in_encoder_;
 
   // The ID for the next frame to be emitted.
   FrameId next_frame_id_;
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<SizeAdaptableVideoEncoderBase> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SizeAdaptableVideoEncoderBase);
 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_SENDER_SIZE_ADAPTABLE_VIDEO_ENCODER_BASE_H_