Enables delegating signal strategy for It2Me Host.

remoting/host/it2me/it2me_native_messaging_host.cc

 // Copyright 2013 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/it2me/it2me_native_messaging_host.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringize_macros.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "components/policy/policy_constants.h"
 #include "net/base/url_util.h"
+#include "net/socket/client_socket_factory.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/host_exit_codes.h"
 #include "remoting/host/policy_watcher.h"
 #include "remoting/host/service_urls.h"
 #include "remoting/protocol/name_value_map.h"
+#include "remoting/signaling/delegating_signal_strategy.h"
 
 #if defined(OS_WIN)
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 
 #include "remoting/host/win/elevated_native_messaging_host.h"
 #endif  // defined(OS_WIN)
 
 namespace remoting {
 
@@ skipping 43 matching lines @@
     std::unique_ptr<It2MeHostFactory> factory)
     : needs_elevation_(needs_elevation),
       host_context_(std::move(context)),
       factory_(std::move(factory)),
       policy_service_(policy_service),
       policy_watcher_(PolicyWatcher::Create(policy_service_,
                                             host_context_->file_task_runner())),
       weak_factory_(this) {
   weak_ptr_ = weak_factory_.GetWeakPtr();
 
-  const ServiceUrls* service_urls = ServiceUrls::GetInstance();
-  const bool xmpp_server_valid =
-      net::ParseHostAndPort(service_urls->xmpp_server_address(),
-                            &xmpp_server_config_.host,
-                            &xmpp_server_config_.port);
-  DCHECK(xmpp_server_valid);
-
-  xmpp_server_config_.use_tls = service_urls->xmpp_server_use_tls();
-  directory_bot_jid_ = service_urls->directory_bot_jid();
-
   // The policy watcher runs on the |file_task_runner| but we want to run the
   // update code on |task_runner| so we use a shim to post the callback to the
   // preferred task runner.
   PolicyWatcher::PolicyUpdatedCallback update_callback =
       base::Bind(&It2MeNativeMessagingHost::OnPolicyUpdate, weak_ptr_);
   policy_watcher_->StartWatching(
       base::Bind(&PolicyUpdateCallback, task_runner(), update_callback),
       base::Bind(&OnPolicyError));
 }
 
@@ skipping 33 matching lines @@
   }
 
   response->SetString("type", type + "Response");
 
   if (type == "hello") {
     ProcessHello(std::move(message_dict), std::move(response));
   } else if (type == "connect") {
     ProcessConnect(std::move(message_dict), std::move(response));
   } else if (type == "disconnect") {
     ProcessDisconnect(std::move(message_dict), std::move(response));
+  } else if (type == "incomingIq") {
+    ProcessIncomingIq(std::move(message_dict), std::move(response));
   } else {
     SendErrorAndExit(std::move(response), "Unsupported request type: " + type);
   }
 }
 
 void It2MeNativeMessagingHost::Start(Client* client) {
   DCHECK(task_runner()->BelongsToCurrentThread());
   client_ = client;
 #if !defined(OS_CHROMEOS)
   log_message_handler_.reset(
@@ skipping 51 matching lines @@
     }
     return;
   }
 
   if (it2me_host_.get()) {
     SendErrorAndExit(std::move(response),
                      "Connect can be called only when disconnected.");
     return;
   }
 
