Remove base::SupportsWeakPtr from {Audio,Video}Sender

media/cast/sender/video_sender.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/video_sender.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
@@ skipping 92 matching lines @@
                     (video_config.min_bitrate + video_config.max_bitrate) / 2)
               : NewAdaptiveCongestionControl(cast_environment->Clock(),
                                              video_config.max_bitrate,
                                              video_config.min_bitrate,
                                              video_config.max_frame_rate)),
       frames_in_encoder_(0),
       last_bitrate_(0),
       playout_delay_change_cb_(playout_delay_change_cb),
       low_latency_mode_(false),
       last_reported_encoder_utilization_(-1.0),
-      last_reported_lossy_utilization_(-1.0),
-      weak_factory_(this) {
+      last_reported_lossy_utilization_(-1.0) {
   video_encoder_ = VideoEncoder::Create(
       cast_environment_,
       video_config,
       status_change_cb,
       create_vea_cb,
       create_video_encode_mem_cb);
   if (!video_encoder_) {
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
@@ skipping 125 matching lines @@
 
   TRACE_COUNTER_ID1("cast.stream", "Video Target Bitrate", this, bitrate);
 
   const scoped_refptr<VideoFrame> frame_to_encode =
       MaybeRenderPerformanceMetricsOverlay(
           GetTargetPlayoutDelay(), low_latency_mode_, bitrate,
           frames_in_encoder_ + 1, last_reported_encoder_utilization_,
           last_reported_lossy_utilization_, video_frame);
   if (video_encoder_->EncodeVideoFrame(
           frame_to_encode, reference_time,
-          base::Bind(&VideoSender::OnEncodedVideoFrame,
-                     weak_factory_.GetWeakPtr(), frame_to_encode, bitrate))) {
+          base::Bind(&VideoSender::OnEncodedVideoFrame, AsWeakPtr(),
+                     frame_to_encode, bitrate))) {
     TRACE_EVENT_ASYNC_BEGIN1("cast.stream", "Video Encode",
                              frame_to_encode.get(), "rtp_timestamp",
                              rtp_timestamp.lower_32_bits());
     frames_in_encoder_++;
     duration_in_encoder_ += duration_added_by_next_frame;
     last_enqueued_frame_rtp_timestamp_ = rtp_timestamp;
     last_enqueued_frame_reference_time_ = reference_time;
   } else {
     VLOG(1) << "Encoder rejected a frame.  Skipping...";
     TRACE_EVENT_INSTANT1("cast.stream", "Video Encode Reject",
@@ skipping 59 matching lines @@
         media::VideoFrameMetadata::RESOURCE_UTILIZATION,
         encoded_frame->dependency == EncodedFrame::KEY ?
             std::min(1.0, attenuated_utilization) : attenuated_utilization);
   }
 
   SendEncodedFrame(encoder_bitrate, std::move(encoded_frame));
 }
 
 }  // namespace cast
 }  // namespace media