RefCounted types should not have public destructors, content/browser part 2

content/renderer/p2p/p2p_transport_impl_unittest.cc

 // Copyright (c) 2012 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 "content/renderer/p2p/p2p_transport_impl.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
@@ skipping 40 matching lines @@
         write_socket_(write_socket),
         read_socket_(read_socket),
         done_(false),
         write_errors_(0),
         read_errors_(0),
         packets_sent_(0),
         packets_received_(0),
         broken_packets_(0) {
   }
 
-  virtual ~UdpChannelTester() { }
-
   void Start() {
     message_loop_->PostTask(
         FROM_HERE, base::Bind(&UdpChannelTester::DoStart, this));
   }
 
   void CheckResults() {
     EXPECT_EQ(0, write_errors_);
     EXPECT_EQ(0, read_errors_);
 
     EXPECT_EQ(0, broken_packets_);
 
     // Verify that we've received at least one packet.
     EXPECT_GT(packets_received_, 0);
     LOG(INFO) << "Received " << packets_received_ << " packets out of "
               << kMessages;
   }
 
  protected:
+  friend class base::RefCountedThreadSafe<UdpChannelTester>;
+  virtual ~UdpChannelTester() {}
+
   void Done() {
     done_ = true;
     message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   void DoStart() {
     DoRead();
     DoWrite();
   }
 
@@ skipping 101 matching lines @@
                 net::Socket* write_socket,
                 net::Socket* read_socket)
       : message_loop_(message_loop),
         write_socket_(write_socket),
         read_socket_(read_socket),
         done_(false),
         write_errors_(0),
         read_errors_(0) {
   }
 
-  virtual ~TcpChannelTester() { }
-
   void Init() {
     // Initialize |send_buffer_|.
     send_buffer_ = new net::DrainableIOBuffer(new net::IOBuffer(kTcpDataSize),
                                               kTcpDataSize);
     for (int i = 0; i < kTcpDataSize; ++i) {
       send_buffer_->data()[i] = rand() % 256;
     }
   }
 
   void StartRead() {
@@ skipping 12 matching lines @@
 
     EXPECT_EQ(0, send_buffer_->BytesRemaining());
 
     send_buffer_->SetOffset(0);
     EXPECT_EQ(kTcpDataSize, static_cast<int>(received_data_.size()));
     EXPECT_EQ(0, memcmp(send_buffer_->data(),
                         &received_data_[0], received_data_.size()));
   }
 
  protected:
+  friend class base::RefCountedThreadSafe<TcpChannelTester>;
+  virtual ~TcpChannelTester() {}
+
   void Done() {
     done_ = true;
     message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   void DoWrite() {
     if (send_buffer_->BytesRemaining() == 0) {
       return;
     }
 
@@ skipping 273 matching lines @@
                                        P2PTransport::STATE_WRITABLE)))
       .Times(Exactly(1))
       .WillOnce(DoAll(
           InvokeWithoutArgs(this, &P2PTransportImplTest::DestroyTransport),
           InvokeWithoutArgs(&message_loop_, &MessageLoop::Quit)));
 
   message_loop_.Run();
 }
 
 }  // namespace content