[Chromoting] Implement the host domain policy.

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"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/files/file_path_watcher.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/scoped_native_library.h"
+#include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "net/base/network_change_notifier.h"
 #include "net/socket/ssl_server_socket.h"
 #include "remoting/base/breakpad.h"
 #include "remoting/base/constants.h"
@@ skipping 271 matching lines @@
 
   void OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
     if (!context_->network_task_runner()->BelongsToCurrentThread()) {
       context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
           &HostProcess::OnPolicyUpdate, base::Unretained(this),
           base::Passed(&policies)));
       return;
     }
 
     bool bool_value;
+    std::string string_value;
+    if (policies->GetString(policy_hack::PolicyWatcher::kHostDomainPolicyName,
+                            &string_value)) {
+      OnHostDomainPolicyUpdate(string_value);
+    }
     if (policies->GetBoolean(policy_hack::PolicyWatcher::kNatPolicyName,
                              &bool_value)) {
       OnNatPolicyUpdate(bool_value);
     }
   }
 
+  void OnHostDomainPolicyUpdate(const std::string& host_domain) {
+    if (!context_->network_task_runner()->BelongsToCurrentThread()) {
+      context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
+          &HostProcess::OnHostDomainPolicyUpdate, base::Unretained(this),
+          host_domain));
+      return;
+    }
+
+    if (!host_domain.empty() &&
+        !EndsWith(xmpp_login_, std::string("@") + host_domain, false)) {
+      Shutdown(kInvalidHostDomainExitCode);
+    }
+  }
+
   void OnNatPolicyUpdate(bool nat_traversal_enabled) {
     if (!context_->network_task_runner()->BelongsToCurrentThread()) {
       context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
           &HostProcess::OnNatPolicyUpdate, base::Unretained(this),
           nat_traversal_enabled));
       return;
     }
 
     bool policy_changed = allow_nat_traversal_ != nat_traversal_enabled;
     allow_nat_traversal_ = nat_traversal_enabled;
 
     if (host_) {
       // Restart the host if the policy has changed while the host was
       // online.
       if (policy_changed)
         RestartHost();
     } else {
       // Just start the host otherwise.
       StartHost();
     }
   }
 
   void StartHost() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
     DCHECK(!host_);
 
+    if (shutting_down_)
+      return;
+
     if (!signal_strategy_.get()) {
       signal_strategy_.reset(
           new XmppSignalStrategy(context_->url_request_context_getter(),
                                  xmpp_login_, xmpp_auth_token_,
                                  xmpp_auth_service_));
 
       signaling_connector_.reset(new SignalingConnector(
           signal_strategy_.get(),
           base::Bind(&HostProcess::OnAuthFailed, base::Unretained(this))));
 
@@ skipping 104 matching lines @@
   }
 
   void Shutdown(int exit_code) {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     if (shutting_down_)
       return;
 
     shutting_down_ = true;
     exit_code_ = exit_code;
-    host_->Shutdown(base::Bind(
-        &HostProcess::OnShutdownFinished, base::Unretained(this)));
+    if (host_) {
+      host_->Shutdown(base::Bind(
+          &HostProcess::OnShutdownFinished, base::Unretained(this)));
+    } else {
+      OnShutdownFinished();
+    }
   }
 
   void OnShutdownFinished() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     // Destroy networking objects while we are on the network thread.
     host_ = NULL;
     host_event_logger_.reset();
     log_to_server_.reset();
     heartbeat_sender_.reset();
@@ skipping 131 matching lines @@
             user32.GetFunctionPointer("SetProcessDPIAware"));
     set_process_dpi_aware();
   }
 
   // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
   // the command line from GetCommandLineW(), so we can safely pass NULL here.
   return main(0, NULL);
 }
 
 #endif  // defined(OS_WIN)