arc: Notify ARC instance failures via callbacks.

components/arc/arc_bridge_bootstrap.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 <fcntl.h>
 #include <grp.h>
 #include <unistd.h>
 
@@ skipping 55 matching lines @@
   // STOPPED
   //   Start() ->
   // SOCKET_CREATING
   //   CreateSocket() -> OnSocketCreated() ->
   // STARTING
   //   StartArcInstance() -> OnInstanceStarted() ->
   // STARTED
   //   AcceptInstanceConnection() -> OnInstanceConnected() ->
   // READY
   //
-  // When Stop() is called from any state, either because an operation
-  // resulted in an error or because the user is logging out:
+  // When Stop() or AbortBoot() is called from any state, either because an
+  // operation resulted in an error or because the user is logging out:
   //
   // (any)
-  //   Stop() ->
+  //   Stop()/AbortBoot() ->
   // STOPPING
   //   StopInstance() ->
   // STOPPED
   //
   // When the instance crashes while it was ready, it will be stopped:
   //   READY -> STOPPING -> STOPPED
   // and then restarted:
   //   STOPPED -> SOCKET_CREATING -> ... -> READY).
+  //
+  // Note: Order of constants below matters. Please make sure to sort them
+  // in chronological order.
   enum class State {
     // ARC is not currently running.
     STOPPED,
 
     // An UNIX socket is being created.
     SOCKET_CREATING,
 
     // The request to start the instance has been sent.
     STARTING,
 
     // The instance has started. Waiting for it to connect to the IPC bridge.
     STARTED,
 
     // The instance is fully connected.
     READY,
 
     // The request to shut down the instance has been sent.
     STOPPING,
   };
 
   ArcBridgeBootstrapImpl();
   ~ArcBridgeBootstrapImpl() override;
 
   // ArcBridgeBootstrap:
   void Start() override;
   void Stop() override;
 
  private:
+  // Aborts ARC instance boot. This is called from various state-machine
+  // functions when they encounter an error during boot.
+  void AbortBoot(ArcBridgeService::StopReason reason);
+
   // Creates the UNIX socket on the bootstrap thread and then processes its
   // file descriptor.
   static base::ScopedFD CreateSocket();
   void OnSocketCreated(base::ScopedFD fd);
 
   // Synchronously accepts a connection on |socket_fd| and then processes the
   // connected socket's file descriptor.
   static base::ScopedFD AcceptInstanceConnection(base::ScopedFD socket_fd);
   void OnInstanceConnected(base::ScopedFD fd);
 
   void SetState(State state);
 
   // DBus callbacks.
   void OnInstanceStarted(base::ScopedFD socket_fd, bool success);
 
   // chromeos::SessionManagerClient::Observer:
   void ArcInstanceStopped(bool clean) override;
 
   // The state of the bootstrap connection.
   State state_ = State::STOPPED;
 
+  // The reason the ARC instance is stopped.
+  ArcBridgeService::StopReason stop_reason_ =
+      ArcBridgeService::StopReason::SHUTDOWN;
+
   base::ThreadChecker thread_checker_;
 
   // WeakPtrFactory to use callbacks.
   base::WeakPtrFactory<ArcBridgeBootstrapImpl> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ArcBridgeBootstrapImpl);
 };
 
 ArcBridgeBootstrapImpl::ArcBridgeBootstrapImpl()
@@ skipping 13 matching lines @@
   client->RemoveObserver(this);
 }
 
 void ArcBridgeBootstrapImpl::Start() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(delegate_);
   if (state_ != State::STOPPED) {
     VLOG(1) << "Start() called when instance is not stopped";
     return;
   }
