Add operator* and operator safe-bool to sk_sp.

include/core/SkRefCnt.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 SkRefCnt_DEFINED
 #define SkRefCnt_DEFINED
 
@@ skipping 220 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Shared pointer class to wrap classes that support a ref()/unref() interface.
  *
  *  This can be used for classes inheriting from SkRefCnt, but it also works for other
  *  classes that match the interface, but have different internal choices: e.g. the hosted class
  *  may have its ref/unref be thread-safe, but that is not assumed/imposed by sk_sp.
  */
 template <typename T> class sk_sp {
+    using unspecified_bool_type = T* sk_sp::*;

[mtklein, 2016/03/02 20:05:10]

  // safe bool idiom.  obsolete with explicit operator bool

[bungeman-skia, 2016/03/02 20:32:58]

Done.

 public:
     sk_sp() : fPtr(nullptr) {}
     sk_sp(std::nullptr_t) : fPtr(nullptr) {}
 
     /**
      *  Shares the underlying object by calling ref(), so that both the argument and the newly
      *  created sk_sp both have a reference to it.
      */
     sk_sp(const sk_sp<T>& that) : fPtr(SkSafeRef(that.get())) {}
     template <typename U,
@@ skipping 58 matching lines @@
     }
 
     bool operator==(std::nullptr_t) const { return this->get() == nullptr; }
     bool operator!=(std::nullptr_t) const { return this->get() != nullptr; }
 
     template <typename U>
     bool operator==(const sk_sp<U>& that) const { return this->get() == that.get(); }
     template <typename U>
     bool operator!=(const sk_sp<U>& that) const { return this->get() != that.get(); }
 
+    T& operator*() const {
+        SkASSERT(this->get() != nullptr);
+        return *this->get();
+    }
+
     // MSVC 2013 does not work correctly with explicit operator bool.
     // https://chromium-cpp.appspot.com/#core-blacklist
+    // When explicit operator bool can be used, remove operator! and operator unspecified_bool_type.
     //explicit operator bool() const { return this->get() != nullptr; }
-
+    operator unspecified_bool_type() const { return this->get() ? &sk_sp::fPtr : nullptr; }

[mtklein, 2016/03/02 20:05:10]

 ... ? &fPtr : nullptr ...
?

[bungeman-skia, 2016/03/02 20:32:58]

So it turns out the type of '&fPtr' here is 'T*const*' but '&sk_sp::fPtr' is 'T*
sk_sp<T>::*' (which is what we actually want). The difference is that the first
is the address of the fPtr object in memory, the other is a field pointer which
may be used to find the fPtr field of sk_sp<T> objects (note that this means
that all instances of sk_sp<T> for a given T will share the same value with the
same type).

     bool operator!() const { return this->get() == nullptr; }
 
     T* get() const { return fPtr; }
     T* operator->() const { return fPtr; }
 
     /**
      *  Adopt the new bare pointer, and call unref() on any previously held object (if not null).
      *  No call to ref() will be made.
      */
     void reset(T* ptr = nullptr) {
@@ skipping 17 matching lines @@
 private:
     T*  fPtr;
 };
 
 template <typename T, typename... Args>
 sk_sp<T> sk_make_sp(Args&&... args) {
     return sk_sp<T>(new T(std::forward<Args>(args)...));
 }
 
 #endif