[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"
@@ skipping 68 matching lines @@
 const int kMaxPortNumber = 12409;
 
 const char kUnofficialOAuth2ClientId[] =
     "440925447803-2pi3v45bff6tp1rde2f7q6lgbor3o5uj.apps.googleusercontent.com";
 const char kUnofficialOAuth2ClientSecret[] = "W2ieEsG-R1gIA4MMurGrgMc_";
 
 const char kOfficialOAuth2ClientId[] =
     "440925447803-avn2sj1kc099s0r7v62je5s339mu0am1.apps.googleusercontent.com";
 const char kOfficialOAuth2ClientSecret[] = "Bgur6DFiOMM1h8x-AQpuTQlK";
 
+// Whether a given string ends with a given suffix.
+bool EndsWith(std::string s, std::string suffix) {
+  if (s.length() < suffix.length()) {
+    return false;
+  }
+  return s.compare(s.length() - suffix.length(), suffix.length(), suffix) == 0;
+}
+
 }  // namespace
 
 namespace remoting {
 
 class HostProcess
     : public HeartbeatSender::Listener {
  public:
   HostProcess()
       : message_loop_(MessageLoop::TYPE_UI),
 #ifdef OFFICIAL_BUILD
@@ skipping 217 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)) {
+      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 125 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)