Disconnect all users if too many connection requests are received for It2Me

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 <string>
 
@@ skipping 80 matching lines @@
   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.
+  // Returns the callback used for validating incoming connections.
+  // Do not run the returned callback after this object has been destroyed.
   protocol::ValidatingAuthenticator::ValidationCallback
-  GetValidationCallbackForTesting();
+  GetIncomingConnectionCallbackForTesting();
+
+  // Returns the callback used for validating accepted connections.
+  // Do not run the returned callback after this object has been destroyed.
+  protocol::ValidatingAuthenticator::ValidationCallback
+  GetAcceptedConnectionCallbackForTesting();
 
  protected:
   friend class base::RefCountedThreadSafe<It2MeHost>;
 
   ~It2MeHost() override;
 
   ChromotingHostContext* host_context() { return host_context_.get(); }
   base::WeakPtr<It2MeHost::Observer> observer() { return observer_; }
 
  private:
@@ skipping 31 matching lines @@
   void UpdateClientDomainPolicy(const std::string& client_domain);
 
   void DisconnectOnNetworkThread();
 
   // Uses details of the connection and current policies to determine if the
   // connection should be accepted or rejected.
   void ValidateConnectionDetails(
       const std::string& remote_jid,
       const protocol::ValidatingAuthenticator::ResultCallback& result_callback);
 
+  // Allows the user to accept or reject the connection before it is completed.
+  void ShowConfirmationDialog(
+      const std::string& remote_jid,
+      const protocol::ValidatingAuthenticator::ResultCallback& result_callback);
+
   // Caller supplied fields.
   std::unique_ptr<ChromotingHostContext> host_context_;
   base::WeakPtr<It2MeHost::Observer> observer_;
   std::unique_ptr<SignalStrategy> signal_strategy_;
   std::string username_;
   std::string directory_bot_jid_;
 
   It2MeHostState state_ = kDisconnected;
 
   scoped_refptr<RsaKeyPair> host_key_pair_;
@@ skipping 20 matching lines @@
   // that on startup, we do not accidentally start a connection before we have
   // queried our policy restrictions.
   bool policy_received_ = false;
 
   // 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
-  // determines whether to reject the connection or allow it to continue.
-  protocol::ValidatingAuthenticator::ValidationCallback validation_callback_;
-
   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 10 matching lines @@
       const std::string& username,
       const std::string& directory_bot_jid);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(It2MeHostFactory);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_IT2ME_IT2ME_HOST_H_