RefCounted types should not have public destructors, net/

net/base/host_resolver_impl.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 "net/base/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 157 matching lines @@
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addr_list,
                       int* os_error) OVERRIDE {
     return SystemHostResolverProc(hostname,
                                   address_family,
                                   host_resolver_flags,
                                   addr_list,
                                   os_error);
   }
+
+ private:
+  virtual ~CallSystemHostResolverProc() {}
 };
 
 // Extra parameters to attach to the NetLog when the resolve failed.
 class ProcTaskFailedParams : public NetLog::EventParameters {
  public:
   ProcTaskFailedParams(uint32 attempt_number, int net_error, int os_error)
       : attempt_number_(attempt_number),
         net_error_(net_error),
         os_error_(os_error) {
   }
@@ skipping 22 matching lines @@
                                0);  // Arguments (unused).
       dict->SetString("os_error_string", WideToUTF8(error_string));
       LocalFree(error_string);
 #endif
     }
 
     return dict;
   }
 
  private:
+  virtual ~ProcTaskFailedParams() {}
+
   const uint32 attempt_number_;
   const int net_error_;
   const int os_error_;
 };
 
 // Extra parameters to attach to the NetLog when the DnsTask failed.
 class DnsTaskFailedParams : public NetLog::EventParameters {
  public:
   DnsTaskFailedParams(int net_error, int dns_error)
       : net_error_(net_error), dns_error_(dns_error) {
   }
 
   virtual Value* ToValue() const OVERRIDE {
     DictionaryValue* dict = new DictionaryValue();
     dict->SetInteger("net_error", net_error_);
     if (dns_error_)
       dict->SetInteger("dns_error", dns_error_);
     return dict;
   }
 
  private:
+  virtual ~DnsTaskFailedParams() {}
+
   const int net_error_;
   const int dns_error_;
 };
 
 // Parameters representing the information in a RequestInfo object, along with
 // the associated NetLog::Source.
 class RequestInfoParameters : public NetLog::EventParameters {
  public:
   RequestInfoParameters(const HostResolver::RequestInfo& info,
                         const NetLog::Source& source)
       : info_(info), source_(source) {}
 
   virtual Value* ToValue() const OVERRIDE {
     DictionaryValue* dict = new DictionaryValue();
     dict->SetString("host", info_.host_port_pair().ToString());
     dict->SetInteger("address_family",
                      static_cast<int>(info_.address_family()));
     dict->SetBoolean("allow_cached_response", info_.allow_cached_response());
     dict->SetBoolean("is_speculative", info_.is_speculative());
     dict->SetInteger("priority", info_.priority());
 
     if (source_.is_valid())
       dict->Set("source_dependency", source_.ToValue());
 
     return dict;
   }
 
  private:
+  virtual ~RequestInfoParameters() {}
+
   const HostResolver::RequestInfo info_;
   const NetLog::Source source_;
 };
 
 // Parameters associated with the creation of a HostResolverImpl::Job.
 class JobCreationParameters : public NetLog::EventParameters {
  public:
   JobCreationParameters(const std::string& host,
                         const NetLog::Source& source)
       : host_(host), source_(source) {}
 
   virtual Value* ToValue() const OVERRIDE {
     DictionaryValue* dict = new DictionaryValue();
     dict->SetString("host", host_);
     dict->Set("source_dependency", source_.ToValue());
     return dict;
   }
 
  private:
+  virtual ~JobCreationParameters() {}
+
   const std::string host_;
   const NetLog::Source source_;
 };
 
 // Parameters of the HOST_RESOLVER_IMPL_JOB_ATTACH/DETACH event.
 class JobAttachParameters : public NetLog::EventParameters {
  public:
   JobAttachParameters(const NetLog::Source& source,
                       RequestPriority priority)
       : source_(source), priority_(priority) {}
 
   virtual Value* ToValue() const OVERRIDE {
     DictionaryValue* dict = new DictionaryValue();
     dict->Set("source_dependency", source_.ToValue());
     dict->SetInteger("priority", priority_);
     return dict;
   }
 
  private:
+  virtual ~JobAttachParameters() {}
+
   const NetLog::Source source_;
   const RequestPriority priority_;
 };
 
 // Parameters of the DNS_CONFIG_CHANGED event.
 class DnsConfigParameters : public NetLog::EventParameters {
  public:
   explicit DnsConfigParameters(const DnsConfig& config)
       : num_hosts_(config.hosts.size()) {
     config_.CopyIgnoreHosts(config);
   }
 
   virtual Value* ToValue() const OVERRIDE {
     Value* value = config_.ToValue();
     if (!value)
       return NULL;
     DictionaryValue* dict;
     if (value->GetAsDictionary(&dict))
       dict->SetInteger("num_hosts", num_hosts_);
     return value;
   }
 
  private:
+  virtual ~DnsConfigParameters() {}
+
   DnsConfig config_;  // Does not include DnsHosts to save memory and work.
   const size_t num_hosts_;
 };
 
 // The logging routines are defined here because some requests are resolved
 // without a Request object.
 
 // Logs when a request has just been started.
 void LogStartRequest(const BoundNetLog& source_net_log,
                      const BoundNetLog& request_net_log,
@@ skipping 290 matching lines @@
     DCHECK(origin_loop_->BelongsToCurrentThread());
     return callback_.is_null();
   }
 
   bool was_completed() const {
     DCHECK(origin_loop_->BelongsToCurrentThread());
     return completed_attempt_number_ > 0;
   }
 
  private:
+  friend base::RefCountedThreadSafe<ProcTask>;
+  virtual ~ProcTask() {}
+
   void StartLookupAttempt() {
     DCHECK(origin_loop_->BelongsToCurrentThread());
     base::TimeTicks start_time = base::TimeTicks::Now();
     ++attempt_number_;
     // Dispatch the lookup attempt to a worker thread.
     if (!base::WorkerPool::PostTask(
             FROM_HERE,
             base::Bind(&ProcTask::DoLookup, this, start_time, attempt_number_),
             true)) {
       NOTREACHED();
@@ skipping 1303 matching lines @@
 
   if (self && dns_config.IsValid())
     TryServingAllJobsFromHosts();
 }
 
 bool HostResolverImpl::HaveDnsConfig() const {
   return (dns_client_.get() != NULL) && (dns_client_->GetConfig() != NULL);
 }
 
 }  // namespace net