Remove ipc/unix_domain_socket_util.*

components/arc/arc_session.cc

 // Copyright 2015 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 "components/arc/arc_session.h"
 
 #include <fcntl.h>
 #include <grp.h>
 #include <poll.h>
 #include <unistd.h>
@@ skipping 10 matching lines @@
 #include "base/task_runner_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "components/arc/arc_bridge_host_impl.h"
 #include "components/arc/arc_features.h"
 #include "components/user_manager/user_manager.h"
-#include "ipc/unix_domain_socket_util.h"
 #include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/named_platform_handle.h"
+#include "mojo/edk/embedder/named_platform_handle_utils.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/platform_channel_utils_posix.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
 namespace arc {
 
 namespace {
 
@@ skipping 160 matching lines @@
   ~ArcSessionImpl() override;
 
   // ArcSession overrides:
   void Start() override;
   void Stop() override;
   void OnShutdown() override;
 
  private:
   // Creates the UNIX socket on a worker pool and then processes its file
   // descriptor.
-  static base::ScopedFD CreateSocket();
-  void OnSocketCreated(base::ScopedFD fd);
+  static mojo::edk::ScopedPlatformHandle CreateSocket();
+  void OnSocketCreated(mojo::edk::ScopedPlatformHandle fd);
 
   // DBus callback for StartArcInstance().
-  void OnInstanceStarted(base::ScopedFD socket_fd,
+  void OnInstanceStarted(mojo::edk::ScopedPlatformHandle socket_fd,
                          StartArcInstanceResult result);
 
   // Synchronously accepts a connection on |socket_fd| and then processes the
   // connected socket's file descriptor.
-  static base::ScopedFD ConnectMojo(base::ScopedFD socket_fd,
-                                    base::ScopedFD cancel_fd);
-  void OnMojoConnected(base::ScopedFD fd);
+  static mojo::edk::ScopedPlatformHandle ConnectMojo(
+      mojo::edk::ScopedPlatformHandle socket_fd,
+      base::ScopedFD cancel_fd);
+  void OnMojoConnected(mojo::edk::ScopedPlatformHandle fd);
 
   // Request to stop ARC instance via DBus.
   void StopArcInstance();
 
   // chromeos::SessionManagerClient::Observer:
   void ArcInstanceStopped(bool clean) override;
 
   // Completes the termination procedure.
   void OnStopped(ArcBridgeService::StopReason reason);
 
@@ skipping 49 matching lines @@
   VLOG(2) << "Creating socket...";
 
   state_ = State::CREATING_SOCKET;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(), FROM_HERE,
       base::Bind(&ArcSessionImpl::CreateSocket),
       base::Bind(&ArcSessionImpl::OnSocketCreated, weak_factory_.GetWeakPtr()));
 }
 
 // static
-base::ScopedFD ArcSessionImpl::CreateSocket() {
+mojo::edk::ScopedPlatformHandle ArcSessionImpl::CreateSocket() {
   base::FilePath socket_path(kArcBridgeSocketPath);
 
-  int raw_fd = -1;
-  if (!IPC::CreateServerUnixDomainSocket(socket_path, &raw_fd))
-    return base::ScopedFD();
-  base::ScopedFD socket_fd(raw_fd);
+  mojo::edk::ScopedPlatformHandle socket_fd = mojo::edk::CreateServerHandle(
+      mojo::edk::NamedPlatformHandle(socket_path.value()));
+  if (!socket_fd.is_valid())
+    return socket_fd;
 
   // Change permissions on the socket.
   struct group arc_bridge_group;
   struct group* arc_bridge_group_res = nullptr;
   char buf[10000];
   if (HANDLE_EINTR(getgrnam_r(kArcBridgeSocketGroup, &arc_bridge_group, buf,
                               sizeof(buf), &arc_bridge_group_res)) < 0) {
     PLOG(ERROR) << "getgrnam_r";
-    return base::ScopedFD();
+    return mojo::edk::ScopedPlatformHandle();
   }
 
   if (!arc_bridge_group_res) {
     LOG(ERROR) << "Group '" << kArcBridgeSocketGroup << "' not found";
-    return base::ScopedFD();
+    return mojo::edk::ScopedPlatformHandle();
   }
 
   if (HANDLE_EINTR(chown(kArcBridgeSocketPath, -1, arc_bridge_group.gr_gid)) <
       0) {
     PLOG(ERROR) << "chown";
-    return base::ScopedFD();
+    return mojo::edk::ScopedPlatformHandle();
   }
 
   if (!base::SetPosixFilePermissions(socket_path, 0660)) {
     PLOG(ERROR) << "Could not set permissions: " << socket_path.value();
-    return base::ScopedFD();
+    return mojo::edk::ScopedPlatformHandle();
   }
 
   return socket_fd;
 }
 
-void ArcSessionImpl::OnSocketCreated(base::ScopedFD socket_fd) {
+void ArcSessionImpl::OnSocketCreated(
+    mojo::edk::ScopedPlatformHandle socket_fd) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, State::CREATING_SOCKET);
 
   if (stop_requested_) {
     VLOG(1) << "Stop() called while connecting";
     OnStopped(ArcBridgeService::StopReason::SHUTDOWN);
     return;
   }
 
   if (!socket_fd.is_valid()) {
@@ skipping 13 matching lines @@
       !base::FeatureList::IsEnabled(arc::kBootCompletedBroadcastFeature);
 
   chromeos::SessionManagerClient* session_manager_client =
       chromeos::DBusThreadManager::Get()->GetSessionManagerClient();
   session_manager_client->StartArcInstance(
       cryptohome_id, disable_boot_completed_broadcast,
       base::Bind(&ArcSessionImpl::OnInstanceStarted, weak_factory_.GetWeakPtr(),
                  base::Passed(&socket_fd)));
 }
 
-void ArcSessionImpl::OnInstanceStarted(base::ScopedFD socket_fd,
-                                       StartArcInstanceResult result) {
+void ArcSessionImpl::OnInstanceStarted(
+    mojo::edk::ScopedPlatformHandle socket_fd,
+    StartArcInstanceResult result) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ == State::STOPPED) {
     // This is the case that error is notified via DBus before the
     // OnInstanceStarted() callback is invoked. The stopping procedure has
     // been run, so do nothing.
     return;
   }
 
   DCHECK_EQ(state_, State::STARTING_INSTANCE);
 
@@ skipping 27 matching lines @@
   }
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(), FROM_HERE,
       base::Bind(&ArcSessionImpl::ConnectMojo, base::Passed(&socket_fd),
                  base::Passed(&cancel_fd)),
       base::Bind(&ArcSessionImpl::OnMojoConnected, weak_factory_.GetWeakPtr()));
 }
 
 // static
