Rename ArcBridgeBootstrap to ArcSession.

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_bridge_bootstrap.h"
+#include "components/arc/arc_session.h"
 
 #include <fcntl.h>
 #include <grp.h>
 #include <poll.h>
 #include <unistd.h>
 
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 83 matching lines @@
     VLOG(1) << "Stop() was called during ConnectMojo()";
     return false;
   }
 
   DCHECK(fds[0].revents);
   return true;
 }
 
 // TODO(hidehiko): Refactor more to make this class unittest-able, for at least
 // state-machine part.
-class ArcBridgeBootstrapImpl : public ArcBridgeBootstrap,
-                               public chromeos::SessionManagerClient::Observer {
+class ArcSessionImpl : public ArcSession,
+                       public chromeos::SessionManagerClient::Observer {
  public:
   // The possible states of the bootstrap connection.  In the normal flow,

[Luis Héctor Chávez, 2016/10/18 00:24:57]

nit: s/bootstrap connection/session/?

[hidehiko, 2016/10/18 05:27:45]

Done.

   // the state changes in the following sequence:
   //
   // NOT_STARTED
   //   Start() ->
   // CREATING_SOCKET
   //   CreateSocket() -> OnSocketCreated() ->
   // STARTING_INSTANCE
   //   -> OnInstanceStarted() ->
   // CONNECTING_MOJO
   //   ConnectMojo() -> OnMojoConnected() ->
@@ skipping 69 matching lines @@
     // The instance has started. Waiting for it to connect to the IPC bridge.
     CONNECTING_MOJO,
 
     // The instance is fully set up.
     RUNNING,
 
     // ARC is terminated.
     STOPPED,
   };
 
-  ArcBridgeBootstrapImpl();
-  ~ArcBridgeBootstrapImpl() override;
+  ArcSessionImpl();
+  ~ArcSessionImpl() override;
 
-  // ArcBridgeBootstrap:
+  // ArcSession overrides:
   void Start() override;
   void Stop() override;
 
  private:
-  // Creates the UNIX socket on the bootstrap thread and then processes its
-  // file descriptor.
+  // Creates the UNIX socket on a worker pool and then processes its file
+  // descriptor.
   static base::ScopedFD CreateSocket();
   void OnSocketCreated(base::ScopedFD fd);
 
   // DBus callback for StartArcInstance().
   void OnInstanceStarted(base::ScopedFD 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);
 
   // 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);
 
-  // The state of the bootstrap connection.
+  // The state of the session.
   State state_ = State::NOT_STARTED;
 
   // When Stop() is called, this flag is set.
   bool stop_requested_ = false;
 
   // In CONNECTING_MOJO state, this is set to the write side of the pipe
   // to notify cancelling of the procedure.
   base::ScopedFD accept_cancel_pipe_;
 
   // Mojo endpoint.
   std::unique_ptr<mojom::ArcBridgeHost> arc_bridge_host_;
 
   base::ThreadChecker thread_checker_;
 
   // WeakPtrFactory to use callbacks.
-  base::WeakPtrFactory<ArcBridgeBootstrapImpl> weak_factory_;
+  base::WeakPtrFactory<ArcSessionImpl> weak_factory_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ArcBridgeBootstrapImpl);
+  DISALLOW_COPY_AND_ASSIGN(ArcSessionImpl);
 };
 
-ArcBridgeBootstrapImpl::ArcBridgeBootstrapImpl()
-    : weak_factory_(this) {
+ArcSessionImpl::ArcSessionImpl() : weak_factory_(this) {
   chromeos::SessionManagerClient* client = GetSessionManagerClient();
   if (client == nullptr)
     return;
   client->AddObserver(this);
 }
 
-ArcBridgeBootstrapImpl::~ArcBridgeBootstrapImpl() {
+ArcSessionImpl::~ArcSessionImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(hidehiko): CHECK if |state_| is in NOT_STARTED or STOPPED.
   // Currently, specifically on shutdown, the state_ can be any value.
   chromeos::SessionManagerClient* client = GetSessionManagerClient();
   if (client == nullptr)
     return;
   client->RemoveObserver(this);
 }
 
-void ArcBridgeBootstrapImpl::Start() {
+void ArcSessionImpl::Start() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, State::NOT_STARTED);
   VLOG(2) << "Starting ARC session.";
   VLOG(2) << "Creating socket...";
 
   state_ = State::CREATING_SOCKET;
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(true).get(), FROM_HERE,
-      base::Bind(&ArcBridgeBootstrapImpl::CreateSocket),
-      base::Bind(&ArcBridgeBootstrapImpl::OnSocketCreated,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&ArcSessionImpl::CreateSocket),
+      base::Bind(&ArcSessionImpl::OnSocketCreated, weak_factory_.GetWeakPtr()));
 }
 
 // static
