RefCounted types should not have public destructors, net/

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 #pragma once
 
 #include <cstring>
 #include <deque>
@@ skipping 415 matching lines @@
 // complete in this step, but is marked asynchronous.  Write() returns
 // ERR_IO_PENDING.  The current step is still 1.  At this point RunFor(1) is
 // called which will cause the write callback to be invoked, and will then
 // stop.  The current state is now 2.  RunFor(1) is called again, which
 // causes the read callback to be invoked, and will then stop.  Then current
 // step is 2.  Write() is called again.  Then next available write is
 // synchronous so the call to Write() returns length.
 //
 // For examples of how to use this class, see:
 //   deterministic_socket_data_unittests.cc
-class DeterministicSocketData : public StaticSocketDataProvider,
-    public base::RefCounted<DeterministicSocketData> {
+class DeterministicSocketData
+    : public StaticSocketDataProvider,
+      public base::RefCounted<DeterministicSocketData> {
  public:
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   DeterministicSocketData(MockRead* reads, size_t reads_count,
                           MockWrite* writes, size_t writes_count);
-  virtual ~DeterministicSocketData();
 
   // Consume all the data up to the give stop point (via SetStop()).
   void Run();
 
   // Set the stop point to be |steps| from now, and then invoke Run().
   void RunFor(int steps);
 
   // Stop at step |seq|, which must be in the future.
   virtual void SetStop(int seq);
 
@@ skipping 15 matching lines @@
   virtual MockRead GetNextRead() OVERRIDE;
 
   // When the socket calls Write(), it always completes synchronously. OnWrite()
   // checks to make sure the written data matches the expected data. The
   // callback will not be invoked until its sequence number is reached.
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
   virtual void Reset() OVERRIDE;
   virtual void CompleteRead() OVERRIDE {}
 
  private:
+  friend class base::RefCounted<DeterministicSocketData>;
+  virtual ~DeterministicSocketData();
+
   // Invoke the read and write callbacks, if the timing is appropriate.
   void InvokeCallbacks();
 
   void NextStep();
 
   int sequence_number_;
   MockRead current_read_;
   MockWrite current_write_;
   int stopping_sequence_number_;
   bool stopped_;
@@ skipping 554 matching lines @@
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_