Add reminders that these classes have constexpr default constructors.

include/private/SkOnce.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkOnce_DEFINED
 #define SkOnce_DEFINED
 
 #include <atomic>
 #include <utility>
 #include "SkTypes.h"
 
 // SkOnce provides call-once guarantees for Skia, much like std::once_flag/std::call_once().
 //
 // There should be no particularly error-prone gotcha use cases when using SkOnce.
 // It works correctly as a class member, a local, a global, a function-scoped static, whatever.
 
 class SkOnce {
 public:
+    constexpr SkOnce() = default;
+
     template <typename Fn, typename... Args>
     void operator()(Fn&& fn, Args&&... args) {
         auto state = fState.load(std::memory_order_acquire);
 
         if (state == Done) {
             return;
         }
 
         if (state == NotStarted) {
             // Try to claim the job of calling fn() by swapping from NotStarted to Calling.
@@ skipping 29 matching lines @@
  *
  * But if that compare_exchange_strong() fails and we find ourselves in the Done state,
  * we've never done an acquire load to sync up to the store of that Done state.
  *
  * So on failure we need an acquire load.  Generally the failure memory order cannot be
  * stronger than the success memory order, so we need acquire on success too.  The single
  * memory order version of compare_exchange_strong() uses the same acquire order for both.
  */
 
 #endif  // SkOnce_DEFINED