[Chromoting] Add SessionPlugin in JingleSession

remoting/protocol/jingle_session.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/protocol/jingle_session.h"
 
 #include <stdint.h>
 
 #include <limits>
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/content_description.h"
 #include "remoting/protocol/jingle_messages.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/session_config.h"
+#include "remoting/protocol/session_plugin.h"
 #include "remoting/protocol/transport.h"
 #include "remoting/signaling/iq_sender.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 #include "third_party/webrtc/libjingle/xmpp/constants.h"
 #include "third_party/webrtc/p2p/base/candidate.h"
 
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
@@ skipping 167 matching lines @@
   peer_address_ = SignalingAddress(peer_jid);
   authenticator_ = std::move(authenticator);
 
   // Generate random session ID. There are usually not more than 1
   // concurrent session per host, so a random 64-bit integer provides
   // enough entropy. In the worst case connection will fail when two
   // clients generate the same session ID concurrently.
   session_id_ = base::Uint64ToString(
       base::RandGenerator(std::numeric_limits<uint64_t>::max()));
 
-  // Send session-initiate message.
-  std::unique_ptr<JingleMessage> message(new JingleMessage(
-      peer_address_, JingleMessage::SESSION_INITIATE, session_id_));
-  message->initiator = session_manager_->signal_strategy_->GetLocalJid();
-  message->description.reset(new ContentDescription(
-      session_manager_->protocol_config_->Clone(),
-      authenticator_->GetNextMessage()));
-  SendMessage(std::move(message));
+  // Delay sending session-initiate message to ensure SessionPlugin can be
+  // attached before the message.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+      base::Bind(&JingleSession::SendSessionInitiateMessage,
+                 weak_factory_.GetWeakPtr()));
 
   SetState(CONNECTING);
 }
 
 void JingleSession::InitializeIncomingConnection(
     const JingleMessage& initiate_message,
     std::unique_ptr<Authenticator> authenticator) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initiate_message.description.get());
   DCHECK(authenticator.get());
