PairingAuthenticator implementation and plumbing.

remoting/host/remoting_me2me_host.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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 49 matching lines @@
 #include "remoting/host/network_settings.h"
 #include "remoting/host/policy_hack/policy_watcher.h"
 #include "remoting/host/service_urls.h"
 #include "remoting/host/session_manager_factory.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/host/token_validator_factory_impl.h"
 #include "remoting/host/ui_strings.h"
 #include "remoting/host/usage_stats_consent.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/me2me_host_authenticator_factory.h"
+#include "remoting/protocol/pairing_registry.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #include "base/file_descriptor_posix.h"
 #include "remoting/host/pam_authorization_factory_posix.h"
 #include "remoting/host/posix/signal_handler.h"
 #endif  // defined(OS_POSIX)
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_cftyperef.h"
@@ skipping 378 matching lines @@
     return;
 
   std::string local_certificate = key_pair_->GenerateCertificate();
   if (local_certificate.empty()) {
     LOG(ERROR) << "Failed to generate host certificate.";
     ShutdownHost(kInitializationFailed);
     return;
   }
   scoped_ptr<protocol::AuthenticatorFactory> factory;
 
+  // TODO(jamiewalch): Add a proper pairing registry here once all the code
+  // is committed.
+  scoped_refptr<remoting::protocol::PairingRegistry> pairing_registry;

[rmsousa, 2013/05/15 01:25:16]

Nit: Please either pass NULL explicitly (and move the comment down), or create
an actual (possibly dummy) instance. Passing an implicitly null pointer is a bit
harder to read.

(Note, not necessarily related to this CL: while looking at whether it was
possible to create a dummy instance, I noticed that
NotImplementedPairingRegistryDelegate is a bit too literal :) - please take the
opportunity to either remove the declaration or add a definition for ::Save). 

[Jamie, 2013/05/15 23:41:08]

It says quite clearly that it's not implemented. What more do you want? ;)

I've actually already fixed this in https://codereview.chromium.org/14995019/.
Regarding passing NULL, the reason I'm doing that for now is that I don't want
the UI to present the option of pairing until it's fully implemented. The
simplest way of doing that is by not creating the registry. It will also make it
easy to support a policy to disable pairing. Creating a dummy implementation
doesn't really make sense because it's not an interface. Even if I made it into
an interface, it would still need something along the lines of an IsImplemented
method in order to prevent pairing from being offered. This seems like overkill
to me.

I've added a comment to NegotiatingHostAuthenticator::CreateWithSharedSecret to
explain.

[rmsousa, 2013/05/16 00:46:25]

I see, I agree passing NULL is the right move in this case. But since that's the
case, [nit:] I think actually passing NULL in the parameter list makes the
intention more readable.

[Jamie, 2013/05/16 19:30:16]

The reason I made it separate is that the pairing registry is just one of many
parameters, so a comment above the CreateWithSharedSecret wouldn't be as clear.
If you still think I should change it, I don't mind, but I think this approach
is clearer.

[rmsousa, 2013/05/16 20:11:02]

I see what you mean, good point.

+
   if (token_url_.is_empty() && token_validation_url_.is_empty()) {
     factory = protocol::Me2MeHostAuthenticatorFactory::CreateWithSharedSecret(
-        local_certificate, key_pair_, host_secret_hash_);
+        local_certificate, key_pair_, host_secret_hash_, pairing_registry);
   } else if (token_url_.is_valid() && token_validation_url_.is_valid()) {
     scoped_ptr<protocol::ThirdPartyHostAuthenticator::TokenValidatorFactory>
         token_validator_factory(new TokenValidatorFactoryImpl(
             token_url_, token_validation_url_, key_pair_,
             context_->url_request_context_getter()));
     factory = protocol::Me2MeHostAuthenticatorFactory::CreateWithThirdPartyAuth(
         local_certificate, key_pair_, token_validator_factory.Pass());
   } else {
     // TODO(rmsousa): If the policy is bad the host should not go online. It
     // should keep running, but not connected, until the policies are fixed.
@@ skipping 600 matching lines @@
   return exit_code;
 }
 
 }  // namespace remoting
 
 #if !defined(OS_WIN)
 int main(int argc, char** argv) {
   return remoting::HostMain(argc, argv);
 }
 #endif  // !defined(OS_WIN)