Add a SharedMemSynchronizer class.

media/audio/shared_mem_synchronizer.cc

Index: media/audio/shared_mem_synchronizer.cc
diff --git a/media/audio/shared_mem_synchronizer.cc b/media/audio/shared_mem_synchronizer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b65a8e2f6650afa119398c00e2a09448c501eb2f
--- /dev/null
+++ b/media/audio/shared_mem_synchronizer.cc
@@ -0,0 +1,135 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#include "media/audio/shared_mem_synchronizer.h"

[scherkus (not reviewing), 2012/03/08 02:37:08]

blank line above

[tommi (sloooow) - chröme, 2012/03/08 16:10:57]

Done.

+
+#if defined(OS_POSIX)
+#include <errno.h>
+#include <sys/poll.h>
+#endif
+
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+
+#if defined(OS_POSIX)
+#include "base/file_descriptor_posix.h"
+#endif
+
+SharedMemSynchronizer::WaitForMultiple::WaitForMultiple(
+    SharedMemSynchronizer* synchronizers, size_t count)
+    : synchronizers_(synchronizers), count_(count), last_(count - 1) {
+  DCHECK_GT(count, 0U);
+}
+
+int SharedMemSynchronizer::WaitForMultiple::Wait() {
+  int ret = WaitMultiple(synchronizers_, count_, last_);
+  last_ = (ret >= 0) ? static_cast<size_t>(ret) : count_ - 1;
+  return ret;
+}
+
+SharedMemSynchronizer::SharedMemSynchronizer() {

[scherkus (not reviewing), 2012/03/08 02:37:08]

nit: typically collapse these one-liners {}

[tommi (sloooow) - chröme, 2012/03/08 16:10:57]

Done.

+}
+
+#if defined(OS_POSIX)
+
+SharedMemSynchronizer::~SharedMemSynchronizer() {

[scherkus (not reviewing), 2012/03/08 02:37:08]

nit: typically collapse these one-liners {}

[tommi (sloooow) - chröme, 2012/03/08 16:10:57]

Done.

+}
+
+SharedMemSynchronizer::SharedMemSynchronizer(IPCHandle handle_1,
+                                             IPCHandle handle_2)
+    : socket_(handle_1.fd) {
+  DCHECK_NE(handle_1.fd, -1);
+  DCHECK_EQ(handle_2.fd, -1);
+  DCHECK(IsValid());
+}
+
+void SharedMemSynchronizer::Signal() {
+  DCHECK(IsValid());
+  char signal = 1;
+  size_t bytes = socket_.Send(&signal, sizeof(signal));
+  DCHECK_EQ(bytes, 1U) << "errno: " << errno;
+}
+
+void SharedMemSynchronizer::Wait() {
+  DCHECK(IsValid());
+  char signal = 0;
+  size_t bytes = socket_.Receive(&signal, sizeof(signal));
+  DCHECK_EQ(bytes, 1U) << "errno: " << errno;
+  DCHECK_EQ(signal, 1);
+}
+
+bool SharedMemSynchronizer::IsValid() const {
+  return socket_.handle() != SocketClass::kInvalidHandle;
+}
+
+bool SharedMemSynchronizer::ShareToProcess(base::ProcessHandle process,
+                                           IPCHandle* handle_1,
+                                           IPCHandle* handle_2) {
+  DCHECK(IsValid());
+  handle_1->fd = socket_.handle();
+  handle_1->auto_close = false;
+  handle_2->fd = -1;
+  return true;
+}
+
+// static
+bool SharedMemSynchronizer::Create(SharedMemSynchronizer* a,
+                                   SharedMemSynchronizer* b) {
+  DCHECK(!a->IsValid());
+  DCHECK(!b->IsValid());
+
+  bool ok = SocketClass::CreatePair(&a->socket_, &b->socket_);
+
+  DLOG_IF(WARNING, !ok) << "failed to create socket: " << errno;
+  DCHECK(!ok || a->IsValid());
+  DCHECK(!ok || b->IsValid());
+  return ok;
+}
+
+// static
+int SharedMemSynchronizer::WaitMultiple(SharedMemSynchronizer* synchronizers,
+                                        size_t count,
+                                        size_t last_signaled) {
+  DCHECK(last_signaled < count);

[scherkus (not reviewing), 2012/03/08 02:37:08]

DCHECK_LE

[tommi (sloooow) - chröme, 2012/03/08 16:10:57]

changed to DCHECK_LT

+#ifndef NDEBUG

[scherkus (not reviewing), 2012/03/08 02:37:08]

if we added curly braces around that for-loop I'd hope that w/o this a compiler
would be smart enough not to spin for no reason!

[tommi (sloooow) - chröme, 2012/03/08 16:10:57]

Done.  Do we even need the curly braces? (the compiler should be smart enough to
realize that ++i doesn't have any side effect)

+  for (size_t i = 0; i < count; ++i)
+    DCHECK(synchronizers[i].IsValid());
+#endif
+
+  int ret = -1;
+
+  scoped_array<struct pollfd> sockets(new struct pollfd[count]);
+  memset(&sockets[0], 0, count * sizeof(struct pollfd));  // NOLINT

[scherkus (not reviewing), 2012/03/08 02:37:08]

is the NOLINT for sizeof(struct pollfd)?

would sizeof(sockets[0]) work?

[tommi (sloooow) - chröme, 2012/03/08 16:10:57]

Done.

+  size_t index = 0;
+  for (size_t i = last_signaled + 1; i < count; ++i) {

[scherkus (not reviewing), 2012/03/08 02:37:08]

I'd have a smallish comment here describing what's going on (prevent starvation
by constructing |sockets| such that it starts at |(last_signaled + 1) % count|

[tommi (sloooow) - chröme, 2012/03/08 16:10:57]

Done.

+    struct pollfd& fd = sockets[index++];
+    fd.events = POLLIN;
+    fd.fd = synchronizers[i].socket_.handle();
+  }
+
+  for (size_t i = 0; i <= last_signaled; ++i) {
+    struct pollfd& fd = sockets[index++];
+    fd.events = POLLIN;
+    fd.fd = synchronizers[i].socket_.handle();
+  }
+  DCHECK_EQ(index, count);
+
+  int err = poll(&sockets[0], count, -1);
+  if (err != -1) {
+    for (size_t i = 0; i < count; ++i) {
+      if (sockets[i].revents) {
+        ret = (i + last_signaled + 1) % count;
+        DCHECK_EQ(sockets[i].fd, synchronizers[ret].socket_.handle());
+        synchronizers[ret].Wait();
+        break;
+      }
+    }
+  } else {
+    NOTREACHED() << "err: " << errno;

[scherkus (not reviewing), 2012/03/08 02:37:08]

something more descriptive?

[tommi (sloooow) - chröme, 2012/03/08 16:10:57]

Done.

+  }
+
+  DCHECK_NE(ret, -1);
+  return ret;
+}
+
+#endif  // !defined(OS_POSIX)