Read container_instance_id.

chromeos/dbus/session_manager_client.cc

 // Copyright (c) 2012 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 "chromeos/dbus/session_manager_client.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 719 matching lines @@
 
   void ScreenIsUnlockedReceived(dbus::Signal* signal) {
     screen_is_locked_ = false;
     for (auto& observer : observers_)
       observer.ScreenIsUnlocked();
   }
 
   void ArcInstanceStoppedReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     bool clean = false;
-    if (!reader.PopBool(&clean)) {
+    std::string container_instance_id;
+    if (!reader.PopBool(&clean) || !reader.PopString(&container_instance_id)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       return;
     }
     for (auto& observer : observers_)
-      observer.ArcInstanceStopped(clean);
+      observer.ArcInstanceStopped(clean, container_instance_id);
   }
 
   // Called when the object is connected to the signal.
   void SignalConnected(const std::string& interface_name,
                        const std::string& signal_name,
                        bool success) {
     LOG_IF(ERROR, !success) << "Failed to connect to " << signal_name;
   }
 
   // Called when kSessionManagerGetServerBackedStateKeys method is complete.
@@ skipping 49 matching lines @@
         arc_start_time = base::TimeTicks::FromInternalValue(ticks);
       } else {
         LOG(ERROR) << "Invalid response: " << response->ToString();
       }
     }
     callback.Run(success, arc_start_time);
   }
 
   void OnStartArcInstanceSucceeded(const StartArcInstanceCallback& callback,
                                    dbus::Response* response) {
+    DCHECK(response);
+    dbus::MessageReader reader(response);
+    std::string container_instance_id;
+    if (!reader.PopString(&container_instance_id)) {
+      LOG(ERROR) << "Invalid response: " << response->ToString();
+      if (!callback.is_null())
+        callback.Run(StartArcInstanceResult::UNKNOWN_ERROR, std::string());
+      return;
+    }
+
     if (!callback.is_null())
-      callback.Run(StartArcInstanceResult::SUCCESS);
+      callback.Run(StartArcInstanceResult::SUCCESS, container_instance_id);
   }
 
   void OnStartArcInstanceFailed(const StartArcInstanceCallback& callback,
                                 dbus::ErrorResponse* response) {
     LOG(ERROR) << "Failed to call StartArcInstance: "
                << (response ? response->ToString() : "(null)");
     if (!callback.is_null()) {
       callback.Run(response && response->GetErrorName() ==
                                    login_manager::dbus_error::kLowFreeDisk
                        ? StartArcInstanceResult::LOW_FREE_DISK_SPACE
-                       : StartArcInstanceResult::UNKNOWN_ERROR);
+                       : StartArcInstanceResult::UNKNOWN_ERROR,
+                   std::string());
     }
   }
 
   dbus::ObjectProxy* session_manager_proxy_ = nullptr;
   std::unique_ptr<BlockingMethodCaller> blocking_method_caller_;
   base::ObserverList<Observer> observers_;
 
   // Most recent screen-lock state received from session_manager.
   bool screen_is_locked_ = false;
 
@@ skipping 191 matching lines @@
   }
 
   void CheckArcAvailability(const ArcCallback& callback) override {
     callback.Run(false);
   }
 
   void StartArcInstance(const cryptohome::Identification& cryptohome_id,
                         bool disable_boot_completed_broadcast,
                         bool enable_vendor_privileged,
                         const StartArcInstanceCallback& callback) override {
-    callback.Run(StartArcInstanceResult::UNKNOWN_ERROR);
+    callback.Run(StartArcInstanceResult::UNKNOWN_ERROR, std::string());
   }
 
   void SetArcCpuRestriction(
       login_manager::ContainerCpuRestrictionState restriction_state,
       const ArcCallback& callback) override {
     callback.Run(false);
   }
 
   void EmitArcBooted(const cryptohome::Identification& cryptohome_id,
                      const ArcCallback& callback) override {
@@ skipping 33 matching lines @@
 
 SessionManagerClient* SessionManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new SessionManagerClientImpl();
   DCHECK_EQ(FAKE_DBUS_CLIENT_IMPLEMENTATION, type);
   return new SessionManagerClientStubImpl();
 }
 
 }  // namespace chromeos