@@ skipping 13 matching lines @@
                  << " because no compatible configuration has been found.";
     Close(INCOMPATIBLE_PROTOCOL);
     return;
   }
 }
 
 void JingleSession::AcceptIncomingConnection(
     const JingleMessage& initiate_message) {
   DCHECK(config_);
 
+  ExecutePluginsOnIncomingMessage(initiate_message);
   // Process the first authentication message.
   const buzz::XmlElement* first_auth_message =
       initiate_message.description->authenticator_message();
 
   if (!first_auth_message) {
     Close(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
   DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
@@ skipping 53 matching lines @@
 }
 
 void JingleSession::SendTransportInfo(
     std::unique_ptr<buzz::XmlElement> transport_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, AUTHENTICATED);
 
   std::unique_ptr<JingleMessage> message(new JingleMessage(
       peer_address_, JingleMessage::TRANSPORT_INFO, session_id_));
   message->transport_info = std::move(transport_info);
+  ExecutePluginsOnOutgoingMessage(message.get());
 
   std::unique_ptr<buzz::XmlElement> stanza = message->ToXml();
   stanza->AddAttr(buzz::QN_ID, GetNextOutgoingId());
 
   auto request = session_manager_->iq_sender()->SendIq(
       std::move(stanza), base::Bind(&JingleSession::OnTransportInfoResponse,
                                     base::Unretained(this)));
   if (request) {
     request->SetTimeout(base::TimeDelta::FromSeconds(kTransportInfoTimeout));
     transport_info_requests_.push_back(std::move(request));
@@ skipping 44 matching lines @@
 
   if (state_ != FAILED && state_ != CLOSED) {
     if (error != OK) {
       SetState(FAILED);
     } else {
       SetState(CLOSED);
     }
   }
 }
 
+void JingleSession::AddPlugin(SessionPlugin* plugin) {
+  DCHECK(plugin);
+  plugins_.push_back(plugin);
+}
+
 void JingleSession::SendMessage(std::unique_ptr<JingleMessage> message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  if (message->action != JingleMessage::SESSION_TERMINATE) {
+    // When the host accepts session-initiate message from a client JID it
+    // doesn't recognize it sends session-terminate without session-accept.
+    // Attaching plugin information to this session-terminate message may lead
+    // to privacy issues (e.g. leaking Windows version to someone who does not
+    // own the host). So a simply approach is to ignore plugins when sending
+    // SESSION_TERMINATE message.
+    ExecutePluginsOnOutgoingMessage(message.get());
+  }
   std::unique_ptr<buzz::XmlElement> stanza = message->ToXml();
   stanza->AddAttr(buzz::QN_ID, GetNextOutgoingId());
 
   auto request = session_manager_->iq_sender()->SendIq(
       std::move(stanza), base::Bind(&JingleSession::OnMessageResponse,
                                     base::Unretained(this), message->action));
 
   int timeout = kDefaultMessageTimeout;
   if (message->action == JingleMessage::SESSION_INITIATE ||
       message->action == JingleMessage::SESSION_ACCEPT) {
@@ skipping 73 matching lines @@
   if (type != "result") {
     LOG(ERROR) << "Received error in response to transport-info message: \""
                << response->Str() << "\". Terminating the session.";
     Close(PEER_IS_OFFLINE);
   }
 }
 
 void JingleSession::OnIncomingMessage(const std::string& id,
                                       std::unique_ptr<JingleMessage> message,
                                       const ReplyCallback& reply_callback) {
+  ExecutePluginsOnIncomingMessage(*message);
   std::vector<PendingMessage> ordered = message_queue_->OnIncomingMessage(
       id, PendingMessage{std::move(message), reply_callback});
   base::WeakPtr<JingleSession> self = weak_factory_.GetWeakPtr();
   for (auto& message : ordered) {
     ProcessIncomingMessage(std::move(message.message), message.reply_callback);
     if (!self)
       return;
   }
 }
 
@@ skipping 245 matching lines @@
     if (event_handler_)
       event_handler_->OnSessionStateChange(new_state);
   }
 }
 
 bool JingleSession::is_session_active() {
   return state_ == CONNECTING || state_ == ACCEPTING || state_ == ACCEPTED ||
         state_ == AUTHENTICATING || state_ == AUTHENTICATED;
 }
 
+void JingleSession::ExecutePluginsOnIncomingMessage(

[Sergey Ulanov, 2016/12/29 00:37:58]

Maybe call it ProcessIncomingAttachments() or ProcessIncomingPluginMessage()?

[Hzj_jie, 2016/12/29 03:07:56]

Done.

+    const JingleMessage& message) {
+  if (message.attachments) {

[Sergey Ulanov, 2016/12/29 00:37:58]

if (!messeage.attachments) {
 return;
}

[Hzj_jie, 2016/12/29 03:07:57]

Done.

+    for (const auto& plugin : plugins_) {
+      plugin->OnIncomingMessage(*(message.attachments));
+    }
+  }
+}
+
+void JingleSession::ExecutePluginsOnOutgoingMessage(JingleMessage* message) {

[Sergey Ulanov, 2016/12/29 00:37:58]

Maybe AddPluginAttachments() or something like that? The current name doesn't
make it clear that this function may change the |message|.

[Hzj_jie, 2016/12/29 03:07:57]

Done.

+  DCHECK(message);
+  for (const auto& plugin : plugins_) {
+    std::unique_ptr<XmlElement> attachment = plugin->GetNextMessage();
+    if (attachment) {
+      message->AddAttachment(std::move(attachment));
+    }
+  }
+}
+
+void JingleSession::SendSessionInitiateMessage() {
+  std::unique_ptr<JingleMessage> message(new JingleMessage(

[Sergey Ulanov, 2016/12/29 00:37:58]

Need to check here that the state_ is still CONNECTING, in case the session was
closed.

[Hzj_jie, 2016/12/29 03:07:56]

Done.

+      peer_address_, JingleMessage::SESSION_INITIATE, session_id_));
+  message->initiator = session_manager_->signal_strategy_->GetLocalJid();
+  message->description.reset(new ContentDescription(
+      session_manager_->protocol_config_->Clone(),
+      authenticator_->GetNextMessage()));
+  SendMessage(std::move(message));
+}
+
 std::string JingleSession::GetNextOutgoingId() {
   return outgoing_id_prefix_ + "_" + base::IntToString(++next_outgoing_id_);
 }
 
 }  // namespace protocol
 }  // namespace remoting