-  XmppSignalStrategy::XmppServerConfig xmpp_config = xmpp_server_config_;
-
-  if (!message->GetString("userName", &xmpp_config.username)) {
+  std::string username;
+  if (!message->GetString("userName", &username)) {
     SendErrorAndExit(std::move(response), "'userName' not found in request.");
     return;
   }
 
-  std::string auth_service_with_token;
-  if (!message->GetString("authServiceWithToken", &auth_service_with_token)) {
-    SendErrorAndExit(std::move(response),
-                     "'authServiceWithToken' not found in request.");
-    return;
+  bool use_signaling_proxy = false;
+  message->GetBoolean("useSignalingProxy", &use_signaling_proxy);
+
+  const ServiceUrls* service_urls = ServiceUrls::GetInstance();
+  std::unique_ptr<SignalStrategy> signal_strategy;
+
+  if (!use_signaling_proxy) {
+    XmppSignalStrategy::XmppServerConfig xmpp_config;
+    xmpp_config.username = username;
+
+    const bool xmpp_server_valid =
+        net::ParseHostAndPort(service_urls->xmpp_server_address(),
+                              &xmpp_config.host, &xmpp_config.port);
+    DCHECK(xmpp_server_valid);
+    xmpp_config.use_tls = service_urls->xmpp_server_use_tls();
+
+    std::string auth_service_with_token;
+    if (!message->GetString("authServiceWithToken", &auth_service_with_token)) {
+      SendErrorAndExit(std::move(response),
+                       "'authServiceWithToken' not found in request.");
+      return;
+    }
+
+    // For backward compatibility the webapp still passes OAuth service as part
+    // of the authServiceWithToken field. But auth service part is always
+    // expected to be set to oauth2.
+    const char kOAuth2ServicePrefix[] = "oauth2:";
+    if (!base::StartsWith(auth_service_with_token, kOAuth2ServicePrefix,
+                          base::CompareCase::SENSITIVE)) {
+      SendErrorAndExit(std::move(response), "Invalid 'authServiceWithToken': " +
+                                                auth_service_with_token);
+      return;
+    }
+
+    xmpp_config.auth_token =
+        auth_service_with_token.substr(strlen(kOAuth2ServicePrefix));
+
+#if !defined(NDEBUG)
+    std::string address;
+    if (!message->GetString("xmppServerAddress", &address)) {
+      SendErrorAndExit(std::move(response),
+                       "'xmppServerAddress' not found in request.");
+      return;
+    }
+
+    if (!net::ParseHostAndPort(address, &xmpp_config.host, &xmpp_config.port)) {
+      SendErrorAndExit(std::move(response),
+                       "Invalid 'xmppServerAddress': " + address);
+      return;
+    }
+
+    if (!message->GetBoolean("xmppServerUseTls", &xmpp_config.use_tls)) {
+      SendErrorAndExit(std::move(response),
+                       "'xmppServerUseTls' not found in request.");
+      return;
+    }
+#endif  // !defined(NDEBUG)
+
+    signal_strategy.reset(new XmppSignalStrategy(
+        net::ClientSocketFactory::GetDefaultFactory(),
+        host_context_->url_request_context_getter(), xmpp_config));
+  } else {
+    std::string local_jid;
+
+    if (!message->GetString("localJid", &local_jid)) {
+      SendErrorAndExit(std::move(response), "'localJid' not found in request.");
+      return;
+    }
+
+    delegating_signal_strategy_ = new DelegatingSignalStrategy(
+        local_jid, host_context_->network_task_runner(),
+        base::Bind(&It2MeNativeMessagingHost::SendOutgoingIq,
+                   weak_factory_.GetWeakPtr()));
+    signal_strategy.reset(delegating_signal_strategy_);
   }
 
-  // For backward compatibility the webapp still passes OAuth service as part of
-  // the authServiceWithToken field. But auth service part is always expected to
-  // be set to oauth2.
-  const char kOAuth2ServicePrefix[] = "oauth2:";
-  if (!base::StartsWith(auth_service_with_token, kOAuth2ServicePrefix,
-                        base::CompareCase::SENSITIVE)) {
-    SendErrorAndExit(std::move(response), "Invalid 'authServiceWithToken': " +
-                                              auth_service_with_token);
-    return;
-  }
-
-  xmpp_config.auth_token =
-      auth_service_with_token.substr(strlen(kOAuth2ServicePrefix));
+  std::string directory_bot_jid = service_urls->directory_bot_jid();
 
 #if !defined(NDEBUG)
-  std::string address;
-  if (!message->GetString("xmppServerAddress", &address)) {
-    SendErrorAndExit(std::move(response),
-                     "'xmppServerAddress' not found in request.");
-    return;
-  }
-
-  if (!net::ParseHostAndPort(address, &xmpp_config.host,
-                             &xmpp_config.port)) {
-    SendErrorAndExit(std::move(response),
-                     "Invalid 'xmppServerAddress': " + address);
-    return;
-  }
-
-  if (!message->GetBoolean("xmppServerUseTls", &xmpp_config.use_tls)) {
-    SendErrorAndExit(std::move(response),
-                     "'xmppServerUseTls' not found in request.");
-    return;
-  }
-
-  if (!message->GetString("directoryBotJid", &directory_bot_jid_)) {
+  if (!message->GetString("directoryBotJid", &directory_bot_jid)) {
     SendErrorAndExit(std::move(response),
                      "'directoryBotJid' not found in request.");
     return;
   }
 #endif  // !defined(NDEBUG)
 
   // Create the It2Me host and start connecting.
-  it2me_host_ =
-      factory_->CreateIt2MeHost(host_context_->Copy(), policy_service_,
-                                weak_ptr_, xmpp_config, directory_bot_jid_);
+  it2me_host_ = factory_->CreateIt2MeHost(
+      host_context_->Copy(), policy_service_, weak_ptr_,
+      std::move(signal_strategy), username, directory_bot_jid);
   it2me_host_->Connect();
 
   SendMessageToClient(std::move(response));
 }
 
 void It2MeNativeMessagingHost::ProcessDisconnect(
     std::unique_ptr<base::DictionaryValue> message,
     std::unique_ptr<base::DictionaryValue> response) {
   DCHECK(task_runner()->BelongsToCurrentThread());
   DCHECK(policy_received_);
@@ skipping 11 matching lines @@
     return;
   }
 
   if (it2me_host_.get()) {
     it2me_host_->Disconnect();
     it2me_host_ = nullptr;
   }
   SendMessageToClient(std::move(response));
 }
 
+void It2MeNativeMessagingHost::ProcessIncomingIq(
+    std::unique_ptr<base::DictionaryValue> message,
+    std::unique_ptr<base::DictionaryValue> response) {
+  std::string iq;
+  if (!message->GetString("iq", &iq)) {
+    LOG(ERROR) << "Invalid incomingIq() data.";
+    return;
+  }
+
+  if (delegating_signal_strategy_)
+    delegating_signal_strategy_->OnIncomingMessage(iq);
+  SendMessageToClient(std::move(response));
+};
+
+void It2MeNativeMessagingHost::SendOutgoingIq(const std::string& iq) {
+  std::unique_ptr<base::DictionaryValue> message(new base::DictionaryValue());
+  message->SetString("iq", iq);
+  message->SetString("type", "sendOutgoingIq");
+  SendMessageToClient(std::move(message));
+}
+
 void It2MeNativeMessagingHost::SendErrorAndExit(
     std::unique_ptr<base::DictionaryValue> response,
     const std::string& description) const {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   LOG(ERROR) << description;
 
   response->SetString("type", "error");
   response->SetString("description", description);
   SendMessageToClient(std::move(response));
@@ skipping 146 matching lines @@
 
 bool It2MeNativeMessagingHost::DelegateToElevatedHost(
     std::unique_ptr<base::DictionaryValue> message) {
   NOTREACHED();
   return false;
 }
 
 #endif  // !defined(OS_WIN)
 
 }  // namespace remoting