Updating It2Me to use the new ValidatingAuthenticator class

remoting/host/it2me/it2me_host.h

 // Copyright 2013 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.
 
 #ifndef REMOTING_HOST_IT2ME_IT2ME_HOST_H_
 #define REMOTING_HOST_IT2ME_IT2ME_HOST_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/host/host_status_observer.h"
 #include "remoting/host/it2me/it2me_confirmation_dialog.h"
 #include "remoting/host/it2me/it2me_confirmation_dialog_proxy.h"
+#include "remoting/protocol/validating_authenticator.h"
 #include "remoting/signaling/xmpp_signal_strategy.h"
 
 namespace base {
 class DictionaryValue;
 }
 
 namespace policy {
 class PolicyService;
 }  // namespace policy
 
@@ skipping 58 matching lines @@
   // remoting::HostStatusObserver implementation.
   void OnAccessDenied(const std::string& jid) override;
   void OnClientConnected(const std::string& jid) override;
   void OnClientDisconnected(const std::string& jid) override;
 
   void SetStateForTesting(It2MeHostState state,
                           const std::string& error_message) {
     SetState(state, error_message);
   }
 
+  // Updates the current policies based on |policies|.  Runs |done_callback| on
+  // the calling thread once the policies have been updated.
+  void SetPolicyForTesting(std::unique_ptr<base::DictionaryValue> policies,
+                           const base::Closure& done_callback);
+
+  // Returns the callback used for validating the connection.  Do not run the
+  // returned callback after this object has been destroyed.
+  const protocol::ValidatingAuthenticator::ValidationCallback&
+  GetValidationCallbackForTesting() {
+    return validation_callback_;
+  }
+
  protected:
   friend class base::RefCountedThreadSafe<It2MeHost>;
 
   ~It2MeHost() override;
 
   ChromotingHostContext* host_context() { return host_context_.get(); }
   scoped_refptr<base::SingleThreadTaskRunner> task_runner() {
     return task_runner_;
   }
   base::WeakPtr<It2MeHost::Observer> observer() { return observer_; }
@@ skipping 29 matching lines @@
   // Called when malformed policies are detected.
   void OnPolicyError();
 
   // Handlers for NAT traversal and domain policies.
   void UpdateNatPolicy(bool nat_traversal_enabled);
   void UpdateHostDomainPolicy(const std::string& host_domain);
   void UpdateClientDomainPolicy(const std::string& client_domain);
 
   void DisconnectOnNetworkThread();
 
+  // Uses details of the connection and current policies to detemine if the
+  // connection should be accepted or rejected.
+  void ValidateConnectionDetails(
+      const std::string& remote_jid,
+      const protocol::ValidatingAuthenticator::ResultCallback& result_callback);
+
   // Caller supplied fields.
   std::unique_ptr<ChromotingHostContext> host_context_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   base::WeakPtr<It2MeHost::Observer> observer_;
   XmppSignalStrategy::XmppServerConfig xmpp_server_config_;
   std::string directory_bot_jid_;
 
   It2MeHostState state_;
 
   scoped_refptr<RsaKeyPair> host_key_pair_;
@@ skipping 21 matching lines @@
   // that on startup, we do not accidentally start a connection before we have
   // queried our policy restrictions.
   bool policy_received_;
 
   // On startup, it is possible to have Connect() called before the policy read
   // is completed.  Rather than just failing, we thunk the connection call so
   // it can be executed after at least one successful policy read. This
   // variable contains the thunk if it is necessary.
   base::Closure pending_connect_;
 
+  // Called after the client machine initiates the connection process and is

[Jamie, 2016/08/26 23:31:02]

s/is//

[joedow, 2016/08/30 00:08:24]

Acknowledged.

+  // determines whether to reject the connection or allow it to continue.
+  protocol::ValidatingAuthenticator::ValidationCallback validation_callback_;

[Jamie, 2016/08/26 23:31:02]

Is it necessary to store this, rather than rebinding each time?

[joedow, 2016/08/30 00:08:24]

Probably not, I was thinking it would simplify things but I don't think it helps
much.   I'll remove it.

+
   DISALLOW_COPY_AND_ASSIGN(It2MeHost);
 };
 
 // Having a factory interface makes it possible for the test to provide a mock
 // implementation of the It2MeHost.
 class It2MeHostFactory {
  public:
   It2MeHostFactory();
   virtual ~It2MeHostFactory();
 
@@ skipping 11 matching lines @@
       const std::string& directory_bot_jid);
 
  private:
   policy::PolicyService* policy_service_;
   DISALLOW_COPY_AND_ASSIGN(It2MeHostFactory);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_IT2ME_IT2ME_HOST_H_