Export of internal Abseil changes.

--
e09635c907d471ab46e14fb8091988c92cb4e78e by Abseil Team <absl-team@google.com>:

Fix syntax error in documentation '}' -> ')'

PiperOrigin-RevId: 215744854

--
a9e2d036850748137355f4a07083f1052d5c3766 by Abseil Team <absl-team@google.com>:

WrapUnique's comment about avoiding explicit template specification
doesn't make clear what alternative there is when this hurts
readability. Add a comment about the approved alternative.

PiperOrigin-RevId: 215634917

--
596b8ff41ff70b27bff3a2369038c0fe7d13ae85 by Greg Falcon <gfalcon@google.com>:

Allow for a small amount of slop in timeout tests, as not all OSs we support give us the perfect timing behavior we're testing for here.

PiperOrigin-RevId: 215615172
GitOrigin-RevId: e09635c907d471ab46e14fb8091988c92cb4e78e
Change-Id: I30721294bac86510a49bb7f405149fc74c532abb

absl/container/flat_hash_map.h

@@ -88,7 +88,7 @@ struct FlatHashMapPolicy;
 //     {{"a", "huey"}, {"b", "dewey"}, {"c", "louie"}};
 //
 //  // Insert a new element into the flat hash map
-//  ducks.insert({"d", "donald"}};
+//  ducks.insert({"d", "donald"});
 //
 //  // Force a rehash of the flat hash map
 //  ducks.rehash(0);

absl/memory/memory.h

@@ -40,15 +40,29 @@ namespace absl {
 // -----------------------------------------------------------------------------
 //
 // Adopts ownership from a raw pointer and transfers it to the returned
-//  `std::unique_ptr`, whose type is deduced. DO NOT specify the template type T
+// `std::unique_ptr`, whose type is deduced. Because of this deduction, *do not*
-//  when calling WrapUnique.
+// specify the template type `T` when calling `WrapUnique`.
 //
 // Example:
 //   X* NewX(int, int);
 //   auto x = WrapUnique(NewX(1, 2));  // 'x' is std::unique_ptr<X>.
 //
-// `absl::WrapUnique` is useful for capturing the output of a raw pointer
+// The purpose of WrapUnique is to automatically deduce the pointer type. If you
-// factory. However, prefer 'absl::make_unique<T>(args...) over
+// wish to make the type explicit, for readability reasons or because you prefer
+// to use a base-class pointer rather than a derived one, just use
+// `std::unique_ptr` directly.
+//
+// Example:
+//   X* Factory(int, int);
+//   auto x = std::unique_ptr<X>(Factory(1, 2));
+//                  - or -
+//   std::unique_ptr<X> x(Factory(1, 2));
+//
+// This has the added advantage of working whether Factory returns a raw
+// pointer or a `std::unique_ptr`.
+//
+// While `absl::WrapUnique` is useful for capturing the output of a raw
+// pointer factory, prefer 'absl::make_unique<T>(args...)' over
 // 'absl::WrapUnique(new T(args...))'.
 //
 //   auto x = WrapUnique(new X(1, 2));  // works, but nonideal.

absl/synchronization/internal/per_thread_sem_test.cc

@@ -153,12 +153,15 @@ TEST_F(PerThreadSemTest, WithTimeout) {
 
 TEST_F(PerThreadSemTest, Timeouts) {
   absl::Time timeout = absl::Now() + absl::Milliseconds(50);
+  // Allow for a slight early return, to account for quality of implementation
+  // issues on various platforms.
+  const absl::Duration slop = absl::Microseconds(200);
   EXPECT_FALSE(Wait(timeout));
-  EXPECT_LE(timeout, absl::Now());
+  EXPECT_LE(timeout, absl::Now() + slop);
 
   absl::Time negative_timeout = absl::UnixEpoch() - absl::Milliseconds(100);
   EXPECT_FALSE(Wait(negative_timeout));
-  EXPECT_LE(negative_timeout, absl::Now());  // trivially true :)
+  EXPECT_LE(negative_timeout, absl::Now() + slop);  // trivially true :)
 
   Post(GetOrCreateCurrentThreadIdentity());
   // The wait here has an expired timeout, but we have a wake to consume,

absl/synchronization/notification_test.cc

@@ -71,10 +71,13 @@ static void BasicTests(bool notify_before_waiting, Notification* notification) {
       notification->WaitForNotificationWithTimeout(absl::Milliseconds(0)));
   EXPECT_FALSE(notification->WaitForNotificationWithDeadline(absl::Now()));
 
+  const absl::Duration delay = absl::Milliseconds(50);
+  // Allow for a slight early return, to account for quality of implementation
+  // issues on various platforms.
+  const absl::Duration slop = absl::Microseconds(200);
   absl::Time start = absl::Now();
-  EXPECT_FALSE(
+  EXPECT_FALSE(notification->WaitForNotificationWithTimeout(delay));
-      notification->WaitForNotificationWithTimeout(absl::Milliseconds(50)));
+  EXPECT_LE(start + delay, absl::Now() + slop);
-  EXPECT_LE(start + absl::Milliseconds(50), absl::Now());
 
   ThreadSafeCounter ready_counter;
   ThreadSafeCounter done_counter;