Add a working SkFontMgr_fontconfig.

include/core/SkTemplates.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkTemplates_DEFINED
@@ skipping 59 matching lines @@
     Call a function when this goes out of scope. The template uses two
     parameters, the object, and a function that is to be called in the destructor.
     If detach() is called, the object reference is set to null. If the object
     reference is null when the destructor is called, we do not call the
     function.
 */
 template <typename T, void (*P)(T*)> class SkAutoTCallVProc : SkNoncopyable {
 public:
     SkAutoTCallVProc(T* obj): fObj(obj) {}
     ~SkAutoTCallVProc() { if (fObj) P(fObj); }
+
+    operator T*() const { return fObj; }

[mtklein, 2014/07/22 15:48:42]

Is there any chance, given that we get to start from scratch with this, that we
can get away with returning const pointers from const methods and non-const
pointers from non-const methods?  It can be very confusing (and thread-hostile)
to get a non-const pointer out of a smart pointer member from within a const
method.

[bungeman-skia, 2014/07/22 22:09:57]

Not sure what you mean here. If you create an SkAutoTCallVProc<const SkType,
...> then the pointer you get back here will be const. This const here states
that returning the pointer here does not mutate the SkAutoTCallProc. A const
SkAutoTCallProc just means you can't detach or reset it.

None of the std xxx_ptr types have transitive constness, and the idea seems
confusing (c++ normally separates the constness of the pointer from the
constness of the thing).

+    T& operator*() const { SkASSERT(fObj); return *fObj; }
+    T* operator->() const { SkASSERT(fObj); return fObj; }
+    T** operator&() { return &fObj; }

[mtklein, 2014/07/22 15:48:42]

Can we avoid this one?  Seems really easy to write code that'd swap around
pointers without ever calling P.  operator& is pretty bonkers.

[bungeman-skia, 2014/07/22 22:09:57]

It is, but it makes certain things easier when dealing with the type signatures
in font config. Will work around and remove, since it is a bit iffy.

+
     T* detach() { T* obj = fObj; fObj = NULL; return obj; }
+    void reset(T* obj = NULL) {
+        if (fObj != obj) {
+            if (fObj) {
+                P(fObj);
+            }
+            fObj = obj;
+        }
+    }
 private:
     T* fObj;
 };
 
 /** \class SkAutoTCallIProc
 
 Call a function when this goes out of scope. The template uses two
 parameters, the object, and a function that is to be called in the destructor.
 If detach() is called, the object reference is set to null. If the object
 reference is null when the destructor is called, we do not call the
@@ skipping 379 matching lines @@
     /**
      * Returns void* because this object does not initialize the
      * memory. Use placement new for types that require a cons.
      */
     void* get() { return fStorage.get(); }
 private:
     SkAlignedSStorage<sizeof(T)*N> fStorage;
 };
 
 #endif