tpm_manager: Implemented server/client logic for a few initial commands.

The first commands supported are GetTpmStatus and TakeOwnership. This CL
implements the relevant server and client boilerplate and logic as well
as adds unit tests for this and current untested code.

This CL only includes mock implementations of the LocalDataStore,
TpmStatus, and TpmInitializer interfaces.

BUG=brillo:1040,brillo:1042
TEST=unit

Change-Id: Ie69d343c21ab8abee84eae5c1f3f08f0c37bbeca
Reviewed-on: https://chromium-review.googlesource.com/288367
Reviewed-by: Utkarsh Sanghi <usanghi@chromium.org>
Commit-Queue: Darren Krahn <dkrahn@chromium.org>
Tested-by: Darren Krahn <dkrahn@chromium.org>

3 files changed, 127 insertions, 0 deletions

diff --git a/client/dbus_proxy.cc b/client/dbus_proxy.cc
index be57336..b5429f2 100644
--- a/client/dbus_proxy.cc
+++ b/client/dbus_proxy.cc
@@ -53,4 +53,21 @@ void DBusProxy::GetTpmStatus(const GetTpmStatusRequest& request,
       request);
 }
 
+void DBusProxy::TakeOwnership(const TakeOwnershipRequest& request,
+                              const TakeOwnershipCallback& callback) {
+  auto on_error = [callback](chromeos::Error* error) {
+    TakeOwnershipReply reply;
+    reply.set_status(STATUS_NOT_AVAILABLE);
+    callback.Run(reply);
+  };
+  chromeos::dbus_utils::CallMethodWithTimeout(
+      kDBusTimeoutMS,
+      object_proxy_,
+      tpm_manager::kTpmManagerInterface,
+      tpm_manager::kTakeOwnership,
+      callback,
+      base::Bind(on_error),
+      request);
+}
+
 }  // namespace tpm_manager
diff --git a/client/dbus_proxy.h b/client/dbus_proxy.h
index 8945d07..b99b735 100644
--- a/client/dbus_proxy.h
+++ b/client/dbus_proxy.h
@@ -31,6 +31,8 @@ class TPM_MANAGER_EXPORT DBusProxy : public TpmManagerInterface {
   bool Initialize() override;
   void GetTpmStatus(const GetTpmStatusRequest& request,
                     const GetTpmStatusCallback& callback) override;
+  void TakeOwnership(const TakeOwnershipRequest& request,
+                     const TakeOwnershipCallback& callback) override;
 
   void set_object_proxy(dbus::ObjectProxy* object_proxy) {
     object_proxy_ = object_proxy;
diff --git a/client/dbus_proxy_test.cc b/client/dbus_proxy_test.cc
new file mode 100644
index 0000000..121896d
--- /dev/null
+++ b/client/dbus_proxy_test.cc
@@ -0,0 +1,108 @@
+// Copyright 2015 The Chromium OS 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 <string>
+
+#include <chromeos/bind_lambda.h>
+#include <dbus/mock_object_proxy.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "tpm_manager/client/dbus_proxy.h"
+
+using testing::_;
+using testing::Invoke;
+using testing::StrictMock;
+using testing::WithArgs;
+
+namespace tpm_manager {
+
+class DBusProxyTest : public testing::Test {
+ public:
+  ~DBusProxyTest() override = default;
+  void SetUp() override {
+    mock_object_proxy_ = new StrictMock<dbus::MockObjectProxy>(
+        nullptr, "", dbus::ObjectPath(""));
+    proxy_.set_object_proxy(mock_object_proxy_.get());
+  }
+ protected:
+  scoped_refptr<StrictMock<dbus::MockObjectProxy>> mock_object_proxy_;
+  DBusProxy proxy_;
+};
+
+TEST_F(DBusProxyTest, GetTpmStatus) {
+  auto fake_dbus_call = [](
+      dbus::MethodCall* method_call,
+      const dbus::MockObjectProxy::ResponseCallback& response_callback) {
+    // Verify request protobuf.
+    dbus::MessageReader reader(method_call);
+    GetTpmStatusRequest request;
+    EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
+    // Create reply protobuf.
+    auto response = dbus::Response::CreateEmpty();
+    dbus::MessageWriter writer(response.get());
+    GetTpmStatusReply reply;
+    reply.set_status(STATUS_NOT_AVAILABLE);
+    reply.set_enabled(true);
+    reply.set_owned(true);
+    reply.mutable_local_data()->set_owned_by_this_install(true);
+    reply.set_dictionary_attack_counter(3);
+    reply.set_dictionary_attack_threshold(4);
+    reply.set_dictionary_attack_lockout_in_effect(true);
+    reply.set_dictionary_attack_lockout_seconds_remaining(5);
+    writer.AppendProtoAsArrayOfBytes(reply);
+    response_callback.Run(response.release());
+  };
+  EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
+      .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
+
+  // Set expectations on the outputs.
+  int callback_count = 0;
+  auto callback = [&callback_count](const GetTpmStatusReply& reply) {
+    callback_count++;
+    EXPECT_EQ(STATUS_NOT_AVAILABLE, reply.status());
+    EXPECT_TRUE(reply.enabled());
+    EXPECT_TRUE(reply.owned());
+    EXPECT_TRUE(reply.local_data().owned_by_this_install());
+    EXPECT_EQ(3, reply.dictionary_attack_counter());
+    EXPECT_EQ(4, reply.dictionary_attack_threshold());
+    EXPECT_TRUE(reply.dictionary_attack_lockout_in_effect());
+    EXPECT_EQ(5, reply.dictionary_attack_lockout_seconds_remaining());
+  };
+  GetTpmStatusRequest request;
+  proxy_.GetTpmStatus(request, base::Bind(callback));
+  EXPECT_EQ(1, callback_count);
+}
+
+TEST_F(DBusProxyTest, TakeOwnership) {
+  auto fake_dbus_call = [](
+      dbus::MethodCall* method_call,
+      const dbus::MockObjectProxy::ResponseCallback& response_callback) {
+    // Verify request protobuf.
+    dbus::MessageReader reader(method_call);
+    TakeOwnershipRequest request;
+    EXPECT_TRUE(reader.PopArrayOfBytesAsProto(&request));
+    // Create reply protobuf.
+    auto response = dbus::Response::CreateEmpty();
+    dbus::MessageWriter writer(response.get());
+    TakeOwnershipReply reply;
+    reply.set_status(STATUS_NOT_AVAILABLE);
+    writer.AppendProtoAsArrayOfBytes(reply);
+    response_callback.Run(response.release());
+  };
+  EXPECT_CALL(*mock_object_proxy_, CallMethodWithErrorCallback(_, _, _, _))
+      .WillOnce(WithArgs<0, 2>(Invoke(fake_dbus_call)));
+
+  // Set expectations on the outputs.
+  int callback_count = 0;
+  auto callback = [&callback_count](const TakeOwnershipReply& reply) {
+    callback_count++;
+    EXPECT_EQ(STATUS_NOT_AVAILABLE, reply.status());
+  };
+  TakeOwnershipRequest request;
+  proxy_.TakeOwnership(request, base::Bind(callback));
+  EXPECT_EQ(1, callback_count);
+}
+
+}  // namespace tpm_manager