RefCounted types should not have public destructors, net/

net/base/net_log.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_BASE_NET_LOG_H_
 #define NET_BASE_NET_LOG_H_
 #pragma once
 
 #include <string>
 
@@ skipping 60 matching lines @@
     uint32 id;
   };
 
   // Base class for associating additional parameters with an event. Log
   // observers need to know what specific derivations of EventParameters a
   // particular EventType uses, in order to get at the individual components.
   class NET_EXPORT EventParameters
       : public base::RefCountedThreadSafe<EventParameters> {
    public:
     EventParameters() {}
-    virtual ~EventParameters() {}
 
     // Serializes the parameters to a Value tree. This is intended to be a
     // lossless conversion, which is used to serialize the parameters to JSON.
     // The caller takes ownership of the returned Value*.
     virtual base::Value* ToValue() const = 0;
 
+   protected:
+    virtual ~EventParameters() {}
+
    private:
+    friend class base::RefCountedThreadSafe<EventParameters>;
+
     DISALLOW_COPY_AND_ASSIGN(EventParameters);
   };
 
   // Specifies the granularity of events that should be emitted to the log.
   enum LogLevel {
     // Log everything possible, even if it is slow and memory expensive.
     // Includes logging of transferred bytes.
     LOG_ALL,
 
     // Log all events, but do not include the actual transferred bytes as
@@ skipping 215 matching lines @@
   NetLog::Source source_;
   NetLog* net_log_;
 };
 
 // NetLogStringParameter is a subclass of EventParameters that encapsulates a
 // single std::string parameter.
 class NET_EXPORT NetLogStringParameter : public NetLog::EventParameters {
  public:
   // |name| must be a string literal.
   NetLogStringParameter(const char* name, const std::string& value);
-  virtual ~NetLogStringParameter();
 
   const std::string& value() const {
     return value_;
   }
 
   virtual base::Value* ToValue() const OVERRIDE;
 
  private:
+  virtual ~NetLogStringParameter();
+
   const char* const name_;
   const std::string value_;
 };
 
 // NetLogIntegerParameter is a subclass of EventParameters that encapsulates a
 // single integer parameter.
 class NET_EXPORT NetLogIntegerParameter : public NetLog::EventParameters {
  public:
   // |name| must be a string literal.
   NetLogIntegerParameter(const char* name, int value)
       : name_(name), value_(value) {}
 
   int value() const {
     return value_;
   }
 
   virtual base::Value* ToValue() const OVERRIDE;
 
  private:
+  virtual ~NetLogIntegerParameter() {}
+
   const char* name_;
   const int value_;
 };
 
 // NetLogSourceParameter is a subclass of EventParameters that encapsulates a
 // single NetLog::Source parameter.
 class NET_EXPORT NetLogSourceParameter : public NetLog::EventParameters {
  public:
   // |name| must be a string literal.
   NetLogSourceParameter(const char* name, const NetLog::Source& value)
       : name_(name), value_(value) {}
 
   const NetLog::Source& value() const {
     return value_;
   }
 
   virtual base::Value* ToValue() const OVERRIDE;
 
  private:
+  virtual ~NetLogSourceParameter() {}
+
   const char* name_;
   const NetLog::Source value_;
 };
 
 // ScopedNetLogEvent logs a begin event on creation, and the corresponding end
 // event on destruction.
 class NET_EXPORT_PRIVATE ScopedNetLogEvent {
  public:
   ScopedNetLogEvent(const BoundNetLog& net_log,
                     NetLog::EventType event_type,
@@ skipping 11 matching lines @@
 
  private:
   BoundNetLog net_log_;
   const NetLog::EventType event_type_;
   scoped_refptr<NetLog::EventParameters> end_event_params_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_LOG_H_