Cast: Enable use of VideoEncodeAccelerator for hardware video encoding

media/cast/video_sender/video_sender.cc

 // Copyright 2013 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/video_sender/video_sender.h"
 
 #include <cstring>
 #include <list>
 
 #include "base/bind.h"
@@ skipping 28 matching lines @@
 
  private:
   VideoSender* video_sender_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LocalRtcpVideoSenderFeedback);
 };
 
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
-    const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories,
+    const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
+    const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
     const CastInitializationCallback& cast_initialization_cb,
     transport::CastTransportSender* const transport_sender)
     : rtp_max_delay_(base::TimeDelta::FromMilliseconds(
           video_config.rtp_config.max_delay_ms)),
       max_frame_rate_(video_config.max_frame_rate),
       cast_environment_(cast_environment),
       transport_sender_(transport_sender),
       event_subscriber_(kMaxEventSubscriberEntries),
       rtp_stats_(kVideoFrequency),
       rtcp_feedback_(new LocalRtcpVideoSenderFeedback(this)),
       last_acked_frame_id_(-1),
       last_sent_frame_id_(-1),
       duplicate_ack_(0),
       last_skip_count_(0),
       congestion_control_(cast_environment->Clock(),
                           video_config.congestion_control_back_off,
                           video_config.max_bitrate,
                           video_config.min_bitrate,
                           video_config.start_bitrate),
       initialized_(false),
       active_session_(false),
       weak_factory_(this) {
   max_unacked_frames_ =
       1 + static_cast<uint8>(video_config.rtp_config.max_delay_ms *
                              max_frame_rate_ / 1000);
   VLOG(1) << "max_unacked_frames " << static_cast<int>(max_unacked_frames_);
   DCHECK_GT(max_unacked_frames_, 0) << "Invalid argument";
 
   if (video_config.use_external_encoder) {
-    CHECK(gpu_factories);
-    video_encoder_.reset(new ExternalVideoEncoder(
-        cast_environment, video_config, gpu_factories));
+    video_encoder_.reset(new ExternalVideoEncoder(cast_environment,
+                                                  video_config,
+                                                  create_vea_cb,
+                                                  create_video_encode_mem_cb));
   } else {
     video_encoder_.reset(new VideoEncoderImpl(
         cast_environment, video_config, max_unacked_frames_));
   }
 
   rtcp_.reset(
       new Rtcp(cast_environment_,
                rtcp_feedback_.get(),
                transport_sender_,
                NULL,  // paced sender.
@@ skipping 373 matching lines @@
 
 void VideoSender::ResendPacketsOnTransportThread(
     const transport::MissingFramesAndPacketsMap& missing_packets) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::TRANSPORT));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   transport_sender_->ResendPackets(false, missing_packets);
 }
 
 }  // namespace cast
 }  // namespace media