Simplify AuthenticationMethod type and PIN hash handling.

remoting/test/protocol_perftest.cc

 // Copyright 2014 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 <utility>
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 34 matching lines @@
 
 namespace remoting {
 
 using protocol::ChannelConfig;
 
 namespace {
 
 const char kHostJid[] = "host_jid@example.com/host";
 const char kHostOwner[] = "jane.doe@example.com";
 const char kClientJid[] = "jane.doe@example.com/client";
+const char kHostId[] = "ABC123";
+const char kHostPin[] = "123456";
 
 struct NetworkPerformanceParams {
   NetworkPerformanceParams(int bandwidth,
                            int max_buffers,
                            double latency_average_ms,
                            double latency_stddev_ms,
                            double out_of_order_rate)
       : bandwidth(bandwidth),
         max_buffers(max_buffers),
         latency_average(base::TimeDelta::FromMillisecondsD(latency_average_ms)),
@@ skipping 275 matching lines @@
         certs_dir.AppendASCII("unittest.selfsigned.der"), &host_cert));
 
     base::FilePath key_path = certs_dir.AppendASCII("unittest.key.bin");
     std::string key_string;
     ASSERT_TRUE(base::ReadFileToString(key_path, &key_string));
     std::string key_base64;
     base::Base64Encode(key_string, &key_base64);
     scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(key_base64);
     ASSERT_TRUE(key_pair.get());
 
-    protocol::SharedSecretHash host_secret;
-    host_secret.hash_function = protocol::AuthenticationMethod::NONE;
-    host_secret.value = "123456";
+    std::string host_pin_hash = protocol::ApplySharedSecretHashFunction(
+        protocol::HashFunction::HMAC_SHA256, kHostId, kHostPin);
     scoped_ptr<protocol::AuthenticatorFactory> auth_factory =
-        protocol::Me2MeHostAuthenticatorFactory::CreateWithSharedSecret(
-            true, kHostOwner, host_cert, key_pair, "", host_secret, nullptr);
+        protocol::Me2MeHostAuthenticatorFactory::CreateWithPin(
+            true, kHostOwner, host_cert, key_pair, "", host_pin_hash, nullptr);
     host_->SetAuthenticatorFactory(std::move(auth_factory));
 
     host_->AddStatusObserver(this);
     host_->Start(kHostOwner);
 
     message_loop_.PostTask(FROM_HERE,
                            base::Bind(&ProtocolPerfTest::StartClientAfterHost,
                                       base::Unretained(this)));
   }
 
@@ skipping 14 matching lines @@
     port_allocator_factory->socket_factory()->SetLatency(
         GetParam().latency_average, GetParam().latency_stddev);
     port_allocator_factory->socket_factory()->set_out_of_order_rate(
         GetParam().out_of_order_rate);
     scoped_refptr<protocol::TransportContext> transport_context(
         new protocol::TransportContext(
             host_signaling_.get(), std::move(port_allocator_factory), nullptr,
             network_settings, protocol::TransportRole::CLIENT));
 
     std::vector<protocol::AuthenticationMethod> auth_methods;
-    auth_methods.push_back(protocol::AuthenticationMethod::Spake2(
-        protocol::AuthenticationMethod::NONE));
+    auth_methods.push_back(
+        protocol::AuthenticationMethod::SPAKE2_SHARED_SECRET_HMAC);
     scoped_ptr<protocol::Authenticator> client_authenticator(
         new protocol::NegotiatingClientAuthenticator(
             std::string(),  // client_pairing_id
             std::string(),  // client_pairing_secret
-            std::string(),  // authentication_tag
+            kHostId,
             base::Bind(&ProtocolPerfTest::FetchPin, base::Unretained(this)),
             nullptr, auth_methods));
     client_.reset(
         new ChromotingClient(client_context_.get(), this, this, nullptr));
     client_->set_protocol_config(protocol_config_->Clone());
     client_->Start(client_signaling_.get(), std::move(client_authenticator),
                    transport_context, kHostJid, std::string());
   }
 
   void FetchPin(
       bool pairing_supported,
       const protocol::SecretFetchedCallback& secret_fetched_callback) {
-    secret_fetched_callback.Run("123456");
+    secret_fetched_callback.Run(kHostPin);
   }
 
   void MeasureTotalLatency(bool webrtc) {
     scoped_refptr<test::CyclicFrameGenerator> frame_generator =
         test::CyclicFrameGenerator::Create();
     frame_generator->set_draw_barcode(true);
 
     desktop_environment_factory_.set_frame_generator(base::Bind(
         &test::CyclicFrameGenerator::GenerateFrame, frame_generator));
 
@@ skipping 210 matching lines @@
 
 TEST_P(ProtocolPerfTest, TotalLatencyIce) {
   MeasureTotalLatency(false);
 }
 
 TEST_P(ProtocolPerfTest, TotalLatencyWebrtc) {
   MeasureTotalLatency(true);
 }
 
 }  // namespace remoting