+  stop_reason_ = ArcBridgeService::StopReason::SHUTDOWN;
   SetState(State::SOCKET_CREATING);
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(true).get(), FROM_HERE,
       base::Bind(&ArcBridgeBootstrapImpl::CreateSocket),
       base::Bind(&ArcBridgeBootstrapImpl::OnSocketCreated,
                  weak_factory_.GetWeakPtr()));
 }
 
 // static
 base::ScopedFD ArcBridgeBootstrapImpl::CreateSocket() {
@@ skipping 48 matching lines @@
 void ArcBridgeBootstrapImpl::OnSocketCreated(base::ScopedFD socket_fd) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != State::SOCKET_CREATING) {
     VLOG(1) << "Stop() called while connecting";
     return;
   }
   SetState(State::STARTING);
 
   if (!socket_fd.is_valid()) {
     LOG(ERROR) << "ARC: Error creating socket";
-    Stop();
+    AbortBoot(ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE);
     return;
   }
 
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   DCHECK(user_manager->GetPrimaryUser());
   const cryptohome::Identification cryptohome_id(
       user_manager->GetPrimaryUser()->GetAccountId());
 
   chromeos::SessionManagerClient* session_manager_client =
       chromeos::DBusThreadManager::Get()->GetSessionManagerClient();
   session_manager_client->StartArcInstance(
       cryptohome_id,
       base::Bind(&ArcBridgeBootstrapImpl::OnInstanceStarted,
                  weak_factory_.GetWeakPtr(), base::Passed(&socket_fd)));
 }
 
 void ArcBridgeBootstrapImpl::OnInstanceStarted(base::ScopedFD socket_fd,
                                                bool success) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!success) {
     LOG(ERROR) << "Failed to start ARC instance";
     // Roll back the state to SOCKET_CREATING to avoid sending the D-Bus signal
     // to stop the failed instance.
     SetState(State::SOCKET_CREATING);
-    Stop();
+    AbortBoot(ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE);
     return;
   }
   if (state_ != State::STARTING) {
     VLOG(1) << "Stop() called when ARC is not running";
     return;
   }
   SetState(State::STARTED);
 
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(true).get(), FROM_HERE,
@@ skipping 36 matching lines @@
 }
 
 void ArcBridgeBootstrapImpl::OnInstanceConnected(base::ScopedFD fd) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != State::STARTED) {
     VLOG(1) << "Stop() called when ARC is not running";
     return;
   }
   if (!fd.is_valid()) {
     LOG(ERROR) << "Invalid handle";
+    AbortBoot(ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE);
     return;
   }
   mojo::ScopedMessagePipeHandle server_pipe = mojo::edk::CreateMessagePipe(
       mojo::edk::ScopedPlatformHandle(mojo::edk::PlatformHandle(fd.release())));
   if (!server_pipe.is_valid()) {
     LOG(ERROR) << "Invalid pipe";
+    AbortBoot(ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE);
     return;
   }
   SetState(State::READY);
   mojom::ArcBridgeInstancePtr instance;
   instance.Bind(mojo::InterfacePtrInfo<mojom::ArcBridgeInstance>(
       std::move(server_pipe), 0u));
   delegate_->OnConnectionEstablished(std::move(instance));
 }
 
 void ArcBridgeBootstrapImpl::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ == State::STOPPED || state_ == State::STOPPING) {
     VLOG(1) << "Stop() called when ARC is not running";
     return;
   }
-  if (state_ == State::SOCKET_CREATING) {
+  if (state_ < State::STARTING) {
     // This was stopped before the D-Bus command to start the instance. Skip
     // the D-Bus command to stop it.
-    SetState(State::STOPPING);
-    ArcInstanceStopped(true);
+    SetState(State::STOPPED);
     return;
   }
   SetState(State::STOPPING);
   // Notification will arrive through ArcInstanceStopped().
   chromeos::SessionManagerClient* session_manager_client =
       chromeos::DBusThreadManager::Get()->GetSessionManagerClient();
   session_manager_client->StopArcInstance(
       base::Bind(&DoNothingInstanceStopped));
 }
 
+void ArcBridgeBootstrapImpl::AbortBoot(ArcBridgeService::StopReason reason) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(reason != ArcBridgeService::StopReason::SHUTDOWN);
+  // In case of multiple errors, report the first one.
+  if (stop_reason_ == ArcBridgeService::StopReason::SHUTDOWN) {
+    stop_reason_ = reason;
+  }
+  Stop();
+}
+
 void ArcBridgeBootstrapImpl::ArcInstanceStopped(bool clean) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!clean)
+  if (!clean) {
     LOG(ERROR) << "ARC instance crashed";
-  DCHECK(delegate_);
+    // In case of multiple errors, report the first one.
+    if (stop_reason_ == ArcBridgeService::StopReason::SHUTDOWN) {
+      stop_reason_ = ArcBridgeService::StopReason::CRASH;
+    }
+  }
   SetState(State::STOPPED);
-  delegate_->OnStopped();
 }
 
 void ArcBridgeBootstrapImpl::SetState(State state) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // DCHECK on enum classes not supported.
   DCHECK(state_ != state);
   state_ = state;
   VLOG(2) << "State: " << static_cast<uint32_t>(state_);
+  if (state_ == State::STOPPED) {
+    DCHECK(delegate_);
+    delegate_->OnStopped(stop_reason_);
+  }
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<ArcBridgeBootstrap> ArcBridgeBootstrap::Create() {
   return base::WrapUnique(new ArcBridgeBootstrapImpl());
 }
 
 }  // namespace arc