Delete the windows specific count_down_latch and use the shared implementation

PiperOrigin-RevId: 398772515

cpp/platform/impl/shared/BUILD

@@ -59,6 +59,24 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "count_down_latch",
+    srcs = ["count_down_latch.cc"],
+    hdrs = ["count_down_latch.h"],
+    compatible_with = ["//buildenv/target:non_prod"],
+    visibility = [
+        "//googlemac/iPhone/Shared/Nearby/Connections:__subpackages__",
+        "//platform/impl:__subpackages__",
+    ],
+    deps = [
+        "//absl/base:core_headers",
+        "//absl/strings",
+        "//absl/synchronization",
+        "//absl/time",
+        "//platform/api:types",
+    ],
+)
+
 cc_test(
     name = "file_test",
     srcs = ["file_test.cc"],

cpp/platform/impl/shared/count_down_latch.cc

@@ -0,0 +1,54 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "platform/impl/shared/count_down_latch.h"
+
+namespace location {
+namespace nearby {
+namespace shared {
+
+// A synchronization aid that allows one or more threads to wait until a set of
+// operations being performed in other threads completes.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CountDownLatch.html
+CountDownLatch::CountDownLatch(int count) : count_(count) {}
+
+ExceptionOr<bool> CountDownLatch::Await(absl::Duration timeout) {
+  absl::MutexLock lock(&mutex_);
+  absl::Time deadline = absl::Now() + timeout;
+  while (count_ > 0) {
+    if (cond_.WaitWithDeadline(&mutex_, deadline)) {
+      return ExceptionOr<bool>(false);
+    }
+  }
+  return ExceptionOr<bool>(true);
+}
+
+Exception CountDownLatch::Await() {
+  absl::MutexLock lock(&mutex_);
+  while (count_ > 0) {
+    cond_.Wait(&mutex_);
+  }
+  return {Exception::kSuccess};
+}
+void CountDownLatch::CountDown() {
+  absl::MutexLock lock(&mutex_);
+  if (count_ > 0 && --count_ == 0) {
+    cond_.SignalAll();
+  }
+}
+
+}  // namespace shared
+}  // namespace nearby
+}  // namespace location

cpp/platform/impl/shared/count_down_latch.h

@@ -0,0 +1,53 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef PLATFORM_IMPL_SHARED_COUNT_DOWN_LATCH_H_
+#define PLATFORM_IMPL_SHARED_COUNT_DOWN_LATCH_H_
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/clock.h"
+#include "platform/api/count_down_latch.h"
+
+namespace location {
+namespace nearby {
+namespace shared {
+
+// A synchronization aid that allows one or more threads to wait until a set of
+// operations being performed in other threads completes.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CountDownLatch.html
+class CountDownLatch final : public api::CountDownLatch {
+ public:
+  explicit CountDownLatch(int count);
+  CountDownLatch(const CountDownLatch&) = delete;
+  CountDownLatch& operator=(const CountDownLatch&) = delete;
+  CountDownLatch(CountDownLatch&&) = delete;
+  CountDownLatch& operator=(CountDownLatch&&) = delete;
+  ExceptionOr<bool> Await(absl::Duration timeout) override;
+  Exception Await() override;
+  void CountDown() override;
+
+ private:
+  absl::Mutex mutex_;   // Mutex to be used with cond_.Wait...() method family.
+  absl::CondVar cond_;  // Condition to synchronize up to N waiting threads.
+  int count_
+      ABSL_GUARDED_BY(mutex_);  // When zero, latch should release all waiters.
+};
+
+}  // namespace shared
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_IMPL_G3_COUNT_DOWN_LATCH_H_