Implicit constructors for SkFunction are much more readable.

src/core/SkFunction.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkFunction_DEFINED
 #define SkFunction_DEFINED
 
 // TODO: document
 
 #include "SkTypes.h"
 #include "SkTLogic.h"
 
 template <typename> class SkFunction;
 
 template <typename R, typename... Args>
 class SkFunction<R(Args...)> : SkNoncopyable {
 public:
-    explicit SkFunction(R (*fn)(Args...)) : fVTable(GetFunctionPointerVTable()) {
+    SkFunction(R (*fn)(Args...)) : fVTable(GetFunctionPointerVTable()) {
         // We've been passed a function pointer.  We'll just store it.
         fFunction = reinterpret_cast<void*>(fn);
     }
 
     template <typename Fn>
-    explicit SkFunction(Fn fn, SK_WHEN_C((sizeof(Fn) > sizeof(void*)), void*) = nullptr)
+    SkFunction(Fn fn, SK_WHEN_C((sizeof(Fn) > sizeof(void*)), void*) = nullptr)
             : fVTable(GetOutlineVTable<Fn>()) {
         // We've got a functor larger than a pointer.  We've go to copy it onto the heap.
         fFunction = SkNEW_ARGS(Fn, (Forward(fn)));
     }
 
     template <typename Fn>
-    explicit SkFunction(Fn fn, SK_WHEN_C((sizeof(Fn) <= sizeof(void*)), void*) = nullptr)
+    SkFunction(Fn fn, SK_WHEN_C((sizeof(Fn) <= sizeof(void*)), void*) = nullptr)
             : fVTable(GetInlineVTable<Fn>()) {
         // We've got a functor that fits in a pointer.  We copy it right inline.
         fFunction = NULL;  // Quiets a (spurious) warning that fFunction might be uninitialized.
         SkNEW_PLACEMENT_ARGS(&fFunction, Fn, (Forward(fn)));
     }
 
     ~SkFunction() { fVTable.fCleanUp(fFunction); }
 
     R operator()(Args... args) { return fVTable.fCall(fFunction, Forward(args)...); }
 
@@ skipping 44 matching lines @@
         return vtable;
     }
 
 
     void* fFunction;        // A function pointer, a pointer to a functor, or an inlined functor.
     const VTable& fVTable;  // How to call, delete (and one day copy, move) fFunction.
 };
 
 // TODO:
 //   - is it worth moving fCall out of the VTable into SkFunction itself to avoid the indirection?
-//   - should constructors be implicit?
 //   - make SkFunction copyable
 
 #endif//SkFunction_DEFINED