Remove const folly::Synchronized upgrade lock acquire

Summary: Users acquiring upgrade locks should only be allowed to lock the synchronized object when it is non-const.  Because an upgrade locks are permitted to transition to write locks when mutation is required.  At which point non-const access is often required on the Synchronized object.

Reviewed By: yfeldblum

Differential Revision: D8654360

fbshipit-source-id: c2a6574bd880db0d8e4c90166e288f5b83542ad6

folly/Synchronized.h

@@ -257,9 +257,6 @@ class SynchronizedBase<Subclass, detail::MutexLevel::UPGRADE>
   UpgradeLockedPtr ulock() {
     return UpgradeLockedPtr(static_cast<Subclass*>(this));
   }
-  ConstUpgradeLockedPtr ulock() const {
-    return ConstUpgradeLockedPtr(static_cast<const Subclass*>(this));
-  }
 
   /**
    * Attempts to acquire the lock in upgrade mode.  If acquisition is
@@ -271,9 +268,6 @@ class SynchronizedBase<Subclass, detail::MutexLevel::UPGRADE>
   TryUpgradeLockedPtr tryULock() {
     return TryUpgradeLockedPtr{static_cast<Subclass*>(this)};
   }
-  ConstTryUpgradeLockedPtr tryULock() const {
-    return ConstTryUpgradeLockedPtr{static_cast<const Subclass*>(this)};
-  }
 
   /**
    * Acquire an upgrade lock and return a LockedPtr that can be used to safely
@@ -285,11 +279,6 @@ class SynchronizedBase<Subclass, detail::MutexLevel::UPGRADE>
   UpgradeLockedPtr ulock(const std::chrono::duration<Rep, Period>& timeout) {
     return UpgradeLockedPtr(static_cast<Subclass*>(this), timeout);
   }
-  template <class Rep, class Period>
-  UpgradeLockedPtr ulock(
-      const std::chrono::duration<Rep, Period>& timeout) const {
-    return ConstUpgradeLockedPtr(static_cast<const Subclass*>(this), timeout);
-  }
 
   /**
    * Invoke a function while holding the lock.
@@ -312,7 +301,7 @@ class SynchronizedBase<Subclass, detail::MutexLevel::UPGRADE>
    * moveFromUpgradeToWrite() method)
    */
   template <class Function>
-  auto withULock(Function&& function) const {
+  auto withULock(Function&& function) {
     return function(*ulock());
   }
 
@@ -332,10 +321,6 @@ class SynchronizedBase<Subclass, detail::MutexLevel::UPGRADE>
   auto withULockPtr(Function&& function) {
     return function(ulock());
   }
-  template <class Function>
-  auto withULockPtr(Function&& function) const {
-    return function(ulock());
-  }
 };
 
 /**
@@ -1566,10 +1551,6 @@ auto ulock(Synchronized<D, M>& synchronized, Args&&... args) {
   return detail::ulock(synchronized, std::forward<Args>(args)...);
 }
 template <typename D, typename M, typename... Args>
-auto ulock(const Synchronized<D, M>& synchronized, Args&&... args) {
-  return detail::ulock(synchronized, std::forward<Args>(args)...);
-}
-template <typename D, typename M, typename... Args>
 auto lock(Synchronized<D, M>& synchronized, Args&&... args) {
   return detail::lock(synchronized, std::forward<Args>(args)...);
 }