TpmManagerClient support OwnershipTakenSignal.

BUG=b:172748724
TEST=chromeos_unittests.
TEST=deploy a test-only function in DBusHelper, make sure the signal
arrives with CL:2563522.

Cq-Depend: chromium:2563522
Change-Id: I3fb14ff069cd710a9df496df7a293cc73466cec0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2563430
Commit-Queue: Leo Lai <cylai@google.com>
Reviewed-by: Ryo Hashimoto <hashimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#832327}

chromeos/dbus/tpm_manager/fake_tpm_manager_client.cc

@@ -66,6 +66,14 @@ void FakeTpmManagerClient::ClearStoredOwnerPassword(
                     ::tpm_manager::ClearStoredOwnerPasswordReply());
 }
 
+void FakeTpmManagerClient::AddObserver(Observer* observer) {
+  NOTIMPLEMENTED();
+}
+
+void FakeTpmManagerClient::RemoveObserver(Observer* observer) {
+  NOTIMPLEMENTED();
+}
+
 TpmManagerClient::TestInterface* FakeTpmManagerClient::GetTestInterface() {
   return this;
 }

chromeos/dbus/tpm_manager/fake_tpm_manager_client.h

@@ -39,6 +39,8 @@ class COMPONENT_EXPORT(CHROMEOS_DBUS_TPM_MANAGER) FakeTpmManagerClient
   void ClearStoredOwnerPassword(
       const ::tpm_manager::ClearStoredOwnerPasswordRequest& request,
       ClearStoredOwnerPasswordCallback callback) override;
+  void AddObserver(Observer* observer) override;
+  void RemoveObserver(Observer* observer) override;
 
   TpmManagerClient::TestInterface* GetTestInterface() override;
 

chromeos/dbus/tpm_manager/tpm_manager_client.cc

@@ -14,6 +14,7 @@
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chromeos/dbus/constants/dbus_switches.h"
@@ -51,6 +52,14 @@ bool ParseProto(dbus::Response* response,
   return true;
 }
 
+void OnSignalConnected(const std::string& interface_name,
+                       const std::string& signal_name,
+                       bool success) {
+  DCHECK_EQ(interface_name, ::tpm_manager::kTpmManagerInterface);
+  LOG_IF(DFATAL, !success) << "Failed to connect to D-Bus signal; interface: "
+                           << interface_name << "; signal: " << signal_name;
+}
+
 // "Real" implementation of TpmManagerClient taking to the TpmManager daemon
 // on the Chrome OS side.
 class TpmManagerClientImpl : public TpmManagerClient {
@@ -96,10 +105,18 @@ class TpmManagerClientImpl : public TpmManagerClient {
                     std::move(callback));
   }
 
+  void AddObserver(Observer* observer) override {
+    observer_list_.AddObserver(observer);
+  }
+  void RemoveObserver(Observer* observer) override {
+    observer_list_.RemoveObserver(observer);
+  }
+
   void Init(dbus::Bus* bus) {
     proxy_ = bus->GetObjectProxy(
         ::tpm_manager::kTpmManagerServiceName,
         dbus::ObjectPath(::tpm_manager::kTpmManagerServicePath));
+    ConnectToOwnershipTakenSignal();
   }
 
  private:
@@ -156,9 +173,29 @@ class TpmManagerClientImpl : public TpmManagerClient {
     std::move(callback).Run(reply_proto);
   }
 
+  // Called when receiving ownership taken signal.
+  void OnOwnershipTakenSignal(dbus::Signal*) {
+    for (auto& observer : observer_list_) {
+      observer.OnOwnershipTaken();
+    }
+  }
+
+  // Connects to ownership taken signal.
+  void ConnectToOwnershipTakenSignal() {
+    proxy_->ConnectToSignal(
+        ::tpm_manager::kTpmManagerInterface,
+        ::tpm_manager::kOwnershipTakenSignal,
+        base::BindRepeating(&TpmManagerClientImpl::OnOwnershipTakenSignal,
+                            weak_factory_.GetWeakPtr()),
+        base::BindOnce(&OnSignalConnected));
+  }
+
   // D-Bus proxy for the TpmManager daemon, not owned.
   dbus::ObjectProxy* proxy_ = nullptr;
 
+  // The observer list of ownership taken signal.
+  base::ObserverList<Observer> observer_list_;
+
   base::WeakPtrFactory<TpmManagerClientImpl> weak_factory_{this};
 };
 

chromeos/dbus/tpm_manager/tpm_manager_client.h

@@ -7,6 +7,7 @@
 
 #include "base/callback.h"
 #include "base/component_export.h"
