Make the Pepper proxy support in-process font rendering.

base/bind_helpers.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.
 
 // This defines a set of argument wrappers and related factory methods that
 // can be used specify the refcounting and reference semantics of arguments
 // that are bound by the Bind() function in base/bind.h.
 //
 // The public functions are base::Unretained() and base::ConstRef().
 // Unretained() allows Bind() to bind a non-refcounted class.
@@ skipping 105 matching lines @@
 // exist, then &C::TargetFunc is not ambiguous, and the overload resolution
 // will prefer GoodCheck(Helper<&C::TargetFunc>*).
 //
 // This method of SFINAE will correctly probe for inherited names, but it cannot
 // typecheck those names.  It's still a good enough sanity check though.
 //
 // Works on gcc-4.2, gcc-4.4, and Visual Studio 2008.
 //
 // TODO(ajwong): Move to ref_counted.h or template_util.h when we've vetted
 // this works well.
+//
+// TODO(ajwong): Make this check for Release() as well.
+// See http://crbug.com/82038.
 template <typename T>
 class SupportsAddRefAndRelease {
   typedef char Yes[1];
   typedef char No[2];
 
   struct BaseMixin {
     void AddRef();
-    void Release();
   };
 
 // MSVC warns when you try to use Base if T has a private destructor, the
 // common pattern for refcounted types. It does this even though no attempt to
 // instantiate Base is made.  We disable the warning for this definition.
 #if defined(OS_WIN)
 #pragma warning(disable:4624)
 #endif
   struct Base : public T, public BaseMixin {
   };
 #if defined(OS_WIN)
 #pragma warning(default:4624)
 #endif
 
   template <void(BaseMixin::*)(void)> struct Helper {};
 
   template <typename C>
-  static No& Check(Helper<&C::AddRef>*, Helper<&C::Release>*);
+  static No& Check(Helper<&C::AddRef>*);
 
   template <typename >
   static Yes& Check(...);
 
  public:
-  static const bool value = sizeof(Check<Base>(0,0)) == sizeof(Yes);
+  static const bool value = sizeof(Check<Base>(0)) == sizeof(Yes);
 };
 
 
 // Helpers to assert that arguments of a recounted type are bound with a
 // scoped_refptr.
 template <bool IsClasstype, typename T>
 struct UnsafeBindtoRefCountedArgHelper : false_type {
 };
 
 template <typename T>
@@ skipping 86 matching lines @@
 }
 
 template <typename T>
 inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
   return internal::ConstRefWrapper<T>(o);
 }
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_