ipc: hide IsRecoverableError() function behind unnamed namespace

ipc/unix_domain_socket_util.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 <errno.h>
 #include <sys/socket.h>
-#include <sys/stat.h>
 #include <sys/un.h>
 #include <unistd.h>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "build/build_config.h"
 
@@ skipping 40 matching lines @@
 
   // Create unix_addr structure.
   memset(unix_addr, 0, sizeof(struct sockaddr_un));
   unix_addr->sun_family = AF_UNIX;
   strncpy(unix_addr->sun_path, socket_name.c_str(), kMaxSocketNameLength);
   *unix_addr_len =
       offsetof(struct sockaddr_un, sun_path) + socket_name.length();
   return fd.release();
 }
 
+bool IsRecoverableError() {
+  return errno == ECONNABORTED || errno == EMFILE || errno == ENFILE ||
+         errno == ENOMEM || errno == ENOBUFS;
+}
+
 }  // namespace
 
 bool CreateServerUnixDomainSocket(const base::FilePath& socket_path,
                                   int* server_listen_fd) {
   DCHECK(server_listen_fd);
 
   std::string socket_name = socket_path.value();
   base::FilePath socket_dir = socket_path.DirName();
 
   struct sockaddr_un unix_addr;
@@ skipping 85 matching lines @@
   uid_t peer_euid;
   if (!GetPeerEuid(peer_fd, &peer_euid))
     return false;
   if (peer_euid != geteuid()) {
     DLOG(ERROR) << "Client euid is not authorised";
     return false;
   }
   return true;
 }
 
-bool IsRecoverableError(int err) {
-  return errno == ECONNABORTED || errno == EMFILE || errno == ENFILE ||
-         errno == ENOMEM || errno == ENOBUFS;
-}
-
 bool ServerAcceptConnection(int server_listen_fd, int* server_socket) {
   DCHECK(server_socket);
   *server_socket = -1;
 
   base::ScopedFD accept_fd(HANDLE_EINTR(accept(server_listen_fd, NULL, 0)));
   if (!accept_fd.is_valid())
-    return IsRecoverableError(errno);
+    return IsRecoverableError();
   if (!base::SetNonBlocking(accept_fd.get())) {
     PLOG(ERROR) << "base::SetNonBlocking() failed " << accept_fd.get();
     // It's safe to keep listening on |server_listen_fd| even if the attempt to
     // set O_NONBLOCK failed on the client fd.
     return true;
   }
 
   *server_socket = accept_fd.release();
   return true;
 }
 
 }  // namespace IPC