+#include "base/observer_list_types.h"
 #include "chromeos/dbus/tpm_manager/tpm_manager.pb.h"
 
 namespace dbus {
@@ -23,6 +24,13 @@ namespace chromeos {
 // definitions of the D-Bus methods and their arguments.
 class COMPONENT_EXPORT(CHROMEOS_DBUS_TPM_MANAGER) TpmManagerClient {
  public:
+  class Observer : public base::CheckedObserver {
+   public:
+    virtual void OnOwnershipTaken() = 0;
+  };
+
+ public:
+  // Callbacks of the D-Bus methods.
   using GetTpmNonsensitiveStatusCallback = base::OnceCallback<void(
       const ::tpm_manager::GetTpmNonsensitiveStatusReply&)>;
   using GetVersionInfoCallback =
@@ -95,6 +103,11 @@ class COMPONENT_EXPORT(CHROMEOS_DBUS_TPM_MANAGER) TpmManagerClient {
       const ::tpm_manager::ClearStoredOwnerPasswordRequest& request,
       ClearStoredOwnerPasswordCallback callback) = 0;
 
+  // Adds an observer.
+  virtual void AddObserver(Observer* observer) = 0;
+  // Removes an observer.
+  virtual void RemoveObserver(Observer* observer) = 0;
+
   // Returns an interface for testing (fake only), or returns nullptr.
   virtual TestInterface* GetTestInterface() = 0;
 

chromeos/dbus/tpm_manager/tpm_manager_client_unittest.cc

@@ -12,6 +12,7 @@
 #include "dbus/mock_bus.h"
 #include "dbus/mock_object_proxy.h"
 #include "dbus/object_path.h"
+#include "dbus/object_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/tpm_manager/dbus-constants.h"
@@ -19,6 +20,7 @@
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::Return;
+using ::testing::SaveArg;
 
 namespace chromeos {
 
@@ -31,6 +33,19 @@ void RunResponseCallback(dbus::ObjectProxy::ResponseCallback callback,
   std::move(callback).Run(response.get());
 }
 
+// The observer class used for testing to watch the invocation of the signal
+// callbacks.
+class TestObserver : public TpmManagerClient::Observer {
+ public:
+  // TpmManagerClient::Observer.
+  void OnOwnershipTaken() override { ++signal_count_; }
+
+  int signal_count() const { return signal_count_; }
+
+ private:
+  int signal_count_ = 0;
+};
+
 }  // namespace
 
 class TpmManagerClientTest : public testing::Test {
@@ -59,17 +74,33 @@ class TpmManagerClientTest : public testing::Test {
     EXPECT_CALL(*proxy_.get(), DoCallMethod(_, _, _))
         .WillRepeatedly(Invoke(this, &TpmManagerClientTest::OnCallMethod));
 
+    EXPECT_CALL(*proxy_,
+                DoConnectToSignal(::tpm_manager::kTpmManagerInterface,
+                                  ::tpm_manager::kOwnershipTakenSignal, _, _))
+        .WillOnce(SaveArg<2>(&ownership_taken_signal_callback_));
     TpmManagerClient::Initialize(bus_.get());
 
     // Execute callbacks posted by `client_->Init()`.
     base::RunLoop().RunUntilIdle();
 
+    ASSERT_FALSE(ownership_taken_signal_callback_.is_null());
+
     client_ = TpmManagerClient::Get();
   }
 
   void TearDown() override { TpmManagerClient::Shutdown(); }
 
  protected:
+  void EmitOwnershipTakenSignal() {
+    ::tpm_manager::OwnershipTakenSignal ownership_taken_signal;
+    dbus::Signal signal(::tpm_manager::kTpmManagerInterface,
+                        ::tpm_manager::kOwnershipTakenSignal);
+    dbus::MessageWriter(&signal).AppendProtoAsArrayOfBytes(
+        ownership_taken_signal);
+    // Emit signal.
+    ASSERT_FALSE(ownership_taken_signal_callback_.is_null());
+    ownership_taken_signal_callback_.Run(&signal);
+  }
   base::test::SingleThreadTaskEnvironment task_environment_;
 
   // Mock bus and proxy for simulating calls.
@@ -123,6 +154,8 @@ class TpmManagerClientTest : public testing::Test {
         FROM_HERE, base::BindOnce(RunResponseCallback, std::move(*callback),
                                   std::move(response)));
   }
+
+  dbus::ObjectProxy::SignalCallback ownership_taken_signal_callback_;
 };
 
 TEST_F(TpmManagerClientTest, GetTpmNonsensitiveStatus) {
@@ -276,6 +309,21 @@ TEST_F(TpmManagerClientTest, ClearStoredOwnerPassword) {
   EXPECT_EQ(expected_clear_password_reply_.status(), result_reply.status());
 }
 
+TEST_F(TpmManagerClientTest, OnwershipTakenSignal) {
+  TestObserver observer;
+  ASSERT_EQ(observer.signal_count(), 0);
+
+  client_->AddObserver(&observer);
+  EmitOwnershipTakenSignal();
+
+  EXPECT_EQ(observer.signal_count(), 1);
+
+  client_->RemoveObserver(&observer);
+  EmitOwnershipTakenSignal();
+
+  EXPECT_EQ(observer.signal_count(), 1);
+}
+
 TEST_F(TpmManagerClientTest, ClearStoredOwnerPasswordDBusFailure) {
   shall_message_parsing_fail_ = true;
   ::tpm_manager::ClearStoredOwnerPasswordReply result_reply;