-base::ScopedFD ArcSessionImpl::ConnectMojo(base::ScopedFD socket_fd,
-                                           base::ScopedFD cancel_fd) {
-  if (!WaitForSocketReadable(socket_fd.get(), cancel_fd.get())) {
+mojo::edk::ScopedPlatformHandle ArcSessionImpl::ConnectMojo(
+    mojo::edk::ScopedPlatformHandle socket_fd,
+    base::ScopedFD cancel_fd) {
+  if (!WaitForSocketReadable(socket_fd.get().handle, cancel_fd.get())) {
     VLOG(1) << "Mojo connection was cancelled.";
-    return base::ScopedFD();
+    return mojo::edk::ScopedPlatformHandle();
   }
 
-  int raw_fd = -1;
-  if (!IPC::ServerOnConnect(socket_fd.get(), &raw_fd)) {
-    return base::ScopedFD();
+  mojo::edk::ScopedPlatformHandle scoped_fd;
+  if (!mojo::edk::ServerAcceptConnection(socket_fd.get(), &scoped_fd,
+                                         /* check_peer_user = */ false) ||
+      !scoped_fd.is_valid()) {
+    return mojo::edk::ScopedPlatformHandle();
   }
-  base::ScopedFD scoped_fd(raw_fd);
 
   // Hardcode pid 0 since it is unused in mojo.
   const base::ProcessHandle kUnusedChildProcessHandle = 0;
   mojo::edk::PlatformChannelPair channel_pair;
   mojo::edk::ChildProcessLaunched(kUnusedChildProcessHandle,
                                   channel_pair.PassServerHandle(),
                                   mojo::edk::GenerateRandomToken());
 
   mojo::edk::ScopedPlatformHandleVectorPtr handles(
       new mojo::edk::PlatformHandleVector{
           channel_pair.PassClientHandle().release()});
 
   struct iovec iov = {const_cast<char*>(""), 1};
   ssize_t result = mojo::edk::PlatformChannelSendmsgWithHandles(
-      mojo::edk::PlatformHandle(scoped_fd.get()), &iov, 1, handles->data(),
-      handles->size());
+      scoped_fd.get(), &iov, 1, handles->data(), handles->size());
   if (result == -1) {
     PLOG(ERROR) << "sendmsg";
-    return base::ScopedFD();
+    return mojo::edk::ScopedPlatformHandle();
   }
 
   return scoped_fd;
 }
 
-void ArcSessionImpl::OnMojoConnected(base::ScopedFD fd) {
+void ArcSessionImpl::OnMojoConnected(mojo::edk::ScopedPlatformHandle fd) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ == State::STOPPED) {
     // This is the case that error is notified via DBus before the
     // OnMojoConnected() callback is invoked. The stopping procedure has
     // been run, so do nothing.
     return;
   }
 
   DCHECK_EQ(state_, State::CONNECTING_MOJO);
   accept_cancel_pipe_.reset();
 
   if (stop_requested_) {
     StopArcInstance();
     return;
   }
 
   if (!fd.is_valid()) {
     LOG(ERROR) << "Invalid handle";
     StopArcInstance();
     return;
   }
 
-  mojo::ScopedMessagePipeHandle server_pipe = mojo::edk::CreateMessagePipe(
-      mojo::edk::ScopedPlatformHandle(mojo::edk::PlatformHandle(fd.release())));
+  mojo::ScopedMessagePipeHandle server_pipe =
+      mojo::edk::CreateMessagePipe(std::move(fd));
   if (!server_pipe.is_valid()) {
     LOG(ERROR) << "Invalid pipe";
     StopArcInstance();
     return;
   }
 
   mojom::ArcBridgeInstancePtr instance;
   instance.Bind(mojo::InterfacePtrInfo<mojom::ArcBridgeInstance>(
       std::move(server_pipe), 0u));
   arc_bridge_host_.reset(new ArcBridgeHostImpl(std::move(instance)));
@@ skipping 140 matching lines @@
   observer_list_.RemoveObserver(observer);
 }
 
 // static
 std::unique_ptr<ArcSession> ArcSession::Create(
     const scoped_refptr<base::TaskRunner>& blocking_task_runner) {
   return base::MakeUnique<ArcSessionImpl>(blocking_task_runner);
 }
 
 }  // namespace arc