Roll src/third_party/cros_system_api/ c6eab9e4d..6139ae009 + API change

chromeos/dbus/biod/biod_client_unittest.cc

 // Copyright 2017 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/biod/biod_client.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
+#include "base/strings/stringprintf.h"
+#include "chromeos/dbus/biod/messages.pb.h"
 #include "chromeos/dbus/biod/test_utils.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_object_proxy.h"
 #include "dbus/object_path.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::Return;
 
 namespace chromeos {
 
 namespace {
 
 // Shorthand for a commonly-used constant.
 const char* kInterface = biod::kBiometricsManagerInterface;
 
 // Value used to intialize dbus::ObjectPath objects in tests to make it easier
 // to determine when empty values have been assigned.
 const char kInvalidTestPath[] = "/invalid/test/path";
 
 // Value used to intialize string objects in tests to make it easier to
 // determine when empty values have been assigned.
 const char kInvalidString[] = "invalidString";
 
-// TODO(xiaoyinh@): Use the constant from service_constants.h
-// crbug.com/713420
-const char kBiometricsManagerPath[] =
-    "/org/chromium/BiometricsDaemon/FpcBiometricsManager";
-
 // Matcher that verifies that a dbus::Message has member |name|.
 MATCHER_P(HasMember, name, "") {
   if (arg->GetMember() != name) {
     *result_listener << "has member " << arg->GetMember();
     return false;
   }
   return true;
 }
 
 // Runs |callback| with |response|. Needed due to ResponseCallback expecting a
 // bare pointer rather than an std::unique_ptr.
 void RunResponseCallback(dbus::ObjectProxy::ResponseCallback callback,
                          std::unique_ptr<dbus::Response> response) {
   callback.Run(response.get());
 }
 
 }  // namespace
 
 class BiodClientTest : public testing::Test {
  public:
   BiodClientTest() {}
   ~BiodClientTest() override {}
 
   void SetUp() override {
     dbus::Bus::Options options;
     options.bus_type = dbus::Bus::SYSTEM;
     bus_ = new dbus::MockBus(options);
 
-    proxy_ =
-        new dbus::MockObjectProxy(bus_.get(), biod::kBiodServiceName,
-                                  dbus::ObjectPath(kBiometricsManagerPath));
+    dbus::ObjectPath fpc_bio_path = dbus::ObjectPath(base::StringPrintf(
+        "%s/%s", biod::kBiodServicePath, biod::kFpcBiometricsManagerName));
+    proxy_ = new dbus::MockObjectProxy(bus_.get(), biod::kBiodServiceName,
+                                       fpc_bio_path);
 
     // |client_|'s Init() method should request a proxy for communicating with
     // biometrics api.
     EXPECT_CALL(*bus_.get(), GetObjectProxy(biod::kBiodServiceName, _))
         .WillRepeatedly(Return(proxy_.get()));
 
     // Save |client_|'s signal callback.
     EXPECT_CALL(*proxy_.get(), ConnectToSignal(kInterface, _, _, _))
         .WillRepeatedly(Invoke(this, &BiodClientTest::ConnectToSignal));
 
@@ skipping 24 matching lines @@
   void EmitSignal(dbus::Signal* signal) {
     const std::string signal_name = signal->GetMember();
     const auto it = signal_callbacks_.find(signal_name);
     ASSERT_TRUE(it != signal_callbacks_.end())
         << "Client didn't register for signal " << signal_name;
     it->second.Run(signal);
   }
 
   // Passes a enroll scan done signal to |client_|.
   void EmitEnrollScanDoneSignal(biod::ScanResult scan_result,
-                                bool enroll_session_complete) {
+                                bool enroll_session_complete,
+                                int percent_complete) {
     dbus::Signal signal(kInterface,
                         biod::kBiometricsManagerEnrollScanDoneSignal);
     dbus::MessageWriter writer(&signal);
-    writer.AppendUint32(static_cast<uint32_t>(scan_result));
-    writer.AppendBool(enroll_session_complete);
+    biod::EnrollScanDone protobuf;
+    protobuf.set_scan_result(scan_result);
+    protobuf.set_done(enroll_session_complete);
+    protobuf.set_percent_complete(percent_complete);
+    writer.AppendProtoAsArrayOfBytes(protobuf);
     EmitSignal(&signal);
   }
 
   // Passes a auth scan done signal to |client_|.
   void EmitAuthScanDoneSignal(biod::ScanResult scan_result,
                               const AuthScanMatches& matches) {
     dbus::Signal signal(kInterface, biod::kBiometricsManagerAuthScanDoneSignal);
     dbus::MessageWriter writer(&signal);
     writer.AppendUint32(static_cast<uint32_t>(scan_result));
 
@@ skipping 260 matching lines @@
 
 // Verify when signals are mocked, an observer will catch the signals as
 // expected.
 TEST_F(BiodClientTest, TestNotifyObservers) {
   test_utils::TestBiodObserver observer;
   client_->AddObserver(&observer);
   EXPECT_TRUE(client_->HasObserver(&observer));
 
   const biod::ScanResult scan_signal = biod::ScanResult::SCAN_RESULT_SUCCESS;
   const bool enroll_session_complete = false;
+  const int percent_complete = 0;
   const AuthScanMatches test_attempt;
   EXPECT_EQ(0, observer.NumEnrollScansReceived());
   EXPECT_EQ(0, observer.NumAuthScansReceived());
   EXPECT_EQ(0, observer.num_failures_received());
 
-  EmitEnrollScanDoneSignal(scan_signal, enroll_session_complete);
+  EmitEnrollScanDoneSignal(scan_signal, enroll_session_complete,
+                           percent_complete);
   EXPECT_EQ(1, observer.NumEnrollScansReceived());
 
   EmitAuthScanDoneSignal(scan_signal, test_attempt);
   EXPECT_EQ(1, observer.NumAuthScansReceived());
 
   EmitScanFailedSignal();
   EXPECT_EQ(1, observer.num_failures_received());
 
   client_->RemoveObserver(&observer);
 
-  EmitEnrollScanDoneSignal(scan_signal, enroll_session_complete);
+  EmitEnrollScanDoneSignal(scan_signal, enroll_session_complete,
+                           percent_complete);
   EmitAuthScanDoneSignal(scan_signal, test_attempt);
   EXPECT_EQ(1, observer.NumEnrollScansReceived());
   EXPECT_EQ(1, observer.NumAuthScansReceived());
   EXPECT_EQ(1, observer.num_failures_received());
 }
 }  // namespace chromeos