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"
 #include "remoting/client/chromoting_stats.h"
 #include "remoting/client/plugin/chromoting_instance.h"
 #include "remoting/client/plugin/pepper_xmpp_proxy.h"
 
 using pp::Var;
 
 namespace remoting {
 
 namespace {
 
 const char kConnectionInfoUpdate[] = "connectionInfoUpdate";
 const char kDebugInfo[] = "debugInfo";
 const char kDesktopHeight[] = "desktopHeight";
 const char kDesktopWidth[] = "desktopWidth";
 const char kDesktopSizeUpdate[] = "desktopSizeUpdate";
 const char kLoginChallenge[] = "loginChallenge";
+const char kSandboxedAttribute[] = "sandboxed";
 const char kSendIq[] = "sendIq";
 const char kQualityAttribute[] = "quality";
 const char kStatusAttribute[] = "status";
 const char kVideoBandwidthAttribute[] = "videoBandwidth";
 const char kVideoCaptureLatencyAttribute[] = "videoCaptureLatency";
 const char kVideoEncodeLatencyAttribute[] = "videoEncodeLatency";
 const char kVideoDecodeLatencyAttribute[] = "videoDecodeLatency";
 const char kVideoRenderLatencyAttribute[] = "videoRenderLatency";
 const char kRoundTripLatencyAttribute[] = "roundTripLatency";
 
 }  // namespace
 
 ChromotingScriptableObject::ChromotingScriptableObject(
     ChromotingInstance* instance)
     : instance_(instance) {
 }
 
 ChromotingScriptableObject::~ChromotingScriptableObject() {
 }
 
 void ChromotingScriptableObject::Init() {
   // Property addition order should match the interface description at the
   // top of chromoting_scriptable_object.h.
 
   // Connection status.
   AddAttribute(kStatusAttribute, Var(STATUS_UNKNOWN));
 
+  // Sandbox status.
+  AddAttribute(kSandboxedAttribute, Var(true));
+
   // Connection status values.
   AddAttribute("STATUS_UNKNOWN", Var(STATUS_UNKNOWN));
   AddAttribute("STATUS_CONNECTING", Var(STATUS_CONNECTING));
   AddAttribute("STATUS_INITIALIZING", Var(STATUS_INITIALIZING));
   AddAttribute("STATUS_CONNECTED", Var(STATUS_CONNECTED));
   AddAttribute("STATUS_CLOSED", Var(STATUS_CLOSED));
   AddAttribute("STATUS_FAILED", Var(STATUS_FAILED));
 
   // Connection quality.
   AddAttribute(kQualityAttribute, Var(QUALITY_UNKNOWN));
@@ skipping 14 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("disconnect", &ChromotingScriptableObject::DoDisconnect);
   AddMethod("submitLoginInfo", &ChromotingScriptableObject::DoSubmitLogin);
   AddMethod("setScaleToFit", &ChromotingScriptableObject::DoSetScaleToFit);
+  AddMethod("setSandboxed", &ChromotingScriptableObject::DoSetSandboxed);
   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.");
     return false;
   }
 
@@ skipping 217 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)");
+  int sandboxed_index = property_names_[kSandboxedAttribute];
+  bool sandboxed = properties_[sandboxed_index].attribute.AsBool();
+
+  // Parameter order is:
+  //   host_jid
+  //   auth_type: ACCESS_CODE or AUTHENTICATE
+  //   if sandboxed:
+  //     client_jid
+  //   else:
+  //     username (TODO remove support for non-sandboxed)
+  //     xmpp_auth_token
+  //   if ACCESS_CODE:
+  //     access_code
+  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 authentication type must be a string.");
+    return Var();
+  }
+  std::string auth_type = args[arg++].AsString();
+  bool use_access_code = (auth_type == "ACCESS_CODE");
+
+  std::string client_jid;
+  std::string username;
+  std::string auth_token;
+  if (sandboxed) {
+    if (!args[arg].is_string()) {
+      *exception = Var("The client_jid must be a string.");
+      return Var();
+    }
+    client_jid = args[arg++].AsString();
+  } else {
+    // TODO(garykac): Remove support for non-sandboxed connections.
+    if (!args[arg].is_string()) {
+      *exception = Var("The username must be a string.");
+      return Var();
+    }
+    username = args[arg++].AsString();
+
+    if (!args[arg].is_string()) {
+      *exception = Var("The auth_token must be a string.");
+      return Var();
+    }
+    auth_token = args[arg++].AsString();
+  }
+
+  std::string access_code;
+  if (use_access_code) {
+    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;
-
-  if (!args[0].is_string()) {
-    *exception = Var("The username must be a string.");
-    return Var();
+  LogDebugInfo("Connecting to host.");
+  if (sandboxed) {
+    VLOG(1) << "client_jid: " << client_jid << ", host_jid: " << host_jid
+            << ", access_code: " << access_code;
+    instance_->ConnectSandboxed(client_jid, host_jid, access_code);
+  } else {
+    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);
   }
-  config.username = args[0].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()) {
-    *exception = Var("The auth_token must be a string.");
-    return Var();
-  }
-  config.auth_token = args[2].AsString();
-
-  if (!args[3].is_string()) {
-    *exception = Var("nonce must be a string.");
-    return Var();
-  }
-  config.nonce = args[3].AsString();
-
-  LogDebugInfo("Connecting to host.");
-  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 30 matching lines @@
   if (!args[0].is_bool()) {
     *exception = Var("scale_to_fit must be a boolean.");
     return Var();
   }
 
   LogDebugInfo("Setting scale-to-fit.");
   instance_->SetScaleToFit(args[0].AsBool());
   return Var();
 }
 
+Var ChromotingScriptableObject::DoSetSandboxed(const std::vector<Var>& args,
+                                                Var* exception) {
+  if (args.size() != 1) {
+    *exception = Var("Usage: setSandboxed(sandboxed)");

[Wez, 2011/05/20 22:38:59]

Why do we have a method for this, rather than setting it directly?

+    return Var();
+  }
+
+  if (!args[0].is_bool()) {
+    *exception = Var("sandboxed must be a boolean.");
+    return Var();
+  }
+
+  LogDebugInfo("Setting sandboxed.");
+  int sandboxed_index = property_names_[kSandboxedAttribute];
+  properties_[sandboxed_index].attribute = args[0].AsBool();
+  return Var();
+}
+
 Var ChromotingScriptableObject::DoOnIq(const std::vector<Var>& args,
                                        Var* exception) {
   if (args.size() != 1) {
     *exception = Var("Usage: onIq(response_xml)");
     return Var();
   }
 
   if (!args[0].is_string()) {
     *exception = Var("response_xml must be a string.");
     return Var();
   }
 
   xmpp_proxy_->OnIq(args[0].AsString());
 
   return Var();
 }
 
 }  // namespace remoting