Fix undefined behavior in UnixDomainSocketUtil.Connect test.

ipc/unix_domain_socket_util_unittest.cc

 // Copyright 2013 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 "ipc/unix_domain_socket_util.h"
 
 #include <stddef.h>
 #include <sys/socket.h>
 
 #include <memory>
@@ skipping 13 matching lines @@
 namespace {
 
 class SocketAcceptor : public base::MessageLoopForIO::Watcher {
  public:
   SocketAcceptor(int fd, base::SingleThreadTaskRunner* target_thread)
       : server_fd_(-1),
         target_thread_(target_thread),
         started_watching_event_(
             base::WaitableEvent::ResetPolicy::AUTOMATIC,
             base::WaitableEvent::InitialState::NOT_SIGNALED),
+        stopped_watching_event_(
+            base::WaitableEvent::ResetPolicy::AUTOMATIC,
+            base::WaitableEvent::InitialState::NOT_SIGNALED),
         accepted_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                         base::WaitableEvent::InitialState::NOT_SIGNALED) {
     target_thread->PostTask(FROM_HERE,
         base::Bind(&SocketAcceptor::StartWatching, base::Unretained(this), fd));
   }
 
   ~SocketAcceptor() override {
     Close();
   }
 
   int server_fd() const { return server_fd_; }
 
   void WaitUntilReady() {
     started_watching_event_.Wait();
   }
 
   void WaitForAccept() {
     accepted_event_.Wait();
   }
 
   void Close() {
     if (watcher_.get()) {
       target_thread_->PostTask(FROM_HERE,
           base::Bind(&SocketAcceptor::StopWatching, base::Unretained(this),
-              watcher_.release()));
+                     watcher_.release()));
+      stopped_watching_event_.Wait();
     }
   }
 
  private:
   void StartWatching(int fd) {
     watcher_.reset(new base::MessageLoopForIO::FileDescriptorWatcher);
     base::MessageLoopForIO::current()->WatchFileDescriptor(
         fd, true, base::MessageLoopForIO::WATCH_READ, watcher_.get(), this);
     started_watching_event_.Signal();
   }
   void StopWatching(base::MessageLoopForIO::FileDescriptorWatcher* watcher) {
     watcher->StopWatchingFileDescriptor();
     delete watcher;
+    stopped_watching_event_.Signal();
   }
   void OnFileCanReadWithoutBlocking(int fd) override {
     ASSERT_EQ(-1, server_fd_);
     IPC::ServerOnConnect(fd, &server_fd_);
     watcher_->StopWatchingFileDescriptor();
     accepted_event_.Signal();
   }
   void OnFileCanWriteWithoutBlocking(int fd) override {}
 
   int server_fd_;
   base::SingleThreadTaskRunner* target_thread_;
   std::unique_ptr<base::MessageLoopForIO::FileDescriptorWatcher> watcher_;
   base::WaitableEvent started_watching_event_;
+  base::WaitableEvent stopped_watching_event_;
   base::WaitableEvent accepted_event_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketAcceptor);
 };
 
 const base::FilePath GetChannelDir() {
   base::FilePath tmp_dir;
   PathService::Get(base::DIR_TEMP, &tmp_dir);
   return tmp_dir;
 }
@@ skipping 77 matching lines @@
       HANDLE_EINTR(send(connection.client_fd(), buffer, buf_len, 0));
   ASSERT_EQ(buf_len, sent_bytes);
   char recv_buf[sizeof(buffer)];
   size_t received_bytes =
       HANDLE_EINTR(recv(connection.server_fd(), recv_buf, buf_len, 0));
   ASSERT_EQ(buf_len, received_bytes);
   ASSERT_EQ(0, memcmp(recv_buf, buffer, buf_len));
 }
 
 }  // namespace