[Cast] Separate frame size from VideoSenderConfig in H264VideoToolboxEncoder.

This is a prerequisite change for supporting variable video frame sizes
in Cast.  This allows a follow-up change to remove the width/height
properties from VideoSenderConfig.  Instead, the width/height is passed
to the ctor in a separate gfx::Size argument.

BUG=451277

Review URL: https://codereview.chromium.org/883013003

Cr-Commit-Position: refs/heads/master@{#313779}

media/cast/sender/h264_vt_encoder.cc

@@ -224,26 +224,32 @@ class VideoFrameFactoryCVPixelBufferPoolImpl : public VideoFrameFactory {
 }  // namespace
 
 H264VideoToolboxEncoder::H264VideoToolboxEncoder(
-    scoped_refptr<CastEnvironment> cast_environment,
+    const scoped_refptr<CastEnvironment>& cast_environment,
     const VideoSenderConfig& video_config,
+    const gfx::Size& frame_size,
     const CastInitializationCallback& initialization_cb)
     : cast_environment_(cast_environment),
+
       videotoolbox_glue_(VideoToolboxGlue::Get()),
       frame_id_(kStartFrameId),
       encode_next_frame_as_keyframe_(false) {
-  DCHECK(!initialization_cb.is_null());
+  DCHECK(!frame_size.IsEmpty());
+
   CastInitializationStatus initialization_status;
   if (videotoolbox_glue_) {
-    initialization_status = (Initialize(video_config))
+    initialization_status = (Initialize(video_config, frame_size))
                                 ? STATUS_VIDEO_INITIALIZED
                                 : STATUS_INVALID_VIDEO_CONFIGURATION;
   } else {
     LOG(ERROR) << " VideoToolbox is not available";
     initialization_status = STATUS_HW_VIDEO_ENCODER_NOT_SUPPORTED;
   }
-  cast_environment_->PostTask(
-      CastEnvironment::MAIN, FROM_HERE,
-      base::Bind(initialization_cb, initialization_status));
+  if (!initialization_cb.is_null()) {
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN,
+        FROM_HERE,
+        base::Bind(initialization_cb, initialization_status));
+  }
 }
 
 H264VideoToolboxEncoder::~H264VideoToolboxEncoder() {
@@ -251,7 +257,8 @@ H264VideoToolboxEncoder::~H264VideoToolboxEncoder() {
 }
 
 bool H264VideoToolboxEncoder::Initialize(
-    const VideoSenderConfig& video_config) {
+    const VideoSenderConfig& video_config,
+    const gfx::Size& frame_size) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!compression_session_);
 
@@ -286,7 +293,7 @@ bool H264VideoToolboxEncoder::Initialize(
 
   VTCompressionSessionRef session;
   OSStatus status = videotoolbox_glue_->VTCompressionSessionCreate(
-      kCFAllocatorDefault, video_config.width, video_config.height,
+      kCFAllocatorDefault, frame_size.width(), frame_size.height(),
       CoreMediaGlue::kCMVideoCodecType_H264, encoder_spec, buffer_attributes,
       nullptr /* compressedDataAllocator */,
       &H264VideoToolboxEncoder::CompressionCallback,
@@ -359,7 +366,8 @@ bool H264VideoToolboxEncoder::EncodeVideoFrame(
     const base::TimeTicks& reference_time,
     const FrameEncodedCallback& frame_encoded_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!reference_time.is_null());
+  DCHECK(!video_frame->visible_rect().IsEmpty());
+  DCHECK(!frame_encoded_callback.is_null());
 
   if (!compression_session_) {
     DLOG(ERROR) << " compression session is null";

media/cast/sender/h264_vt_encoder.h

@@ -22,9 +22,11 @@ class H264VideoToolboxEncoder : public VideoEncoder {
   typedef VideoToolboxGlue::VTEncodeInfoFlags VTEncodeInfoFlags;
 
  public:
-  H264VideoToolboxEncoder(scoped_refptr<CastEnvironment> cast_environment,
-                          const VideoSenderConfig& video_config,
-                          const CastInitializationCallback& initialization_cb);
+  H264VideoToolboxEncoder(
+      const scoped_refptr<CastEnvironment>& cast_environment,
+      const VideoSenderConfig& video_config,
+      const gfx::Size& frame_size,
+      const CastInitializationCallback& initialization_cb);
   ~H264VideoToolboxEncoder() override;
 
   // media::cast::VideoEncoder implementation
@@ -40,7 +42,8 @@ class H264VideoToolboxEncoder : public VideoEncoder {
 
  private:
   // Initialize the compression session.
-  bool Initialize(const VideoSenderConfig& video_config);
+  bool Initialize(const VideoSenderConfig& video_config,
+                  const gfx::Size& frame_size);
 
   // Configure the compression session.
   void ConfigureSession(const VideoSenderConfig& video_config);

media/cast/sender/h264_vt_encoder_unittest.cc

@@ -24,6 +24,9 @@
 
 namespace {
 
+const int kVideoWidth = 1280;
+const int kVideoHeight = 720;
+
 class MediaTestSuite : public base::TestSuite {
  public:
   MediaTestSuite(int argc, char** argv) : TestSuite(argc, argv) {}
@@ -201,7 +204,9 @@ class H264VideoToolboxEncoderTest : public ::testing::Test {
         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_,
+        gfx::Size(kVideoWidth, kVideoHeight),
         base::Bind(&SaveInitializationStatus, &cast_initialization_status_)));
     message_loop_.RunUntilIdle();
     EXPECT_EQ(STATUS_VIDEO_INITIALIZED, cast_initialization_status_);
@@ -222,7 +227,7 @@ class H264VideoToolboxEncoderTest : public ::testing::Test {
     // Reusable test data.
     video_sender_config_ = GetDefaultVideoSenderConfig();
     video_sender_config_.codec = CODEC_VIDEO_H264;
-    gfx::Size size(video_sender_config_.width, video_sender_config_.height);
+    const gfx::Size size(kVideoWidth, kVideoHeight);
     frame_ = media::VideoFrame::CreateFrame(
         VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta());
     PopulateVideoFrame(frame_.get(), 123);

media/cast/sender/video_sender.cc

@@ -80,9 +80,12 @@ VideoSender::VideoSender(
   if (!video_config.use_external_encoder &&
       video_config.codec == CODEC_VIDEO_H264) {
     video_encoder_.reset(new H264VideoToolboxEncoder(
-        cast_environment, video_config,
+        cast_environment,
+        video_config,
+        gfx::Size(video_config.width, video_config.height),
         base::Bind(&VideoSender::OnEncoderInitialized,
-                   weak_factory_.GetWeakPtr(), initialization_cb)));
+                   weak_factory_.GetWeakPtr(),
+                   initialization_cb)));
   }
 #endif  // defined(OS_MACOSX)
 #if !defined(OS_IOS)