RefCounted types should not have public destructors, chrome/ remaining parts

chrome/service/cloud_print/print_system.h

 // Copyright (c) 2011 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 CHROME_SERVICE_CLOUD_PRINT_PRINT_SYSTEM_H_
 #define CHROME_SERVICE_CLOUD_PRINT_PRINT_SYSTEM_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 66 matching lines @@
     // Callback interface for new printer notifications.
     class Delegate {
       public:
         virtual void OnPrinterAdded() = 0;
         // TODO(gene): Do we need OnPrinterDeleted notification here?
 
       protected:
         virtual ~Delegate() {}
     };
 
-    virtual ~PrintServerWatcher();
     virtual bool StartWatching(PrintServerWatcher::Delegate* delegate) = 0;
     virtual bool StopWatching() = 0;
+
+   protected:
+    friend class base::RefCountedThreadSafe<PrintServerWatcher>;
+    virtual ~PrintServerWatcher();
   };
 
   class PrinterWatcher : public base::RefCountedThreadSafe<PrinterWatcher> {
    public:
     // Callback interface for printer updates notifications.
     class Delegate {
       public:
         virtual void OnPrinterDeleted() = 0;
         virtual void OnPrinterChanged() = 0;
         virtual void OnJobChanged() = 0;
 
       protected:
         virtual ~Delegate() {}
     };
 
-    virtual ~PrinterWatcher();
     virtual bool StartWatching(PrinterWatcher::Delegate* delegate) = 0;
     virtual bool StopWatching() = 0;
     virtual bool GetCurrentPrinterInfo(
         printing::PrinterBasicInfo* printer_info) = 0;
+
+   protected:
+    friend class base::RefCountedThreadSafe<PrinterWatcher>;
+    virtual ~PrinterWatcher();
   };
 
   class JobSpooler : public base::RefCountedThreadSafe<JobSpooler> {
    public:
     // Callback interface for JobSpooler notifications.
     class Delegate {
       public:
         virtual ~Delegate() { }
         virtual void OnJobSpoolSucceeded(const PlatformJobId& job_id) = 0;
         virtual void OnJobSpoolFailed() = 0;
     };
 
-    virtual ~JobSpooler();
     // Spool job to the printer asynchronously. Caller will be notified via
     // |delegate|. Note that only one print job can be in progress at any given
     // time. Subsequent calls to Spool (before the Delegate::OnJobSpoolSucceeded
     // or Delegate::OnJobSpoolFailed methods are called) can fail.
     virtual bool Spool(const std::string& print_ticket,
                        const FilePath& print_data_file_path,
                        const std::string& print_data_mime_type,
                        const std::string& printer_name,
                        const std::string& job_title,
                        const std::vector<std::string>& tags,
                        JobSpooler::Delegate* delegate) = 0;
+   protected:
+    friend class base::RefCountedThreadSafe<JobSpooler>;
+    virtual ~JobSpooler();
   };
 
   class PrintSystemResult {
    public:
     PrintSystemResult(bool succeeded, const std::string& message)
         : succeeded_(succeeded), message_(message) { }
     bool succeeded() const { return succeeded_; }
     std::string message() const { return message_; }
 
    private:
+    PrintSystemResult() {}
+
     bool succeeded_;
     std::string message_;
-
-    PrintSystemResult() { }
   };
 
   typedef base::Callback<void(bool,
                               const std::string&,
                               const printing::PrinterCapsAndDefaults&)>
       PrinterCapsAndDefaultsCallback;
 
-  virtual ~PrintSystem();
-
   // Initialize print system. This need to be called before any other function
   // of PrintSystem.
   virtual PrintSystemResult Init() = 0;
 
   // Enumerates the list of installed local and network printers.
   virtual PrintSystemResult EnumeratePrinters(
       printing::PrinterList* printer_list) = 0;
 
   // Gets the capabilities and defaults for a specific printer asynchronously.
   virtual void GetPrinterCapsAndDefaults(
@@ skipping 25 matching lines @@
   virtual std::string GetSupportedMimeTypes() = 0;
 
   // Generate unique for proxy.
   static std::string GenerateProxyId();
 
   // Call this function to obtain printing system for specified print server.
   // If print settings are NULL, default settings will be used.
   // Return NULL if no print system available.
   static scoped_refptr<PrintSystem> CreateInstance(
       const base::DictionaryValue* print_system_settings);
+
+ protected:
+  friend class base::RefCountedThreadSafe<PrintSystem>;
+  virtual ~PrintSystem();
 };
 
 
 // This typedef is to workaround the issue with certain versions of
 // Visual Studio where it gets confused between multiple Delegate
 // classes and gives a C2500 error. (I saw this error on the try bots -
 // the workaround was not needed for my machine).
 typedef PrintSystem::PrintServerWatcher::Delegate PrintServerWatcherDelegate;
 typedef PrintSystem::PrinterWatcher::Delegate PrinterWatcherDelegate;
 typedef PrintSystem::JobSpooler::Delegate JobSpoolerDelegate;
 
 }  // namespace cloud_print
 
 #endif  // CHROME_SERVICE_CLOUD_PRINT_PRINT_SYSTEM_H_