RefCounted types should not have public destructors, base/ edition

base/message_loop_unittest.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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/eintr_wrapper.h"
@@ skipping 379 matching lines @@
 #endif  // defined(OS_WIN)
 
 // This is used to inject a test point for recording the destructor calls for
 // Closure objects send to MessageLoop::PostTask(). It is awkward usage since we
 // are trying to hook the actual destruction, which is not a common operation.
 class RecordDeletionProbe : public base::RefCounted<RecordDeletionProbe> {
  public:
   RecordDeletionProbe(RecordDeletionProbe* post_on_delete, bool* was_deleted)
       : post_on_delete_(post_on_delete), was_deleted_(was_deleted) {
   }
+  void Run() {}
+
+ private:
+  friend class base::RefCounted<RecordDeletionProbe>;
+
   ~RecordDeletionProbe() {
     *was_deleted_ = true;
     if (post_on_delete_)
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&RecordDeletionProbe::Run, post_on_delete_.get()));
   }
-  void Run() {}
- private:
+
   scoped_refptr<RecordDeletionProbe> post_on_delete_;
   bool* was_deleted_;
 };
 
 void RunTest_EnsureDeletion(MessageLoop::Type message_loop_type) {
   bool a_was_deleted = false;
   bool b_was_deleted = false;
   {
     MessageLoop loop(message_loop_type);
     loop.PostTask(
@@ skipping 1198 matching lines @@
 // send to MessageLoop::PostTask(). It is awkward usage since we are trying to
 // hook the actual destruction, which is not a common operation.
 class DestructionObserverProbe :
   public base::RefCounted<DestructionObserverProbe> {
  public:
   DestructionObserverProbe(bool* task_destroyed,
                            bool* destruction_observer_called)
       : task_destroyed_(task_destroyed),
         destruction_observer_called_(destruction_observer_called) {
   }
-  virtual ~DestructionObserverProbe() {
-    EXPECT_FALSE(*destruction_observer_called_);
-    *task_destroyed_ = true;
-  }
   virtual void Run() {
     // This task should never run.
     ADD_FAILURE();
   }
  private:
+  friend class base::RefCounted<DestructionObserverProbe>;
+
+  virtual ~DestructionObserverProbe() {
+    EXPECT_FALSE(*destruction_observer_called_);
+    *task_destroyed_ = true;
+  }
+
   bool* task_destroyed_;
   bool* destruction_observer_called_;
 };
 
 class MLDestructionObserver : public MessageLoop::DestructionObserver {
  public:
   MLDestructionObserver(bool* task_destroyed, bool* destruction_observer_called)
       : task_destroyed_(task_destroyed),
         destruction_observer_called_(destruction_observer_called),
         task_destroyed_before_message_loop_(false) {
@@ skipping 29 matching lines @@
       base::Bind(&DestructionObserverProbe::Run,
                  new DestructionObserverProbe(&task_destroyed,
                                               &destruction_observer_called)),
       kDelay);
   delete loop;
   EXPECT_TRUE(observer.task_destroyed_before_message_loop());
   // The task should have been destroyed when we deleted the loop.
   EXPECT_TRUE(task_destroyed);
   EXPECT_TRUE(destruction_observer_called);
 }