Remove base/sync_socket* Change-Id: I0cca2cba1fd51a0d5ca5eb90cf4c01d32f7b6338 Reviewed-on: https://gn-review.googlesource.com/1520 Reviewed-by: Brett Wilson <brettw@chromium.org> Commit-Queue: Scott Graham <scottmg@chromium.org>
diff --git a/base/sync_socket.h b/base/sync_socket.h deleted file mode 100644 index 9d582da..0000000 --- a/base/sync_socket.h +++ /dev/null
@@ -1,161 +0,0 @@ -// 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. - -#ifndef BASE_SYNC_SOCKET_H_ -#define BASE_SYNC_SOCKET_H_ - -// A socket abstraction used for sending and receiving plain -// data. Because the receiving is blocking, they can be used to perform -// rudimentary cross-process synchronization with low latency. - -#include <stddef.h> - -#include "base/base_export.h" -#include "base/compiler_specific.h" -#include "base/macros.h" -#include "base/process/process_handle.h" -#include "base/synchronization/waitable_event.h" -#include "base/time/time.h" -#include "build_config.h" - -#if defined(OS_WIN) -#include <windows.h> -#endif -#include <sys/types.h> - -#if defined(OS_POSIX) || defined(OS_FUCHSIA) -#include "base/file_descriptor_posix.h" -#endif - -namespace base { - -class BASE_EXPORT SyncSocket { - public: -#if defined(OS_WIN) - typedef HANDLE Handle; - typedef Handle TransitDescriptor; -#elif defined(OS_POSIX) || defined(OS_FUCHSIA) - typedef int Handle; - typedef FileDescriptor TransitDescriptor; -#endif - static const Handle kInvalidHandle; - - SyncSocket(); - - // Creates a SyncSocket from a Handle. Used in transport. - explicit SyncSocket(Handle handle) : handle_(handle) {} - virtual ~SyncSocket(); - - // Initializes and connects a pair of sockets. - // |socket_a| and |socket_b| must not hold a valid handle. Upon successful - // return, the sockets will both be valid and connected. - static bool CreatePair(SyncSocket* socket_a, SyncSocket* socket_b); - - // Returns |Handle| wrapped in a |TransitDescriptor|. - static Handle UnwrapHandle(const TransitDescriptor& descriptor); - - // Prepares a |TransitDescriptor| which wraps |Handle| used for transit. - // This is used to prepare the underlying shared resource before passing back - // the handle to be used by the peer process. - bool PrepareTransitDescriptor(ProcessHandle peer_process_handle, - TransitDescriptor* descriptor); - - // Closes the SyncSocket. Returns true on success, false on failure. - virtual bool Close(); - - // Sends the message to the remote peer of the SyncSocket. - // Note it is not safe to send messages from the same socket handle by - // multiple threads simultaneously. - // buffer is a pointer to the data to send. - // length is the length of the data to send (must be non-zero). - // Returns the number of bytes sent, or 0 upon failure. - virtual size_t Send(const void* buffer, size_t length); - - // Receives a message from an SyncSocket. - // buffer is a pointer to the buffer to receive data. - // length is the number of bytes of data to receive (must be non-zero). - // Returns the number of bytes received, or 0 upon failure. - virtual size_t Receive(void* buffer, size_t length); - - // Same as Receive() but only blocks for data until |timeout| has elapsed or - // |buffer| |length| is exhausted. Currently only timeouts less than one - // second are allowed. Return the amount of data read. - virtual size_t ReceiveWithTimeout(void* buffer, - size_t length, - TimeDelta timeout); - - // Returns the number of bytes available. If non-zero, Receive() will not - // not block when called. - virtual size_t Peek(); - - // Extracts the contained handle. Used for transferring between - // processes. - Handle handle() const { return handle_; } - - // Extracts and takes ownership of the contained handle. - Handle Release(); - - protected: - Handle handle_; - - private: - DISALLOW_COPY_AND_ASSIGN(SyncSocket); -}; - -// Derives from SyncSocket and adds support for shutting down the socket from -// another thread while a blocking Receive or Send is being done from the -// thread that owns the socket. -class BASE_EXPORT CancelableSyncSocket : public SyncSocket { - public: - CancelableSyncSocket(); - explicit CancelableSyncSocket(Handle handle); - ~CancelableSyncSocket() override = default; - - // Initializes a pair of cancelable sockets. See documentation for - // SyncSocket::CreatePair for more details. - static bool CreatePair(CancelableSyncSocket* socket_a, - CancelableSyncSocket* socket_b); - - // A way to shut down a socket even if another thread is currently performing - // a blocking Receive or Send. - bool Shutdown(); - -#if defined(OS_WIN) - // Since the Linux and Mac implementations actually use a socket, shutting - // them down from another thread is pretty simple - we can just call - // shutdown(). However, the Windows implementation relies on named pipes - // and there isn't a way to cancel a blocking synchronous Read that is - // supported on <Vista. So, for Windows only, we override these - // SyncSocket methods in order to support shutting down the 'socket'. - bool Close() override; - size_t Receive(void* buffer, size_t length) override; - size_t ReceiveWithTimeout(void* buffer, - size_t length, - TimeDelta timeout) override; -#endif - - // Send() is overridden to catch cases where the remote end is not responding - // and we fill the local socket buffer. When the buffer is full, this - // implementation of Send() will not block indefinitely as - // SyncSocket::Send will, but instead return 0, as no bytes could be sent. - // Note that the socket will not be closed in this case. - size_t Send(const void* buffer, size_t length) override; - - private: -#if defined(OS_WIN) - WaitableEvent shutdown_event_; - WaitableEvent file_operation_; -#endif - DISALLOW_COPY_AND_ASSIGN(CancelableSyncSocket); -}; - -#if defined(OS_WIN) && !defined(COMPONENT_BUILD) -// TODO(cpu): remove this once chrome is split in two dlls. -__declspec(selectany) - const SyncSocket::Handle SyncSocket::kInvalidHandle = INVALID_HANDLE_VALUE; -#endif - -} // namespace base - -#endif // BASE_SYNC_SOCKET_H_
diff --git a/base/sync_socket_nacl.cc b/base/sync_socket_nacl.cc deleted file mode 100644 index 19a20be..0000000 --- a/base/sync_socket_nacl.cc +++ /dev/null
@@ -1,105 +0,0 @@ -// 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 "base/sync_socket.h" - -#include <errno.h> -#include <limits.h> -#include <stddef.h> -#include <stdio.h> -#include <sys/types.h> - -#include "base/logging.h" - -namespace base { - -const SyncSocket::Handle SyncSocket::kInvalidHandle = -1; - -SyncSocket::SyncSocket() : handle_(kInvalidHandle) { -} - -SyncSocket::~SyncSocket() { - Close(); -} - -// static -bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) { - return false; -} - -// static -SyncSocket::Handle SyncSocket::UnwrapHandle( - const SyncSocket::TransitDescriptor& descriptor) { - // TODO(xians): Still unclear how NaCl uses SyncSocket. - // See http://crbug.com/409656 - NOTIMPLEMENTED(); - return SyncSocket::kInvalidHandle; -} - -bool SyncSocket::PrepareTransitDescriptor( - ProcessHandle peer_process_handle, - SyncSocket::TransitDescriptor* descriptor) { - // TODO(xians): Still unclear how NaCl uses SyncSocket. - // See http://crbug.com/409656 - NOTIMPLEMENTED(); - return false; -} - -bool SyncSocket::Close() { - if (handle_ != kInvalidHandle) { - if (close(handle_) < 0) - DPLOG(ERROR) << "close"; - handle_ = kInvalidHandle; - } - return true; -} - -size_t SyncSocket::Send(const void* buffer, size_t length) { - const ssize_t bytes_written = write(handle_, buffer, length); - return bytes_written > 0 ? bytes_written : 0; -} - -size_t SyncSocket::Receive(void* buffer, size_t length) { - const ssize_t bytes_read = read(handle_, buffer, length); - return bytes_read > 0 ? bytes_read : 0; -} - -size_t SyncSocket::ReceiveWithTimeout(void* buffer, size_t length, TimeDelta) { - NOTIMPLEMENTED(); - return 0; -} - -size_t SyncSocket::Peek() { - NOTIMPLEMENTED(); - return 0; -} - -SyncSocket::Handle SyncSocket::Release() { - Handle r = handle_; - handle_ = kInvalidHandle; - return r; -} - -CancelableSyncSocket::CancelableSyncSocket() { -} - -CancelableSyncSocket::CancelableSyncSocket(Handle handle) - : SyncSocket(handle) { -} - -size_t CancelableSyncSocket::Send(const void* buffer, size_t length) { - return SyncSocket::Send(buffer, length); -} - -bool CancelableSyncSocket::Shutdown() { - return SyncSocket::Close(); -} - -// static -bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a, - CancelableSyncSocket* socket_b) { - return SyncSocket::CreatePair(socket_a, socket_b); -} - -} // namespace base
diff --git a/base/sync_socket_posix.cc b/base/sync_socket_posix.cc deleted file mode 100644 index 816bb73..0000000 --- a/base/sync_socket_posix.cc +++ /dev/null
@@ -1,253 +0,0 @@ -// 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 "base/sync_socket.h" - -#include <errno.h> -#include <fcntl.h> -#include <limits.h> -#include <poll.h> -#include <stddef.h> -#include <stdio.h> -#include <sys/ioctl.h> -#include <sys/socket.h> -#include <sys/types.h> - -#if defined(OS_SOLARIS) -#include <sys/filio.h> -#endif - -#include "base/files/file_util.h" -#include "base/logging.h" -#include "base/threading/thread_restrictions.h" -#include "build_config.h" - -namespace base { - -namespace { -// To avoid users sending negative message lengths to Send/Receive -// we clamp message lengths, which are size_t, to no more than INT_MAX. -const size_t kMaxMessageLength = static_cast<size_t>(INT_MAX); - -// Writes |length| of |buffer| into |handle|. Returns the number of bytes -// written or zero on error. |length| must be greater than 0. -size_t SendHelper(SyncSocket::Handle handle, - const void* buffer, - size_t length) { - DCHECK_GT(length, 0u); - DCHECK_LE(length, kMaxMessageLength); - DCHECK_NE(handle, SyncSocket::kInvalidHandle); - const char* charbuffer = static_cast<const char*>(buffer); - return WriteFileDescriptor(handle, charbuffer, length) - ? static_cast<size_t>(length) - : 0; -} - -bool CloseHandle(SyncSocket::Handle handle) { - if (handle != SyncSocket::kInvalidHandle && close(handle) < 0) { - DPLOG(ERROR) << "close"; - return false; - } - - return true; -} - -} // namespace - -const SyncSocket::Handle SyncSocket::kInvalidHandle = -1; - -SyncSocket::SyncSocket() : handle_(kInvalidHandle) {} - -SyncSocket::~SyncSocket() { - Close(); -} - -// static -bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) { - DCHECK_NE(socket_a, socket_b); - DCHECK_EQ(socket_a->handle_, kInvalidHandle); - DCHECK_EQ(socket_b->handle_, kInvalidHandle); - -#if defined(OS_MACOSX) - int nosigpipe = 1; -#endif // defined(OS_MACOSX) - - Handle handles[2] = { kInvalidHandle, kInvalidHandle }; - if (socketpair(AF_UNIX, SOCK_STREAM, 0, handles) != 0) { - CloseHandle(handles[0]); - CloseHandle(handles[1]); - return false; - } - -#if defined(OS_MACOSX) - // On OSX an attempt to read or write to a closed socket may generate a - // SIGPIPE rather than returning -1. setsockopt will shut this off. - if (0 != setsockopt(handles[0], SOL_SOCKET, SO_NOSIGPIPE, - &nosigpipe, sizeof nosigpipe) || - 0 != setsockopt(handles[1], SOL_SOCKET, SO_NOSIGPIPE, - &nosigpipe, sizeof nosigpipe)) { - CloseHandle(handles[0]); - CloseHandle(handles[1]); - return false; - } -#endif - - // Copy the handles out for successful return. - socket_a->handle_ = handles[0]; - socket_b->handle_ = handles[1]; - - return true; -} - -// static -SyncSocket::Handle SyncSocket::UnwrapHandle( - const TransitDescriptor& descriptor) { - return descriptor.fd; -} - -bool SyncSocket::PrepareTransitDescriptor(ProcessHandle peer_process_handle, - TransitDescriptor* descriptor) { - descriptor->fd = handle(); - descriptor->auto_close = false; - return descriptor->fd != kInvalidHandle; -} - -bool SyncSocket::Close() { - const bool retval = CloseHandle(handle_); - handle_ = kInvalidHandle; - return retval; -} - -size_t SyncSocket::Send(const void* buffer, size_t length) { - AssertBlockingAllowed(); - return SendHelper(handle_, buffer, length); -} - -size_t SyncSocket::Receive(void* buffer, size_t length) { - AssertBlockingAllowed(); - DCHECK_GT(length, 0u); - DCHECK_LE(length, kMaxMessageLength); - DCHECK_NE(handle_, kInvalidHandle); - char* charbuffer = static_cast<char*>(buffer); - if (ReadFromFD(handle_, charbuffer, length)) - return length; - return 0; -} - -size_t SyncSocket::ReceiveWithTimeout(void* buffer, - size_t length, - TimeDelta timeout) { - AssertBlockingAllowed(); - DCHECK_GT(length, 0u); - DCHECK_LE(length, kMaxMessageLength); - DCHECK_NE(handle_, kInvalidHandle); - - // Only timeouts greater than zero and less than one second are allowed. - DCHECK_GT(timeout.InMicroseconds(), 0); - DCHECK_LT(timeout.InMicroseconds(), - TimeDelta::FromSeconds(1).InMicroseconds()); - - // Track the start time so we can reduce the timeout as data is read. - TimeTicks start_time = TimeTicks::Now(); - const TimeTicks finish_time = start_time + timeout; - - struct pollfd pollfd; - pollfd.fd = handle_; - pollfd.events = POLLIN; - pollfd.revents = 0; - - size_t bytes_read_total = 0; - while (bytes_read_total < length) { - const TimeDelta this_timeout = finish_time - TimeTicks::Now(); - const int timeout_ms = - static_cast<int>(this_timeout.InMillisecondsRoundedUp()); - if (timeout_ms <= 0) - break; - const int poll_result = poll(&pollfd, 1, timeout_ms); - // Handle EINTR manually since we need to update the timeout value. - if (poll_result == -1 && errno == EINTR) - continue; - // Return if other type of error or a timeout. - if (poll_result <= 0) - return bytes_read_total; - - // poll() only tells us that data is ready for reading, not how much. We - // must Peek() for the amount ready for reading to avoid blocking. - // At hang up (POLLHUP), the write end has been closed and there might still - // be data to be read. - // No special handling is needed for error (POLLERR); we can let any of the - // following operations fail and handle it there. - DCHECK(pollfd.revents & (POLLIN | POLLHUP | POLLERR)) << pollfd.revents; - const size_t bytes_to_read = std::min(Peek(), length - bytes_read_total); - - // There may be zero bytes to read if the socket at the other end closed. - if (!bytes_to_read) - return bytes_read_total; - - const size_t bytes_received = - Receive(static_cast<char*>(buffer) + bytes_read_total, bytes_to_read); - bytes_read_total += bytes_received; - if (bytes_received != bytes_to_read) - return bytes_read_total; - } - - return bytes_read_total; -} - -size_t SyncSocket::Peek() { - DCHECK_NE(handle_, kInvalidHandle); - int number_chars = 0; - if (ioctl(handle_, FIONREAD, &number_chars) == -1) { - // If there is an error in ioctl, signal that the channel would block. - return 0; - } - DCHECK_GE(number_chars, 0); - return number_chars; -} - -SyncSocket::Handle SyncSocket::Release() { - Handle r = handle_; - handle_ = kInvalidHandle; - return r; -} - -CancelableSyncSocket::CancelableSyncSocket() = default; -CancelableSyncSocket::CancelableSyncSocket(Handle handle) - : SyncSocket(handle) { -} - -bool CancelableSyncSocket::Shutdown() { - DCHECK_NE(handle_, kInvalidHandle); - return HANDLE_EINTR(shutdown(handle_, SHUT_RDWR)) >= 0; -} - -size_t CancelableSyncSocket::Send(const void* buffer, size_t length) { - DCHECK_GT(length, 0u); - DCHECK_LE(length, kMaxMessageLength); - DCHECK_NE(handle_, kInvalidHandle); - - const int flags = fcntl(handle_, F_GETFL); - if (flags != -1 && (flags & O_NONBLOCK) == 0) { - // Set the socket to non-blocking mode for sending if its original mode - // is blocking. - fcntl(handle_, F_SETFL, flags | O_NONBLOCK); - } - - const size_t len = SendHelper(handle_, buffer, length); - - if (flags != -1 && (flags & O_NONBLOCK) == 0) { - // Restore the original flags. - fcntl(handle_, F_SETFL, flags); - } - - return len; -} - -// static -bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a, - CancelableSyncSocket* socket_b) { - return SyncSocket::CreatePair(socket_a, socket_b); -} - -} // namespace base
diff --git a/base/sync_socket_win.cc b/base/sync_socket_win.cc deleted file mode 100644 index 905d0a2..0000000 --- a/base/sync_socket_win.cc +++ /dev/null
@@ -1,356 +0,0 @@ -// 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 "base/sync_socket.h" - -#include <limits.h> -#include <stddef.h> - -#include "base/logging.h" -#include "base/macros.h" -#include "base/rand_util.h" -#include "base/threading/thread_restrictions.h" -#include "base/win/scoped_handle.h" - -namespace base { - -using win::ScopedHandle; - -namespace { -// IMPORTANT: do not change how this name is generated because it will break -// in sandboxed scenarios as we might have by-name policies that allow pipe -// creation. Also keep the secure random number generation. -const wchar_t kPipeNameFormat[] = L"\\\\.\\pipe\\chrome.sync.%u.%u.%lu"; -const size_t kPipePathMax = arraysize(kPipeNameFormat) + (3 * 10) + 1; - -// To avoid users sending negative message lengths to Send/Receive -// we clamp message lengths, which are size_t, to no more than INT_MAX. -const size_t kMaxMessageLength = static_cast<size_t>(INT_MAX); - -const int kOutBufferSize = 4096; -const int kInBufferSize = 4096; -const int kDefaultTimeoutMilliSeconds = 1000; - -bool CreatePairImpl(HANDLE* socket_a, HANDLE* socket_b, bool overlapped) { - DCHECK_NE(socket_a, socket_b); - DCHECK_EQ(*socket_a, SyncSocket::kInvalidHandle); - DCHECK_EQ(*socket_b, SyncSocket::kInvalidHandle); - - wchar_t name[kPipePathMax]; - ScopedHandle handle_a; - DWORD flags = PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE; - if (overlapped) - flags |= FILE_FLAG_OVERLAPPED; - - do { - unsigned long rnd_name; - RandBytes(&rnd_name, sizeof(rnd_name)); - - swprintf(name, kPipePathMax, - kPipeNameFormat, - GetCurrentProcessId(), - GetCurrentThreadId(), - rnd_name); - - handle_a.Set(CreateNamedPipeW( - name, - flags, - PIPE_TYPE_BYTE | PIPE_READMODE_BYTE, - 1, - kOutBufferSize, - kInBufferSize, - kDefaultTimeoutMilliSeconds, - NULL)); - } while (!handle_a.IsValid() && - (GetLastError() == ERROR_PIPE_BUSY)); - - if (!handle_a.IsValid()) { - NOTREACHED(); - return false; - } - - // The SECURITY_ANONYMOUS flag means that the server side (handle_a) cannot - // impersonate the client (handle_b). This allows us not to care which side - // ends up in which side of a privilege boundary. - flags = SECURITY_SQOS_PRESENT | SECURITY_ANONYMOUS; - if (overlapped) - flags |= FILE_FLAG_OVERLAPPED; - - ScopedHandle handle_b(CreateFileW(name, - GENERIC_READ | GENERIC_WRITE, - 0, // no sharing. - NULL, // default security attributes. - OPEN_EXISTING, // opens existing pipe. - flags, - NULL)); // no template file. - if (!handle_b.IsValid()) { - DPLOG(ERROR) << "CreateFileW failed"; - return false; - } - - if (!ConnectNamedPipe(handle_a.Get(), NULL)) { - DWORD error = GetLastError(); - if (error != ERROR_PIPE_CONNECTED) { - DPLOG(ERROR) << "ConnectNamedPipe failed"; - return false; - } - } - - *socket_a = handle_a.Take(); - *socket_b = handle_b.Take(); - - return true; -} - -// Inline helper to avoid having the cast everywhere. -DWORD GetNextChunkSize(size_t current_pos, size_t max_size) { - // The following statement is for 64 bit portability. - return static_cast<DWORD>(((max_size - current_pos) <= UINT_MAX) ? - (max_size - current_pos) : UINT_MAX); -} - -// Template function that supports calling ReadFile or WriteFile in an -// overlapped fashion and waits for IO completion. The function also waits -// on an event that can be used to cancel the operation. If the operation -// is cancelled, the function returns and closes the relevant socket object. -template <typename BufferType, typename Function> -size_t CancelableFileOperation(Function operation, - HANDLE file, - BufferType* buffer, - size_t length, - WaitableEvent* io_event, - WaitableEvent* cancel_event, - CancelableSyncSocket* socket, - DWORD timeout_in_ms) { - AssertBlockingAllowed(); - // The buffer must be byte size or the length check won't make much sense. - static_assert(sizeof(buffer[0]) == sizeof(char), "incorrect buffer type"); - DCHECK_GT(length, 0u); - DCHECK_LE(length, kMaxMessageLength); - DCHECK_NE(file, SyncSocket::kInvalidHandle); - - // Track the finish time so we can calculate the timeout as data is read. - TimeTicks current_time, finish_time; - if (timeout_in_ms != INFINITE) { - current_time = TimeTicks::Now(); - finish_time = - current_time + base::TimeDelta::FromMilliseconds(timeout_in_ms); - } - - size_t count = 0; - do { - // The OVERLAPPED structure will be modified by ReadFile or WriteFile. - OVERLAPPED ol = { 0 }; - ol.hEvent = io_event->handle(); - - const DWORD chunk = GetNextChunkSize(count, length); - // This is either the ReadFile or WriteFile call depending on whether - // we're receiving or sending data. - DWORD len = 0; - const BOOL operation_ok = operation( - file, static_cast<BufferType*>(buffer) + count, chunk, &len, &ol); - if (!operation_ok) { - if (::GetLastError() == ERROR_IO_PENDING) { - HANDLE events[] = { io_event->handle(), cancel_event->handle() }; - const int wait_result = WaitForMultipleObjects( - arraysize(events), events, FALSE, - timeout_in_ms == INFINITE ? - timeout_in_ms : - static_cast<DWORD>( - (finish_time - current_time).InMilliseconds())); - if (wait_result != WAIT_OBJECT_0 + 0) { - // CancelIo() doesn't synchronously cancel outstanding IO, only marks - // outstanding IO for cancellation. We must call GetOverlappedResult() - // below to ensure in flight writes complete before returning. - CancelIo(file); - } - - // We set the |bWait| parameter to TRUE for GetOverlappedResult() to - // ensure writes are complete before returning. - if (!GetOverlappedResult(file, &ol, &len, TRUE)) - len = 0; - - if (wait_result == WAIT_OBJECT_0 + 1) { - DVLOG(1) << "Shutdown was signaled. Closing socket."; - socket->Close(); - return count; - } - - // Timeouts will be handled by the while() condition below since - // GetOverlappedResult() may complete successfully after CancelIo(). - DCHECK(wait_result == WAIT_OBJECT_0 + 0 || wait_result == WAIT_TIMEOUT); - } else { - break; - } - } - - count += len; - - // Quit the operation if we can't write/read anymore. - if (len != chunk) - break; - - // Since TimeTicks::Now() is expensive, only bother updating the time if we - // have more work to do. - if (timeout_in_ms != INFINITE && count < length) - current_time = base::TimeTicks::Now(); - } while (count < length && - (timeout_in_ms == INFINITE || current_time < finish_time)); - - return count; -} - -} // namespace - -#if defined(COMPONENT_BUILD) -const SyncSocket::Handle SyncSocket::kInvalidHandle = INVALID_HANDLE_VALUE; -#endif - -SyncSocket::SyncSocket() : handle_(kInvalidHandle) {} - -SyncSocket::~SyncSocket() { - Close(); -} - -// static -bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) { - return CreatePairImpl(&socket_a->handle_, &socket_b->handle_, false); -} - -// static -SyncSocket::Handle SyncSocket::UnwrapHandle( - const TransitDescriptor& descriptor) { - return descriptor; -} - -bool SyncSocket::PrepareTransitDescriptor(ProcessHandle peer_process_handle, - TransitDescriptor* descriptor) { - DCHECK(descriptor); - if (!::DuplicateHandle(GetCurrentProcess(), handle(), peer_process_handle, - descriptor, 0, FALSE, DUPLICATE_SAME_ACCESS)) { - DPLOG(ERROR) << "Cannot duplicate socket handle for peer process."; - return false; - } - return true; -} - -bool SyncSocket::Close() { - if (handle_ == kInvalidHandle) - return true; - - const BOOL result = CloseHandle(handle_); - handle_ = kInvalidHandle; - return result == TRUE; -} - -size_t SyncSocket::Send(const void* buffer, size_t length) { - AssertBlockingAllowed(); - DCHECK_GT(length, 0u); - DCHECK_LE(length, kMaxMessageLength); - DCHECK_NE(handle_, kInvalidHandle); - size_t count = 0; - while (count < length) { - DWORD len; - DWORD chunk = GetNextChunkSize(count, length); - if (::WriteFile(handle_, static_cast<const char*>(buffer) + count, chunk, - &len, NULL) == FALSE) { - return count; - } - count += len; - } - return count; -} - -size_t SyncSocket::ReceiveWithTimeout(void* buffer, - size_t length, - TimeDelta timeout) { - NOTIMPLEMENTED(); - return 0; -} - -size_t SyncSocket::Receive(void* buffer, size_t length) { - AssertBlockingAllowed(); - DCHECK_GT(length, 0u); - DCHECK_LE(length, kMaxMessageLength); - DCHECK_NE(handle_, kInvalidHandle); - size_t count = 0; - while (count < length) { - DWORD len; - DWORD chunk = GetNextChunkSize(count, length); - if (::ReadFile(handle_, static_cast<char*>(buffer) + count, chunk, &len, - NULL) == FALSE) { - return count; - } - count += len; - } - return count; -} - -size_t SyncSocket::Peek() { - DWORD available = 0; - PeekNamedPipe(handle_, NULL, 0, NULL, &available, NULL); - return available; -} - -SyncSocket::Handle SyncSocket::Release() { - Handle r = handle_; - handle_ = kInvalidHandle; - return r; -} - -CancelableSyncSocket::CancelableSyncSocket() - : shutdown_event_(base::WaitableEvent::ResetPolicy::MANUAL, - base::WaitableEvent::InitialState::NOT_SIGNALED), - file_operation_(base::WaitableEvent::ResetPolicy::MANUAL, - base::WaitableEvent::InitialState::NOT_SIGNALED) {} - -CancelableSyncSocket::CancelableSyncSocket(Handle handle) - : SyncSocket(handle), - shutdown_event_(base::WaitableEvent::ResetPolicy::MANUAL, - base::WaitableEvent::InitialState::NOT_SIGNALED), - file_operation_(base::WaitableEvent::ResetPolicy::MANUAL, - base::WaitableEvent::InitialState::NOT_SIGNALED) {} - -bool CancelableSyncSocket::Shutdown() { - // This doesn't shut down the pipe immediately, but subsequent Receive or Send - // methods will fail straight away. - shutdown_event_.Signal(); - return true; -} - -bool CancelableSyncSocket::Close() { - const bool result = SyncSocket::Close(); - shutdown_event_.Reset(); - return result; -} - -size_t CancelableSyncSocket::Send(const void* buffer, size_t length) { - static const DWORD kWaitTimeOutInMs = 500; - return CancelableFileOperation( - &::WriteFile, handle_, reinterpret_cast<const char*>(buffer), length, - &file_operation_, &shutdown_event_, this, kWaitTimeOutInMs); -} - -size_t CancelableSyncSocket::Receive(void* buffer, size_t length) { - return CancelableFileOperation( - &::ReadFile, handle_, reinterpret_cast<char*>(buffer), length, - &file_operation_, &shutdown_event_, this, INFINITE); -} - -size_t CancelableSyncSocket::ReceiveWithTimeout(void* buffer, - size_t length, - TimeDelta timeout) { - return CancelableFileOperation(&::ReadFile, handle_, - reinterpret_cast<char*>(buffer), length, - &file_operation_, &shutdown_event_, this, - static_cast<DWORD>(timeout.InMilliseconds())); -} - -// static -bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a, - CancelableSyncSocket* socket_b) { - return CreatePairImpl(&socket_a->handle_, &socket_b->handle_, true); -} - -} // namespace base
diff --git a/build/gen.py b/build/gen.py index 9e2ab8f..412fa9e 100755 --- a/build/gen.py +++ b/build/gen.py
@@ -713,7 +713,6 @@ 'base/profiler/win32_stack_frame_unwinder.cc', 'base/rand_util_win.cc', 'base/strings/sys_string_conversions_win.cc', - 'base/sync_socket_win.cc', 'base/synchronization/condition_variable_win.cc', 'base/synchronization/lock_impl_win.cc', 'base/synchronization/waitable_event_watcher_win.cc',