-base::ScopedFD ArcBridgeBootstrapImpl::CreateSocket() {
+base::ScopedFD 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);
 
   // Change permissions on the socket.
   struct group arc_bridge_group;
   struct group* arc_bridge_group_res = nullptr;
@@ skipping 16 matching lines @@
   }
 
   if (!base::SetPosixFilePermissions(socket_path, 0660)) {
     PLOG(ERROR) << "Could not set permissions: " << socket_path.value();
     return base::ScopedFD();
   }
 
   return socket_fd;
 }
 
-void ArcBridgeBootstrapImpl::OnSocketCreated(base::ScopedFD socket_fd) {
+void ArcSessionImpl::OnSocketCreated(base::ScopedFD 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()) {
     LOG(ERROR) << "ARC: Error creating socket";
     OnStopped(ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE);
     return;
   }
 
   VLOG(2) << "Socket is created. Starting ARC instance...";
   state_ = State::STARTING_INSTANCE;
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   DCHECK(user_manager->GetPrimaryUser());
   const cryptohome::Identification cryptohome_id(
       user_manager->GetPrimaryUser()->GetAccountId());
 
   bool disable_boot_completed_broadcast =
       !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(&ArcBridgeBootstrapImpl::OnInstanceStarted,
-                 weak_factory_.GetWeakPtr(), base::Passed(&socket_fd)));
+      cryptohome_id, disable_boot_completed_broadcast,
+      base::Bind(&ArcSessionImpl::OnInstanceStarted, weak_factory_.GetWeakPtr(),
+                 base::Passed(&socket_fd)));
 }
 
