Read container_instance_id.

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 201 matching lines @@
   void OnShutdown() override;
 
  private:
   // Creates the UNIX socket on a worker pool and then processes its file
   // descriptor.
   static mojo::edk::ScopedPlatformHandle CreateSocket();
   void OnSocketCreated(mojo::edk::ScopedPlatformHandle fd);
 
   // DBus callback for StartArcInstance().
   void OnInstanceStarted(mojo::edk::ScopedPlatformHandle socket_fd,
-                         StartArcInstanceResult result);
+                         StartArcInstanceResult result,
+                         const std::string& container_instance_id);
 
   // Synchronously accepts a connection on |socket_fd| and then processes the
   // connected socket's file descriptor.
   static mojo::ScopedMessagePipeHandle ConnectMojo(
       mojo::edk::ScopedPlatformHandle socket_fd,
       base::ScopedFD cancel_fd);
   void OnMojoConnected(mojo::ScopedMessagePipeHandle server_pipe);
 
   // Request to stop ARC instance via DBus.
   void StopArcInstance();
 
   // chromeos::SessionManagerClient::Observer:
-  void ArcInstanceStopped(bool clean) override;
+  void ArcInstanceStopped(bool clean,
+                          const std::string& container_instance_id) override;
 
   // Completes the termination procedure.
   void OnStopped(ArcStopReason reason);
 
   // Checks whether a function runs on the thread where the instance is
   // created.
   base::ThreadChecker thread_checker_;
 
   // Owned by ArcServiceManager.
   ArcBridgeService* const arc_bridge_service_;
 
   // Task runner to run a blocking tasks.
   scoped_refptr<base::TaskRunner> blocking_task_runner_;
 
   // The state of the session.
   State state_ = State::NOT_STARTED;
 
   // When Stop() is called, this flag is set.
   bool stop_requested_ = false;
 
+  // Container instance id passed from session_manager.
+  // Should be available only after OnInstanceStarted().
+  std::string container_instance_id_;
+
   // 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_;
 
   // WeakPtrFactory to use callbacks.
   base::WeakPtrFactory<ArcSessionImpl> weak_factory_;
 
@@ skipping 108 matching lines @@
   chromeos::SessionManagerClient* session_manager_client =
       chromeos::DBusThreadManager::Get()->GetSessionManagerClient();
   session_manager_client->StartArcInstance(
       cryptohome_id, disable_boot_completed_broadcast, enable_vendor_privileged,
       base::Bind(&ArcSessionImpl::OnInstanceStarted, weak_factory_.GetWeakPtr(),
                  base::Passed(&socket_fd)));
 }
 
 void ArcSessionImpl::OnInstanceStarted(
     mojo::edk::ScopedPlatformHandle socket_fd,
-    StartArcInstanceResult result) {
+    StartArcInstanceResult result,
+    const std::string& container_instance_id) {
   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);
+  container_instance_id_ = container_instance_id;
 
   if (stop_requested_) {
     if (result == StartArcInstanceResult::SUCCESS) {
       // The ARC instance has started to run. Request to stop.
       StopArcInstance();
       return;
     }
     OnStopped(ArcStopReason::SHUTDOWN);
     return;
   }
@@ skipping 70 matching lines @@
     PLOG(ERROR) << "sendmsg";
     return mojo::ScopedMessagePipeHandle();
   }
 
   return pipe;
 }
 
 void ArcSessionImpl::OnMojoConnected(
     mojo::ScopedMessagePipeHandle server_pipe) {
   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 (!server_pipe.is_valid()) {
     LOG(ERROR) << "Invalid pipe";
@@ skipping 67 matching lines @@
          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 ArcSessionImpl::ArcInstanceStopped(bool clean) {
+void ArcSessionImpl::ArcInstanceStopped(
+    bool clean,
+    const std::string& container_instance_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "Notified that ARC instance is stopped "
           << (clean ? "cleanly" : "uncleanly");
 
+  if (container_instance_id != container_instance_id_) {
+    VLOG(1) << "Container instance id mismatch. Do nothing."
+            << container_instance_id << " vs " << container_instance_id_;
+    return;
+  }
+
+  // Release |container_instance_id_| to avoid duplicate invocation situation.
+  container_instance_id_.clear();
+
   // In case that crash happens during before the Mojo channel is connected,
   // unlock the BlockingPool thread.
   accept_cancel_pipe_.reset();
 
   ArcStopReason reason;
   if (stop_requested_) {
     // If the ARC instance is stopped after its explicit request,
     // return SHUTDOWN.
     reason = ArcStopReason::SHUTDOWN;
   } else if (clean) {
@@ skipping 59 matching lines @@
 
 // static
 std::unique_ptr<ArcSession> ArcSession::Create(
     ArcBridgeService* arc_bridge_service,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner) {
   return base::MakeUnique<ArcSessionImpl>(arc_bridge_service,
                                           blocking_task_runner);
 }
 
 }  // namespace arc