Export of internal Abseil changes

--
b548087c24ae7c2c709e8040a118b5e312d18e2e by Derek Mauro <dmauro@google.com>:

Remove the static initialization of global variables used by absl::Mutex
as requested by Chromium

PiperOrigin-RevId: 317676541

--
f198f5da1e966772efa978ba019bd23576899794 by Greg Miller <jgm@google.com>:

fix: work around gcc-4.8 bug in disjunction

See https://godbolt.org/z/i7-AmM for a repro of the bug.

I realize that Abseil no longer supports gcc 4.8 officially
(https://abseil.io/docs/cpp/platforms/platforms), but Cloud C++ still supports
gcc 4.8 officially, and so it would be nice to get this simple fix in.

fixes https://github.com/abseil/abseil-cpp/issues/718

PiperOrigin-RevId: 317484459

--
ed233f646530c6c0948213b643cc6919db1bee90 by Chris Kennelly <ckennelly@google.com>:

Avoid determining the size of the duration unit at runtime.

PiperOrigin-RevId: 317376300

--
73d4011c17fcf747a990176924a7adc69d443533 by Greg Falcon <gfalcon@google.com>:

Change spelling of internal detail from `Invoke`/`InvokeT` to `invoke`/`invoke_result_t`.

This matches the spelling of the C++17 standard library names that perform the same operations.

PiperOrigin-RevId: 317311527
GitOrigin-RevId: b548087c24ae7c2c709e8040a118b5e312d18e2e
Change-Id: I131809ff0b92cfdb0d96dc94e94d9c6f751cb0ac

3 files changed, 11 insertions, 11 deletions

diff --git a/absl/functional/function_ref.h b/absl/functional/function_ref.h
index 370acc55..6e03ac2e 100644
--- a/absl/functional/function_ref.h
+++ b/absl/functional/function_ref.h
@@ -90,7 +90,7 @@ class FunctionRef<R(Args...)> {
   // Used to disable constructors for objects that are not compatible with the
   // signature of this FunctionRef.
   template <typename F,
-            typename FR = absl::base_internal::InvokeT<F, Args&&...>>
+            typename FR = absl::base_internal::invoke_result_t<F, Args&&...>>
   using EnableIfCompatible =
       typename std::enable_if<std::is_void<R>::value ||
                               std::is_convertible<FR, R>::value>::type;
diff --git a/absl/functional/internal/front_binder.h b/absl/functional/internal/front_binder.h
index a4d95da4..45f52de7 100644
--- a/absl/functional/internal/front_binder.h
+++ b/absl/functional/internal/front_binder.h
@@ -33,7 +33,7 @@ namespace functional_internal {
 // Invoke the method, expanding the tuple of bound arguments.
 template <class R, class Tuple, size_t... Idx, class... Args>
 R Apply(Tuple&& bound, absl::index_sequence<Idx...>, Args&&... free) {
-  return base_internal::Invoke(
+  return base_internal::invoke(
       absl::forward<Tuple>(bound).template get<Idx>()...,
       absl::forward<Args>(free)...);
 }
@@ -50,22 +50,22 @@ class FrontBinder {
   constexpr explicit FrontBinder(absl::in_place_t, Ts&&... ts)
       : bound_args_(absl::forward<Ts>(ts)...) {}
 
-  template <class... FreeArgs,
-            class R = base_internal::InvokeT<F&, BoundArgs&..., FreeArgs&&...>>
+  template <class... FreeArgs, class R = base_internal::invoke_result_t<
+                                   F&, BoundArgs&..., FreeArgs&&...>>
   R operator()(FreeArgs&&... free_args) & {
     return functional_internal::Apply<R>(bound_args_, Idx(),
                                          absl::forward<FreeArgs>(free_args)...);
   }
 
   template <class... FreeArgs,
-            class R = base_internal::InvokeT<const F&, const BoundArgs&...,
-                                             FreeArgs&&...>>
+            class R = base_internal::invoke_result_t<
+                const F&, const BoundArgs&..., FreeArgs&&...>>
   R operator()(FreeArgs&&... free_args) const& {
     return functional_internal::Apply<R>(bound_args_, Idx(),
                                          absl::forward<FreeArgs>(free_args)...);
   }
 
-  template <class... FreeArgs, class R = base_internal::InvokeT<
+  template <class... FreeArgs, class R = base_internal::invoke_result_t<
                                    F&&, BoundArgs&&..., FreeArgs&&...>>
   R operator()(FreeArgs&&... free_args) && {
     // This overload is called when *this is an rvalue. If some of the bound
@@ -75,8 +75,8 @@ class FrontBinder {
   }
 
   template <class... FreeArgs,
-            class R = base_internal::InvokeT<const F&&, const BoundArgs&&...,
-                                             FreeArgs&&...>>
+            class R = base_internal::invoke_result_t<
+                const F&&, const BoundArgs&&..., FreeArgs&&...>>
   R operator()(FreeArgs&&... free_args) const&& {
     // This overload is called when *this is an rvalue. If some of the bound
     // arguments are stored by value or rvalue reference, we move them.
diff --git a/absl/functional/internal/function_ref.h b/absl/functional/internal/function_ref.h
index d1575054..b5bb8b43 100644
--- a/absl/functional/internal/function_ref.h
+++ b/absl/functional/internal/function_ref.h
@@ -71,14 +71,14 @@ template <typename Obj, typename R, typename... Args>
 R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   auto o = static_cast<const Obj*>(ptr.obj);
   return static_cast<R>(
-      absl::base_internal::Invoke(*o, std::forward<Args>(args)...));
+      absl::base_internal::invoke(*o, std::forward<Args>(args)...));
 }
 
 template <typename Fun, typename R, typename... Args>
 R InvokeFunction(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   auto f = reinterpret_cast<Fun>(ptr.fun);
   return static_cast<R>(
-      absl::base_internal::Invoke(f, std::forward<Args>(args)...));
+      absl::base_internal::invoke(f, std::forward<Args>(args)...));
 }
 
 template <typename Sig>