RefCounted types should not have public destructors, Linux fixes

content/browser/power_save_blocker_linux.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 "content/browser/power_save_blocker.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 // Xlib #defines Status, but we can't have that for some of our headers.
 #ifdef Status
@@ skipping 53 matching lines @@
   // D-Bus interface. It is responsible for obtaining specific object proxies,
   // making D-Bus method calls and handling D-Bus responses.
   //
   // When a new DBusPowerBlocker is created, only a specific implementation of
   // the delegate is instantiated. See the DBusPowerSaveBlocker constructor for
   // more details. This is ref_counted to make sure that the callbacks stay
   // alive even after the DBusPowerSaveBlocker object is deleted.
   class Delegate : public base::RefCountedThreadSafe<Delegate> {
    public:
     Delegate() {}
+    virtual void ApplyBlock(PowerSaveBlocker::PowerSaveBlockerType type) = 0;
+
+   protected:
     virtual ~Delegate() {}
-    virtual void ApplyBlock(PowerSaveBlocker::PowerSaveBlockerType type) = 0;
+
    private:
+    friend class base::RefCountedThreadSafe<Delegate>;
+
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // Returns a pointer to the sole instance of this class
   static DBusPowerSaveBlocker* GetInstance();
 
   // Forwards a power save block request to the concrete implementation of the
   // Delegate interface. If |delegate_| is NULL, the application runs under an
   // unsupported desktop environment. In this case, the method does nothing.
   void ApplyBlock(PowerSaveBlocker::PowerSaveBlockerType type) {
@@ skipping 26 matching lines @@
 
 // Delegate implementation for KDE4. It uses the
 // org.freedesktop.PowerManagement interface. It works on XFCE4, too.
 class KDEPowerSaveBlocker : public DBusPowerSaveBlocker::Delegate {
  public:
   KDEPowerSaveBlocker()
       : inhibit_cookie_(0),
         pending_inhibit_call_(false),
         postponed_uninhibit_call_(false) {
   }
-  ~KDEPowerSaveBlocker() {}
 
   virtual void ApplyBlock(
       PowerSaveBlocker::PowerSaveBlockerType type) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(pending_inhibit_call_ || !postponed_uninhibit_call_);
 
     // If we have a pending inhibit call, we add a postponed uninhibit
     // request, such that it will be canceled as soon as the response arrives.
     // If we have an active inhibit request and receive a new one,
     // we ignore it since the 'freedesktop' interface has only one Inhibit level
@@ skipping 54 matching lines @@
         // This is an invalid argument
         NOTREACHED();
         break;
     }
 
     object_proxy->CallMethod(&method_call,
                              dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                              bus_callback);
   }
 
+ protected:
+  virtual ~KDEPowerSaveBlocker() {}
+
  private:
   // Inhibit() response callback.
   // Stores the cookie so we can use it later when calling UnInhibit().
   // If the response from D-Bus is successful and there is a postponed
   // uninhibit request, we cancel the cookie that we just received.
   void OnInhibitResponse(dbus::Response* response) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(pending_inhibit_call_);
     pending_inhibit_call_ = false;
     if (response) {
@@ skipping 43 matching lines @@
     kInhibitLogOut            = 1,
     kInhibitSwitchUser        = 2,
     kInhibitSuspendSession    = 4,
     kInhibitMarkSessionAsIdle = 8
   };
 
   GnomePowerSaveBlocker()
       : inhibit_cookie_(0),
         pending_inhibit_calls_(0),
         postponed_uninhibit_calls_(0) {}
-  ~GnomePowerSaveBlocker() {}
 
   virtual void ApplyBlock(
       PowerSaveBlocker::PowerSaveBlockerType type) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(postponed_uninhibit_calls_ <= pending_inhibit_calls_);
 
     // If we have a pending inhibit call, we add a postponed uninhibit request,
     // such that it will be canceled as soon as the response arrives. We want to
     // cancel the current inhibit request whether |type| is
     // kPowerSaveBlockPreventNone or not. If |type| represents an inhibit
@@ skipping 89 matching lines @@
         // This is an invalid argument.
         NOTREACHED();
         break;
     }
 
     object_proxy->CallMethod(&method_call,
                              dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                              bus_callback);
   }
 
+ protected:
+  virtual ~GnomePowerSaveBlocker() {}
+
  private:
   // Inhibit() response callback.
   // Stores the cookie so we can use it later when calling UnInhibit().
   // If the response from D-Bus is successful and there is a postponed
   // uninhibit request, we cancel the cookie that we just received.
   void OnInhibitResponse(dbus::Response* response) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK_GT(pending_inhibit_calls_, 0);
     --pending_inhibit_calls_;
     if (response) {
@@ skipping 111 matching lines @@
 }
 
 }  // namespace
 
 // Called only from UI thread.
 // static
 void PowerSaveBlocker::ApplyBlock(PowerSaveBlockerType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DBusPowerSaveBlocker::GetInstance()->ApplyBlock(type);
 }