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 14 matching lines @@
   // ERR_IO_PENDING or data.
   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 {}
 
+ protected:
+  virtual ~DeterministicSocketData();
+
  private:
+  friend class base::RefCounted<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_;
   base::WeakPtr<DeterministicMockTCPClientSocket> socket_;
   bool print_debug_;
 };
 
 // Holds an array of SocketDataProvider elements.  As Mock{TCP,SSL}StreamSocket
 // objects get instantiated, they take their data from the i'th element of this
 // array.
 template<typename T>
 class SocketDataProviderArray {
  public:
-  SocketDataProviderArray() : next_index_(0) {
-  }
+  SocketDataProviderArray() : next_index_(0) {}
 
   T* GetNext() {
     DCHECK_LT(next_index_, data_providers_.size());
     return data_providers_[next_index_++];
   }
 
   void Add(T* data_provider) {
     DCHECK(data_provider);
     data_providers_.push_back(data_provider);
   }
@@ skipping 532 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_