RefCounted types should not have public destructors, media/ and gpu/ edition

gpu/command_buffer/client/ref_counted.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_CLIENT_REF_COUNTED_H_
 #define GPU_COMMAND_BUFFER_CLIENT_REF_COUNTED_H_
 
 #if defined(__native_client__)
 #include "native_client/src/include/ref_counted.h"
 namespace gpu {
 template <class T>
-struct RefCountedThreadSafe : public nacl::RefCounted<T> {
+class RefCountedThreadSafe : public nacl::RefCounted<T> {

[Ryan Sleevi, 2012/04/13 09:40:00]

I don't suppose there's any chance this can be renamed? ;-)

I suspect this is going to break down in a pure-NaCL compile. This could be
worked around by having RefCounted<> take a Traits class, much like
base::RefCountedThreadSafe<> does. Then we do the exact same trick
base::RefCountedThreadSafe<> does to specialize the default traits so that
friending "gpu::RefCountedThreadSafe" in a NaCL build does the right thing.

When building on Mac, however, I have no clue how to build this target.

[greggman, 2012/04/13 17:19:24]

This is already compiling in NaCl. What am I missing?

Feel free to change it though.

[Ryan Sleevi, 2012/04/13 17:30:01]

It compiles because the destructors are public today.

In the GPU code, the pattern is "friend class
gpu::RefCountedThreadSafe<MyClassHere>;". Prior to this change, it worked for
both base::RCTS and nacl::RC<>, because the destructors were public.

However, when making the destructors protected/private, it doesn't, because
gpu::RCTS is not the one doing the actual deleting, so the friend specifier
gives no access to the base class, only the derived (here or on line 25). That
is, "gpu::RCTS<T>" does not delete T - the (unfriend) base::RCTS<>/nacl::RT<>
do.

This is easily worked around for the base::RCTS by making gpu::RCTS an alias via
using (since you can't typedef templates). But for nacl::RC<>, I suspect this is
going to break.

The 'trick' is the same as base::RCTS - define a traits parameter for
nacl::RC<>, have nacl::RC<> call the traits to do the delete, have the traits
call the (derived) gpu::RCTS, so that the effective "friend class gpu::RCTS<T>"
works and exposes the destructor (which is still invisible to nacl::RC<>).

The question is: What steps are needed to build and test this to work it out?

+ public:
+  RefCountedThreadSafe() {}
+  ~RefCountedThreadSafe() {}
+
+ private:
+  RefCountedThreadSafe(const RefCountedThreadSafe<T>&);
+  void operator=(const RefCountedThreadSafe<T>&);
 };
 }
 #else
 #include "base/memory/ref_counted.h"
 namespace gpu {
-template <class T>
-struct RefCountedThreadSafe : public base::RefCountedThreadSafe<T> {
-};
+using base::RefCountedThreadSafe;
 }
 #endif
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_REF_COUNTED_H_