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

chrome/service/cloud_print/print_system_cups.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 "chrome/service/cloud_print/print_system.h"
 
 #include <cups/cups.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
@@ skipping 109 matching lines @@
     return update_timeout_;
   }
 
   bool NotifyDelete() const {
     // Notify about deleted printers only when we
     // fetched printers list without errors.
     return notify_delete_ && printer_enum_succeeded_;
   }
 
  private:
+  virtual ~PrintSystemCUPS() {}
+
   // Following functions are wrappers around corresponding CUPS functions.
   // <functions>2()  are called when print server is specified, and plain
   // version in another case. There is an issue specifing CUPS_HTTP_DEFAULT
   // in the <functions>2(), it does not work in CUPS prior to 1.4.
   int GetJobs(cups_job_t** jobs, const GURL& url, const char* name,
               int myjobs, int whichjobs);
   int PrintFile(const GURL& url, const char* name, const char* filename,
                 const char* title, int num_options, cups_option_t* options);
 
   void InitPrintBackends(const DictionaryValue* print_system_settings);
@@ skipping 26 matching lines @@
   bool notify_delete_;
 };
 
 class PrintServerWatcherCUPS
   : public PrintSystem::PrintServerWatcher {
  public:
   explicit PrintServerWatcherCUPS(PrintSystemCUPS* print_system)
       : print_system_(print_system),
         delegate_(NULL) {
   }
-  ~PrintServerWatcherCUPS() {
-    StopWatching();
-  }
 
   // PrintSystem::PrintServerWatcher implementation.
   virtual bool StartWatching(
       PrintSystem::PrintServerWatcher::Delegate* delegate) OVERRIDE {
     delegate_ = delegate;
     printers_hash_ = GetPrintersHash();
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrintServerWatcherCUPS::CheckForUpdates, this),
         print_system_->GetUpdateTimeout());
@@ skipping 13 matching lines @@
     if (printers_hash_ != new_hash) {
       printers_hash_ = new_hash;
       delegate_->OnPrinterAdded();
     }
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrintServerWatcherCUPS::CheckForUpdates, this),
         print_system_->GetUpdateTimeout());
   }
 
+ protected:
+  virtual ~PrintServerWatcherCUPS() {
+    StopWatching();
+  }
+
  private:
   std::string GetPrintersHash() {
     printing::PrinterList printer_list;
     print_system_->EnumeratePrinters(&printer_list);
 
     // Sort printer names.
     std::vector<std::string> printers;
     printing::PrinterList::iterator it;
     for (it = printer_list.begin(); it != printer_list.end(); ++it)
       printers.push_back(it->printer_name);
@@ skipping 16 matching lines @@
 class PrinterWatcherCUPS
     : public PrintSystem::PrinterWatcher {
  public:
   PrinterWatcherCUPS(PrintSystemCUPS* print_system,
                      const std::string& printer_name)
       : printer_name_(printer_name),
         delegate_(NULL),
         print_system_(print_system) {
   }
 
-  ~PrinterWatcherCUPS() {
-    StopWatching();
-  }
-
   // PrintSystem::PrinterWatcher implementation.
   virtual bool StartWatching(
       PrintSystem::PrinterWatcher::Delegate* delegate) OVERRIDE{
     scoped_refptr<printing::PrintBackend> print_backend(
         printing::PrintBackend::CreateInstance(NULL));
     child_process_logging::ScopedPrinterInfoSetter prn_info(
         print_backend->GetPrinterDriverInfo(printer_name_));
     if (delegate_ != NULL)
       StopWatching();
     delegate_ = delegate;
@@ skipping 51 matching lines @@
         delegate_->OnPrinterChanged();
         VLOG(1) << "CP_CUPS: Printer update detected for: " << printer_name_;
       }
     }
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrinterWatcherCUPS::PrinterUpdate, this),
         print_system_->GetUpdateTimeout());
   }
 
+ protected:
+  virtual ~PrinterWatcherCUPS() {
+    StopWatching();
+  }
+
  private:
   std::string GetSettingsHash() {
     printing::PrinterBasicInfo info;
     if (!print_system_->GetPrinterInfo(printer_name_, &info))
       return std::string();
 
     printing::PrinterCapsAndDefaults caps;
     if (!print_system_->GetPrinterCapsAndDefaults(printer_name_, &caps))
       return std::string();
 
@@ skipping 47 matching lines @@
   }
 
   static void NotifyDelegate(JobSpooler::Delegate* delegate,
                              int job_id, bool dry_run) {
     if (dry_run || job_id)
       delegate->OnJobSpoolSucceeded(job_id);
     else
       delegate->OnJobSpoolFailed();
   }
 
+ protected:
+  virtual ~JobSpoolerCUPS() {}
+
  private:
   scoped_refptr<PrintSystemCUPS> print_system_;
 
   DISALLOW_COPY_AND_ASSIGN(JobSpoolerCUPS);
 };
 
 PrintSystemCUPS::PrintSystemCUPS(const DictionaryValue* print_system_settings)
     : update_timeout_(base::TimeDelta::FromMinutes(
         kCheckForPrinterUpdatesMinutes)),
       initialized_(false),
@@ skipping 429 matching lines @@
 
 void PrintSystemCUPS::RunCapsCallback(
     const PrinterCapsAndDefaultsCallback& callback,
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& printer_info) {
   callback.Run(succeeded, printer_name, printer_info);
 }
 
 }  // namespace cloud_print