Show a helpful error message if a host domain policy blocked an attempt to use

remoting/host/plugin/host_script_object.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.
 
 #include "remoting/host/plugin/host_script_object.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
@@ skipping 54 matching lines @@
 const char* kFuncNameStopDaemon = "stopDaemon";
 
 // States.
 const char* kAttrNameDisconnected = "DISCONNECTED";
 const char* kAttrNameStarting = "STARTING";
 const char* kAttrNameRequestedAccessCode = "REQUESTED_ACCESS_CODE";
 const char* kAttrNameReceivedAccessCode = "RECEIVED_ACCESS_CODE";
 const char* kAttrNameConnected = "CONNECTED";
 const char* kAttrNameDisconnecting = "DISCONNECTING";
 const char* kAttrNameError = "ERROR";
+const char* kAttrNameInvalidDomainError = "INVALID_DOMAIN_ERROR";
 
 const int kMaxLoginAttempts = 5;
 
 // We may need to have more than one task running at the same time
 // (e.g. key generation and status update), yet unlikely to ever need
 // more than 2 threads.
 const int kMaxWorkerPoolThreads = 2;
 
 }  // namespace
 
@@ skipping 223 matching lines @@
     return true;
   } else if (property_name == kAttrNameConnected) {
     INT32_TO_NPVARIANT(kConnected, *result);
     return true;
   } else if (property_name == kAttrNameDisconnecting) {
     INT32_TO_NPVARIANT(kDisconnecting, *result);
     return true;
   } else if (property_name == kAttrNameError) {
     INT32_TO_NPVARIANT(kError, *result);
     return true;
+  } else if (property_name == kAttrNameInvalidDomainError) {
+    INT32_TO_NPVARIANT(kInvalidDomainError, *result);
+    return true;
   } else {
     SetException("GetProperty: unsupported property " + property_name);
     return false;
   }
 }
 
 bool HostNPScriptObject::SetProperty(const std::string& property_name,
                                      const NPVariant* value) {
   VLOG(2) <<  "SetProperty " << property_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
@@ skipping 210 matching lines @@
   }
 
   if (state_ != kStarting) {
     // Host has been stopped while we were fetching policy.
     return;
   }
 
   // Check the host domain policy.
   if (!required_host_domain_.empty() &&
       !EndsWith(uid, std::string("@") + required_host_domain_, false)) {
-    SetState(kError);
+    SetState(kInvalidDomainError);
     return;
   }
 
   // Generate a key pair for the Host to use.
   // TODO(wez): Move this to the worker thread.
   host_key_pair_.Generate();
 
   // Create XMPP connection.
   scoped_ptr<SignalStrategy> signal_strategy(
       new XmppSignalStrategy(host_context_->url_request_context_getter(),
@@ skipping 469 matching lines @@
 void HostNPScriptObject::SetState(State state) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
   switch (state_) {
     case kDisconnected:
       DCHECK(state == kStarting ||
              state == kError) << state;
       break;
     case kStarting:
       DCHECK(state == kRequestedAccessCode ||
              state == kDisconnecting ||
-             state == kError) << state;
+             state == kError ||
+             state == kInvalidDomainError) << state;
       break;
     case kRequestedAccessCode:
       DCHECK(state == kReceivedAccessCode ||
              state == kDisconnecting ||
              state == kError) << state;
       break;
     case kReceivedAccessCode:
       DCHECK(state == kConnected ||
              state == kDisconnecting ||
              state == kError) << state;
       break;
     case kConnected:
       DCHECK(state == kDisconnecting ||
              state == kDisconnected ||
              state == kError) << state;
       break;
     case kDisconnecting:
       DCHECK(state == kDisconnected) << state;
       break;
     case kError:
       DCHECK(state == kDisconnecting) << state;
       break;
+    case kInvalidDomainError:
+      DCHECK(state == kDisconnecting) << state;
+      break;
   };
   state_ = state;
   NotifyStateChanged(state);
 }
 
 void HostNPScriptObject::NotifyStateChanged(State state) {
   if (!plugin_task_runner_->BelongsToCurrentThread()) {
     plugin_task_runner_->PostTask(
         FROM_HERE, base::Bind(&HostNPScriptObject::NotifyStateChanged,
                               base::Unretained(this), state));
@@ skipping 242 matching lines @@
   return is_good;
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   LOG(INFO) << exception_string;
 }
 
 }  // namespace remoting