Add separate nonce version of connect call.

remoting/client/plugin/chromoting_scriptable_object.cc

 // Copyright (c) 2011 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/client/plugin/chromoting_scriptable_object.h"
 
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "ppapi/cpp/var.h"
 #include "remoting/client/client_config.h"
@@ skipping 67 matching lines @@
 
   // Statistics.
   AddAttribute(kVideoBandwidthAttribute, Var());
   AddAttribute(kVideoCaptureLatencyAttribute, Var());
   AddAttribute(kVideoEncodeLatencyAttribute, Var());
   AddAttribute(kVideoDecodeLatencyAttribute, Var());
   AddAttribute(kVideoRenderLatencyAttribute, Var());
   AddAttribute(kRoundTripLatencyAttribute, Var());
 
   AddMethod("connect", &ChromotingScriptableObject::DoConnect);
-  AddMethod("connectSandboxed",
-            &ChromotingScriptableObject::DoConnectSandboxed);
+  AddMethod("connectUnsandboxed",
+            &ChromotingScriptableObject::DoConnectUnsandboxed);
   AddMethod("disconnect", &ChromotingScriptableObject::DoDisconnect);
   AddMethod("submitLoginInfo", &ChromotingScriptableObject::DoSubmitLogin);
   AddMethod("setScaleToFit", &ChromotingScriptableObject::DoSetScaleToFit);
   AddMethod("onIq", &ChromotingScriptableObject::DoOnIq);
 }
 
 bool ChromotingScriptableObject::HasProperty(const Var& name, Var* exception) {
   // TODO(ajwong): Check if all these name.is_string() sentinels are required.
   if (!name.is_string()) {
     *exception = Var("HasProperty expects a string for the name.");
@@ skipping 220 matching lines @@
 
 void ChromotingScriptableObject::SendIq(const std::string& message_xml) {
   Var exception;
   Var cb = GetProperty(Var(kSendIq), &exception);
 
   // Var() means call the object directly as a function rather than calling
   // a method in the object.
   cb.Call(Var(), Var(message_xml), &exception);
 
   if (!exception.is_undefined())
-    LogDebugInfo("Exception when invoking loginChallenge JS callback.");
+    LogDebugInfo("Exception when invoking sendiq JS callback.");
 }
 
 Var ChromotingScriptableObject::DoConnect(const std::vector<Var>& args,
                                           Var* exception) {
-  if (args.size() != 4) {
-    *exception = Var("Usage: connect(username, host_jid, auth_token)");
+  // Parameter order is:
+  //   host_jid
+  //   client_jid
+  //   access_code (optional)
+  unsigned int arg = 0;
+  if (!args[arg].is_string()) {
+    *exception = Var("The host_jid must be a string.");
+    return Var();
+  }
+  std::string host_jid = args[arg++].AsString();
+
+  if (!args[arg].is_string()) {
+    *exception = Var("The client_jid must be a string.");
+    return Var();
+  }
+  std::string client_jid = args[arg++].AsString();
+
+  std::string access_code;
+  if (args.size() > arg) {
+    if (!args[arg].is_string()) {
+      *exception = Var("The access code must be a string.");
+      return Var();
+    }
+    access_code = args[arg++].AsString();
+  }
+
+  if (args.size() != arg) {
+    *exception = Var("Too many agruments passed to connect().");
     return Var();
   }
 
-  ClientConfig config;
+  LogDebugInfo("Connecting to host.");
+  VLOG(1) << "client_jid: " << client_jid << ", host_jid: " << host_jid
+          << ", access_code: " << access_code;
+  instance_->ConnectSandboxed(client_jid, host_jid, access_code);
 
-  if (!args[0].is_string()) {
+  return Var();
+}
+
+Var ChromotingScriptableObject::DoConnectUnsandboxed(
+    const std::vector<Var>& args,
+    Var* exception) {
+  // Parameter order is:
+  //   host_jid
+  //   username
+  //   xmpp_token
+  //   access_code (optional)
+  unsigned int arg = 0;
+  if (!args[arg].is_string()) {
+    *exception = Var("The host_jid must be a string.");
+    return Var();
+  }
+  std::string host_jid = args[arg++].AsString();
+
+  if (!args[arg].is_string()) {
     *exception = Var("The username must be a string.");
     return Var();
   }
-  config.username = args[0].AsString();
+  std::string username = args[arg++].AsString();
 
-  if (!args[1].is_string()) {
-    *exception = Var("The host_jid must be a string.");
-    return Var();
-  }
-  config.host_jid = args[1].AsString();
-
-  if (!args[2].is_string()) {
+  if (!args[arg].is_string()) {
     *exception = Var("The auth_token must be a string.");
     return Var();
   }
-  config.auth_token = args[2].AsString();
+  std::string auth_token = args[arg++].AsString();
 
-  if (!args[3].is_string()) {
-    *exception = Var("nonce must be a string.");
+  std::string access_code;
+  if (args.size() > arg) {
+    if (!args[arg].is_string()) {
+      *exception = Var("The access code must be a string.");
+      return Var();
+    }
+    access_code = args[arg++].AsString();
+  }
+
+  if (args.size() != arg) {
+    *exception = Var("Too many agruments passed to connect().");
     return Var();
   }
-  config.nonce = args[3].AsString();
 
   LogDebugInfo("Connecting to host.");
+  ClientConfig config;
+  config.host_jid = host_jid;
+  config.username = username;
+  config.auth_token = auth_token;
+  config.nonce = access_code;
+  VLOG(1) << "host_jid: " << host_jid << ", username: " << username
+          << ", access_code: " << access_code;
   instance_->Connect(config);
 
   return Var();
 }
-
-Var ChromotingScriptableObject::DoConnectSandboxed(
-    const std::vector<Var>& args, Var* exception) {
-  if (args.size() != 3) {
-    *exception = Var("Usage: connectSandboxed(your_jid, host_jid, nonce)");
-    return Var();
-  }
-
-  std::string your_jid;
-  if (!args[0].is_string()) {
-    *exception = Var("your_jid must be a string.");
-    return Var();
-  }
-  your_jid = args[0].AsString();
-
-  std::string host_jid;
-  if (!args[1].is_string()) {
-    *exception = Var("host_jid must be a string.");
-    return Var();
-  }
-  host_jid = args[1].AsString();
-
-  std::string nonce;
-  if (!args[2].is_string()) {
-    *exception = Var("nonce must be a string.");
-    return Var();
-  }
-  nonce = args[2].AsString();
-
-  VLOG(1) << "your_jid: " << your_jid << ", host_jid: " << host_jid
-          << ", nonce: " << nonce;
-  instance_->ConnectSandboxed(your_jid, host_jid, nonce);
-
-  return Var();
-}
 
 Var ChromotingScriptableObject::DoDisconnect(const std::vector<Var>& args,
                                              Var* exception) {
   LogDebugInfo("Disconnecting from host.");
 
   instance_->Disconnect();
   return Var();
 }
 
 Var ChromotingScriptableObject::DoSubmitLogin(const std::vector<Var>& args,
@@ skipping 48 matching lines @@
     *exception = Var("response_xml must be a string.");
     return Var();
   }
 
   xmpp_proxy_->OnIq(args[0].AsString());
 
   return Var();
 }
 
 }  // namespace remoting