-void ArcBridgeBootstrapImpl::OnInstanceStarted(base::ScopedFD socket_fd,
-                                               StartArcInstanceResult result) {
+void ArcSessionImpl::OnInstanceStarted(base::ScopedFD 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 21 matching lines @@
   // Prepare a pipe so that AcceptInstanceConnection can be interrupted on
   // Stop().
   base::ScopedFD cancel_fd;
   if (!CreatePipe(&cancel_fd, &accept_cancel_pipe_)) {
     OnStopped(ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(true).get(), FROM_HERE,
-      base::Bind(&ArcBridgeBootstrapImpl::ConnectMojo, base::Passed(&socket_fd),
+      base::Bind(&ArcSessionImpl::ConnectMojo, base::Passed(&socket_fd),
                  base::Passed(&cancel_fd)),
-      base::Bind(&ArcBridgeBootstrapImpl::OnMojoConnected,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&ArcSessionImpl::OnMojoConnected, weak_factory_.GetWeakPtr()));
 }
 
 // static
-base::ScopedFD ArcBridgeBootstrapImpl::ConnectMojo(base::ScopedFD socket_fd,
-                                                   base::ScopedFD cancel_fd) {
+base::ScopedFD ArcSessionImpl::ConnectMojo(base::ScopedFD socket_fd,
+                                           base::ScopedFD cancel_fd) {
   if (!WaitForSocketReadable(socket_fd.get(), cancel_fd.get())) {
     VLOG(1) << "Mojo connection was cancelled.";
     return base::ScopedFD();
   }
 
   int raw_fd = -1;
   if (!IPC::ServerOnConnect(socket_fd.get(), &raw_fd)) {
     return base::ScopedFD();
   }
   base::ScopedFD scoped_fd(raw_fd);
@@ skipping 14 matching lines @@
       mojo::edk::PlatformHandle(scoped_fd.get()), &iov, 1, handles->data(),
       handles->size());
   if (result == -1) {
     PLOG(ERROR) << "sendmsg";
     return base::ScopedFD();
   }
 
   return scoped_fd;
 }
 
-void ArcBridgeBootstrapImpl::OnMojoConnected(base::ScopedFD fd) {
+void ArcSessionImpl::OnMojoConnected(base::ScopedFD 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);
@@ skipping 22 matching lines @@
   instance.Bind(mojo::InterfacePtrInfo<mojom::ArcBridgeInstance>(
       std::move(server_pipe), 0u));
   arc_bridge_host_.reset(new ArcBridgeHostImpl(std::move(instance)));
 
   VLOG(2) << "Mojo is connected. ARC is running.";
   state_ = State::RUNNING;
   for (auto& observer : observer_list_)
     observer.OnReady();
 }
 
-void ArcBridgeBootstrapImpl::Stop() {
+void ArcSessionImpl::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(2) << "Stopping ARC session is requested.";
 
   // For second time or later, just do nothing.
   // It is already in the stopping phase.
   if (stop_requested_)
     return;
 
   stop_requested_ = true;
   arc_bridge_host_.reset();
@@ skipping 28 matching lines @@
       // Now ARC instance is running. Request to stop it.
       StopArcInstance();
       return;
 
     case State::STOPPED:
       // The instance is already stopped. Do nothing.
       return;
   }
 }
 
-void ArcBridgeBootstrapImpl::StopArcInstance() {
+void ArcSessionImpl::StopArcInstance() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == State::STARTING_INSTANCE ||
          state_ == State::CONNECTING_MOJO || state_ == State::RUNNING);
 
   // Notification will arrive through ArcInstanceStopped().
   VLOG(2) << "Requesting to stop ARC instance";
   chromeos::SessionManagerClient* session_manager_client =
       chromeos::DBusThreadManager::Get()->GetSessionManagerClient();
   session_manager_client->StopArcInstance(
       base::Bind(&DoNothingInstanceStopped));
 }
 
-void ArcBridgeBootstrapImpl::ArcInstanceStopped(bool clean) {
+void ArcSessionImpl::ArcInstanceStopped(bool clean) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "Notified that ARC instance is stopped "
           << (clean ? "cleanly" : "uncleanly");
 
   // In case that crash happens during before the Mojo channel is connected,
   // unlock the WorkerPool thread.
   accept_cancel_pipe_.reset();
 
   ArcBridgeService::StopReason reason;
   if (stop_requested_) {
     // If the ARC instance is stopped after its explicit request,
     // return SHUTDOWN.
     reason = ArcBridgeService::StopReason::SHUTDOWN;
   } else if (clean) {
     // If the ARC instance is stopped, but it is not explicitly requested,
     // then this is triggered by some failure during the starting procedure.
     // Return GENERIC_BOOT_FAILURE for the case.
     reason = ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE;
   } else {
     // Otherwise, this is caused by CRASH occured inside of the ARC instance.
     reason = ArcBridgeService::StopReason::CRASH;
   }
   OnStopped(reason);
 }
 
-void ArcBridgeBootstrapImpl::OnStopped(ArcBridgeService::StopReason reason) {
+void ArcSessionImpl::OnStopped(ArcBridgeService::StopReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // OnStopped() should be called once per instance.
   DCHECK_NE(state_, State::STOPPED);
   VLOG(2) << "ARC session is stopped.";
   arc_bridge_host_.reset();
   state_ = State::STOPPED;
   for (auto& observer : observer_list_)
     observer.OnStopped(reason);
 }
 
 }  // namespace
 
-ArcBridgeBootstrap::ArcBridgeBootstrap() = default;
-ArcBridgeBootstrap::~ArcBridgeBootstrap() = default;
+ArcSession::ArcSession() = default;
+ArcSession::~ArcSession() = default;
 
-void ArcBridgeBootstrap::AddObserver(Observer* observer) {
+void ArcSession::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
-void ArcBridgeBootstrap::RemoveObserver(Observer* observer) {
+void ArcSession::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 // static
-std::unique_ptr<ArcBridgeBootstrap> ArcBridgeBootstrap::Create() {
-  return base::MakeUnique<ArcBridgeBootstrapImpl>();
+std::unique_ptr<ArcSession> ArcSession::Create() {
+  return base::MakeUnique<ArcSessionImpl>();
 }
 
 }  // namespace arc