Show a 'remember me' checkbox in the web-app when connecting to a host that supports pairing.

remoting/protocol/negotiating_authenticator_unittest.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 "base/bind.h"
 #include "net/base/net_errors.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/protocol/authenticator_test_base.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/connection_tester.h"
@@ skipping 51 matching lines @@
         pairing_registry);
 
     std::vector<AuthenticationMethod> methods;
     methods.push_back(AuthenticationMethod::Spake2Pair());
     methods.push_back(AuthenticationMethod::Spake2(
         AuthenticationMethod::HMAC_SHA256));
     if (!client_hmac_only) {
       methods.push_back(AuthenticationMethod::Spake2(
           AuthenticationMethod::NONE));
     }
+    bool pairing_expected = pairing_registry != NULL;
+    FetchSecretCallback fetch_secret_callback = base::Bind(
+        &NegotiatingAuthenticatorTest::FetchSecret,
+        client_interactive_pin, pairing_expected);
     client_as_negotiating_authenticator_ = new NegotiatingClientAuthenticator(
         client_id, client_paired_secret,
-        kTestHostId, base::Bind(&NegotiatingAuthenticatorTest::FetchSecret,
-                                client_interactive_pin),
+        kTestHostId, fetch_secret_callback,
         scoped_ptr<ThirdPartyClientAuthenticator::TokenFetcher>(), methods);
     client_.reset(client_as_negotiating_authenticator_);
   }
 
   scoped_refptr<PairingRegistry> CreatePairingRegistry(
       PairingRegistry::Pairing* pairings, size_t num_pairings) {
     PairingRegistry::PairedClients clients;
     for (size_t i = 0; i < num_pairings; ++i) {
       clients[pairings[i].client_id] = pairings[i];
     }
     scoped_refptr<PairingRegistry> result(
         new PairingRegistry(
             scoped_ptr<PairingRegistry::Delegate>(
                 new NotImplementedPairingRegistryDelegate),
             clients));
     return result;
   }
 
   static void FetchSecret(
       const std::string& client_secret,
+      bool pairing_supported,
+      bool pairing_expected,
       const protocol::SecretFetchedCallback& secret_fetched_callback) {
     secret_fetched_callback.Run(client_secret);
+    ASSERT_EQ(pairing_supported, pairing_expected);
   }
 
   void VerifyRejected(Authenticator::RejectionReason reason) {
     ASSERT_TRUE(client_->state() == Authenticator::REJECTED ||
                 host_->state() == Authenticator::REJECTED);
     if (client_->state() == Authenticator::REJECTED) {
       ASSERT_EQ(client_->rejection_reason(), reason);
     }
     if (host_->state() == Authenticator::REJECTED) {
       ASSERT_EQ(host_->rejection_reason(), reason);
@@ skipping 140 matching lines @@
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecretBad, kTestPinBad, kTestPin,
       AuthenticationMethod::HMAC_SHA256, false,
       CreatePairingRegistry(&pairing, 1)));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
   VerifyRejected(Authenticator::INVALID_CREDENTIALS);
 }
 
 }  // namespace protocol
 }  // namespace remoting