Mark template class RefCountedObject as final.

pc/webrtcsession_unittest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 291 matching lines @@
   rtc::PacketTransportInternal* rtcp_transport_channel(
       cricket::BaseChannel* ch) {
     if (!ch) {
       return nullptr;
     }
     return ch->rtcp_dtls_transport();
   }
 };
 
 class WebRtcSessionCreateSDPObserverForTest
-    : public rtc::RefCountedObject<CreateSessionDescriptionObserver> {
+    : public CreateSessionDescriptionObserver {
  public:
   enum State {
     kInit,
     kFailed,
     kSucceeded,
   };
   WebRtcSessionCreateSDPObserverForTest() : state_(kInit) {}
 
   // CreateSessionDescriptionObserver implementation.
   virtual void OnSuccess(SessionDescriptionInterface* desc) {
@@ skipping 458 matching lines @@
 
   SessionDescriptionInterface* CreateOffer() {
     PeerConnectionInterface::RTCOfferAnswerOptions options;
     options.offer_to_receive_audio =
         RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
     return CreateOffer(options);
   }
 
   SessionDescriptionInterface* CreateOffer(
       const PeerConnectionInterface::RTCOfferAnswerOptions options) {
-    rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
-        observer = new WebRtcSessionCreateSDPObserverForTest();
+    rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observer =
+        new rtc::RefCountedObject<WebRtcSessionCreateSDPObserverForTest>();
     cricket::MediaSessionOptions session_options;
     GetOptionsForOffer(options, &session_options);
     session_->CreateOffer(observer, options, session_options);
     EXPECT_TRUE_WAIT(
         observer->state() != WebRtcSessionCreateSDPObserverForTest::kInit,
         2000);
     return observer->ReleaseDescription();
   }
 
   SessionDescriptionInterface* CreateAnswer(
       const cricket::MediaSessionOptions& options) {
-    rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observer
-        = new WebRtcSessionCreateSDPObserverForTest();
+    rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observer =
+        new rtc::RefCountedObject<WebRtcSessionCreateSDPObserverForTest>();
     cricket::MediaSessionOptions session_options = options;
     GetOptionsForAnswer(&session_options);
     session_->CreateAnswer(observer, session_options);
     EXPECT_TRUE_WAIT(
         observer->state() != WebRtcSessionCreateSDPObserverForTest::kInit,
         2000);
     return observer->ReleaseDescription();
   }
 
   SessionDescriptionInterface* CreateAnswer() {
@@ skipping 797 matching lines @@
 
     PeerConnectionInterface::RTCOfferAnswerOptions options;
     cricket::MediaSessionOptions offer_session_options;
     cricket::MediaSessionOptions answer_session_options;
     GetOptionsForOffer(options, &offer_session_options);
     GetOptionsForAnswer(&answer_session_options);
     const int kNumber = 3;
     rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
         observers[kNumber];
     for (int i = 0; i < kNumber; ++i) {
-      observers[i] = new WebRtcSessionCreateSDPObserverForTest();
+      observers[i] =
+          new rtc::RefCountedObject<WebRtcSessionCreateSDPObserverForTest>();
       if (type == CreateSessionDescriptionRequest::kOffer) {
         session_->CreateOffer(observers[i], options, offer_session_options);
       } else {
         session_->CreateAnswer(observers[i], answer_session_options);
       }
     }
 
     WebRtcSessionCreateSDPObserverForTest::State expected_state =
         success ? WebRtcSessionCreateSDPObserverForTest::kSucceeded :
                   WebRtcSessionCreateSDPObserverForTest::kFailed;
@@ skipping 2905 matching lines @@
 TEST_F(WebRtcSessionTest, CreateOffersAndShutdown) {
   Init();
 
   rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observers[100];
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.offer_to_receive_audio =
       RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
   cricket::MediaSessionOptions session_options;
   GetOptionsForOffer(options, &session_options);
   for (auto& o : observers) {
-    o = new WebRtcSessionCreateSDPObserverForTest();
+    o = new rtc::RefCountedObject<WebRtcSessionCreateSDPObserverForTest>();
     session_->CreateOffer(o, options, session_options);
   }
 
   session_.reset();
 
   for (auto& o : observers) {
     // We expect to have received a notification now even if the session was
     // terminated.  The offer creation may or may not have succeeded, but we
     // must have received a notification which, so the only invalid state
     // is kInit.
     EXPECT_NE(WebRtcSessionCreateSDPObserverForTest::kInit, o->state());
   }
 }
 
 TEST_F(WebRtcSessionTest, TestPacketOptionsAndOnPacketSent) {
   TestPacketOptions();
 }
 
 // TODO(bemasc): Add a TestIceStatesBundle with BUNDLE enabled.  That test
 // currently fails because upon disconnection and reconnection OnIceComplete is
 // called more than once without returning to IceGatheringGathering.
 
 INSTANTIATE_TEST_CASE_P(WebRtcSessionTests,
                         WebRtcSessionTest,
                         testing::Values(ALREADY_GENERATED,
                                         DTLS_IDENTITY_STORE));