Remove base::SupportsWeakPtr from FrameReceiver

media/cast/receiver/frame_receiver.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/receiver/frame_receiver.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/big_endian.h"
@@ skipping 95 matching lines @@
 
   if (!reports_are_scheduled_) {
     ScheduleNextRtcpReport();
     ScheduleNextCastMessage();
     reports_are_scheduled_ = true;
   }
 
   return true;
 }
 
+base::WeakPtr<FrameReceiver> FrameReceiver::AsWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
 void FrameReceiver::ProcessParsedPacket(const RtpCastHeader& rtp_header,
                                         const uint8_t* payload_data,
                                         size_t payload_size) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
   frame_id_to_rtp_timestamp_[rtp_header.frame_id.lower_8_bits()] =
       rtp_header.rtp_timestamp;
 
@@ skipping 109 matching lines @@
     if (!is_consecutively_next_frame) {
       // This assumes that decoding takes as long as playing, which might
       // not be true.
       const base::TimeTicks earliest_possible_end_time_of_missing_frame =
           now + expected_frame_duration_ * 2;
       if (earliest_possible_end_time_of_missing_frame < playout_time) {
         VLOG(1) << "Wait for next consecutive frame instead of skipping.";
         if (!is_waiting_for_consecutive_frame_) {
           is_waiting_for_consecutive_frame_ = true;
           cast_environment_->PostDelayedTask(
-              CastEnvironment::MAIN,
-              FROM_HERE,
+              CastEnvironment::MAIN, FROM_HERE,
               base::Bind(&FrameReceiver::EmitAvailableEncodedFramesAfterWaiting,
-                         weak_factory_.GetWeakPtr()),
+                         AsWeakPtr()),
               playout_time - now);
         }
         return;
       }
     }
 
     // At this point, we have the complete next frame, or a decodable
     // frame from somewhere later in the stream, AND we have given up
     // on waiting for any frames in between, so now we can ACK the frame.
     framer_.AckFrame(encoded_frame->frame_id);
@@ skipping 11 matching lines @@
       encoded_frame->data.swap(decrypted_data);
     }
 
     // At this point, we have a decrypted EncodedFrame ready to be emitted.
     encoded_frame->reference_time = playout_time;
     framer_.ReleaseFrame(encoded_frame->frame_id);
     if (encoded_frame->new_playout_delay_ms) {
       target_playout_delay_ = base::TimeDelta::FromMilliseconds(
           encoded_frame->new_playout_delay_ms);
     }
-    cast_environment_->PostTask(CastEnvironment::MAIN,
-                                FROM_HERE,
-                                base::Bind(&FrameReceiver::EmitOneFrame,
-                                           weak_factory_.GetWeakPtr(),
-                                           frame_request_queue_.front(),
-                                           base::Passed(&encoded_frame)));
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN, FROM_HERE,
+        base::Bind(&FrameReceiver::EmitOneFrame, AsWeakPtr(),
+                   frame_request_queue_.front(), base::Passed(&encoded_frame)));
     frame_request_queue_.pop_front();
   }
 }
 
 void FrameReceiver::EmitAvailableEncodedFramesAfterWaiting() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(is_waiting_for_consecutive_frame_);
   is_waiting_for_consecutive_frame_ = false;
   EmitAvailableEncodedFrames();
 }
@@ skipping 20 matching lines @@
 
 void FrameReceiver::ScheduleNextCastMessage() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks send_time;
   framer_.TimeToSendNextCastMessage(&send_time);
   base::TimeDelta time_to_send =
       send_time - cast_environment_->Clock()->NowTicks();
   time_to_send = std::max(
       time_to_send, base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
   cast_environment_->PostDelayedTask(
-      CastEnvironment::MAIN,
-      FROM_HERE,
-      base::Bind(&FrameReceiver::SendNextCastMessage,
-                 weak_factory_.GetWeakPtr()),
+      CastEnvironment::MAIN, FROM_HERE,
+      base::Bind(&FrameReceiver::SendNextCastMessage, AsWeakPtr()),
       time_to_send);
 }
 
 void FrameReceiver::SendNextCastMessage() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   framer_.SendCastMessage();  // Will only send a message if it is time.
   ScheduleNextCastMessage();
 }
 
 void FrameReceiver::ScheduleNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   cast_environment_->PostDelayedTask(
       CastEnvironment::MAIN, FROM_HERE,
-      base::Bind(&FrameReceiver::SendNextRtcpReport,
-                 weak_factory_.GetWeakPtr()),
+      base::Bind(&FrameReceiver::SendNextRtcpReport, AsWeakPtr()),
       base::TimeDelta::FromMilliseconds(kRtcpReportIntervalMs));
 }
 
 void FrameReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   RtpReceiverStatistics stats = stats_.GetStatistics();
   SendRtcpReport(rtcp_.local_ssrc(), rtcp_.remote_ssrc(),
                  CreateRtcpTimeData(now), nullptr, nullptr, base::TimeDelta(),
                  nullptr, &stats);
@@ skipping 40 matching lines @@
     transport_->AddCastFeedback(*cast_message, target_delay);
   if (pli_message)
     transport_->AddPli(*pli_message);
   if (rtcp_events)
     transport_->AddRtcpEvents(*rtcp_events);
   transport_->SendRtcpFromRtpReceiver();
 }
 
 }  // namespace cast
 }  // namespace media