Host port range policy is no longer ignored in it2me host.

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>
 #include <vector>
 
+#include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.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/port_range.h"
 #include "remoting/protocol/validating_authenticator.h"
 #include "remoting/signaling/xmpp_signal_strategy.h"
 
 namespace base {
 class DictionaryValue;
 }
 
 namespace remoting {
 
 class ChromotingHost;
@@ skipping 70 matching lines @@
 
  protected:
   friend class base::RefCountedThreadSafe<It2MeHost>;
 
   ~It2MeHost() override;
 
   ChromotingHostContext* host_context() { return host_context_.get(); }
   base::WeakPtr<It2MeHost::Observer> observer() { return observer_; }
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(It2MeHostTest, HostUdpPortRangePolicy_ValidRange);
+  FRIEND_TEST_ALL_PREFIXES(It2MeHostTest, HostUdpPortRangePolicy_NoRange);
+
   // Updates state of the host. Can be called only on the network thread.
   void SetState(It2MeHostState state, const std::string& error_message);
 
   // Returns true if the host is in a post-starting, non-error state.
   bool IsRunning() const;
 
   // Processes the result of the confirmation dialog.
   void OnConfirmationResult(
       const protocol::ValidatingAuthenticator::ResultCallback& result_callback,
       It2MeConfirmationDialog::Result result);
 
   // Called by Connect() to check for policies and start connection process.
   void ReadPolicyAndConnect();
 
   // Called by ReadPolicyAndConnect once policies have been read.
   void FinishConnect();
 
   // Called when the support host registration completes.
   void OnReceivedSupportID(const std::string& support_id,
                            const base::TimeDelta& lifetime,
                            const std::string& error_message);
 
   // Handlers for NAT traversal and domain policies.
   void UpdateNatPolicy(bool nat_traversal_enabled);
   void UpdateHostDomainListPolicy(std::vector<std::string> host_domain_list);
   void UpdateClientDomainListPolicy(
       std::vector<std::string> client_domain_list);
+  void UpdateHostUdpPortRangePolicy(const std::string& port_range_string);
 
   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);
 
   // Caller supplied fields.
@@ skipping 17 matching lines @@
   std::unique_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory_;
   std::unique_ptr<It2MeConfirmationDialogProxy> confirmation_dialog_proxy_;
 
   // Host the current nat traversal policy setting.
   bool nat_traversal_enabled_ = false;
 
   // The client and host domain policy setting.
   std::vector<std::string> required_client_domain_list_;
   std::vector<std::string> required_host_domain_list_;
 
+  // The host port range policy setting.
+  PortRange udp_port_range_;
+
   // Tracks the JID of the remote user when in a connecting state.
   std::string connecting_jid_;
 
   // Indicates whether or not a policy has ever been read. This is to ensure
   // 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
@@ skipping 18 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_