[Chromoting] Add SessionPlugin in JingleSession

remoting/protocol/jingle_session_unittest.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 <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "net/socket/socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/chromium_port_allocator_factory.h"
 #include "remoting/protocol/connection_tester.h"
 #include "remoting/protocol/fake_authenticator.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/network_settings.h"
+#include "remoting/protocol/session_plugin.h"
 #include "remoting/protocol/transport.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/signaling/fake_signal_strategy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/libjingle/xmpp/constants.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::AtMost;
@@ skipping 56 matching lines @@
       on_message_callback_.Run();
     return true;
   }
 
  private:
   SendTransportInfoCallback send_transport_info_callback_;
   std::vector<std::unique_ptr<buzz::XmlElement>> received_messages_;
   base::Closure on_message_callback_;
 };
 
+class FakePlugin : public SessionPlugin {
+ public:
+   std::unique_ptr<buzz::XmlElement> GetNextMessage() override {
+     std::string tag_name = "test-tag-";
+     tag_name += base::IntToString(outgoing_messages_.size());
+     std::unique_ptr<buzz::XmlElement> new_message(new buzz::XmlElement(
+         buzz::QName("test-namespace", tag_name)));
+     outgoing_messages_.push_back(*new_message);
+     return new_message;
+  }
+
+  void OnIncomingMessage(const buzz::XmlElement& attachments) override {
+    for (const buzz::XmlElement* it = attachments.FirstElement();
+         it != nullptr;
+         it = it->NextElement()) {
+      incoming_messages_.push_back(*it);
+    }
+  }
+
+  const std::vector<buzz::XmlElement>& outgoing_messages() const {
+    return outgoing_messages_;
+  }
+
+  const std::vector<buzz::XmlElement>& incoming_messages() const {
+    return incoming_messages_;
+  }
+
+  void Clear() {
+    outgoing_messages_.clear();
+    incoming_messages_.clear();
+  }
+
+ private:
+  std::vector<buzz::XmlElement> outgoing_messages_;
+  std::vector<buzz::XmlElement> incoming_messages_;
+};
+
 std::unique_ptr<buzz::XmlElement> CreateTransportInfo(const std::string& id) {
   std::unique_ptr<buzz::XmlElement> result(
       buzz::XmlElement::ForStr("<transport xmlns='google:remoting:ice'/>"));
   result->AddAttr(buzz::QN_ID, id);
   return result;
 }
 
 }  // namespace
 
 class JingleSessionTest : public testing::Test {
  public:
   JingleSessionTest() {
     message_loop_.reset(new base::MessageLoopForIO());
     network_settings_ =
         NetworkSettings(NetworkSettings::NAT_TRAVERSAL_OUTGOING);
   }
 
   // Helper method that handles OnIncomingSession().
   void SetHostSession(Session* session) {
     DCHECK(session);
     host_session_.reset(session);
     host_session_->SetEventHandler(&host_session_event_handler_);
     host_session_->SetTransport(&host_transport_);
+    host_session_->AddPlugin(&host_plugin_);
   }
 
   void DeleteHostSession() { host_session_.reset(); }
 
   void DeleteClientSession() { client_session_.reset(); }
 
  protected:
   void TearDown() override {
     CloseSessions();
     CloseSessionManager();
@@ skipping 93 matching lines @@
                   OnSessionStateChange(Session::CLOSED))
           .Times(AtMost(1));
     }
   }
 
   void ConnectClient(std::unique_ptr<Authenticator> authenticator) {
     client_session_ =
         client_server_->Connect(host_jid_, std::move(authenticator));
     client_session_->SetEventHandler(&client_session_event_handler_);
     client_session_->SetTransport(&client_transport_);
+    client_session_->AddPlugin(&client_plugin_);
     base::RunLoop().RunUntilIdle();
   }
 
   void InitiateConnection(int auth_round_trips,
                           FakeAuthenticator::Action auth_action,
                           bool expect_fail) {
     SetHostExpectation(expect_fail);
     SetClientExpectation(expect_fail);
     ConnectClient(base::MakeUnique<FakeAuthenticator>(
         FakeAuthenticator::CLIENT, auth_round_trips, auth_action, true));
   }
 
   void ExpectRouteChange(const std::string& channel_name) {
     EXPECT_CALL(host_session_event_handler_,
                 OnSessionRouteChange(channel_name, _))
         .Times(AtLeast(1));
     EXPECT_CALL(client_session_event_handler_,
                 OnSessionRouteChange(channel_name, _))
         .Times(AtLeast(1));
   }
 
+  void ExpectPluginMessagesEqual() const {
+    ASSERT_EQ(client_plugin_.outgoing_messages().size(),
+              host_plugin_.incoming_messages().size());
+    for (size_t i = 0; i < client_plugin_.outgoing_messages().size(); i++) {
+      ASSERT_EQ(client_plugin_.outgoing_messages()[i].Str(),
+                host_plugin_.incoming_messages()[i].Str());
+    }
+
+    ASSERT_EQ(client_plugin_.incoming_messages().size(),
+              host_plugin_.outgoing_messages().size());
+    for (size_t i = 0; i < client_plugin_.incoming_messages().size(); i++) {
+      ASSERT_EQ(client_plugin_.incoming_messages()[i].Str(),
+                host_plugin_.outgoing_messages()[i].Str());
+    }
+  }
+
   std::unique_ptr<base::MessageLoopForIO> message_loop_;
 
   NetworkSettings network_settings_;
 
   std::unique_ptr<FakeSignalStrategy> host_signal_strategy_;
   std::unique_ptr<FakeSignalStrategy> client_signal_strategy_;
 
   std::string host_jid_ = kHostJid;
 
   std::unique_ptr<JingleSessionManager> host_server_;
   MockSessionManagerListener host_server_listener_;
   std::unique_ptr<JingleSessionManager> client_server_;
 
   std::unique_ptr<Session> host_session_;
   MockSessionEventHandler host_session_event_handler_;
   FakeTransport host_transport_;
   std::unique_ptr<Session> client_session_;
   MockSessionEventHandler client_session_event_handler_;
   FakeTransport client_transport_;
+
+  FakePlugin host_plugin_;
+  FakePlugin client_plugin_;
 };
 
 
 // Verify that we can create and destroy session managers without a
 // connection.
 TEST_F(JingleSessionTest, CreateAndDestoy) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
 }
 
 // Verify that an incoming session can be rejected, and that the
@@ skipping 258 matching lines @@
   // Resume authentication.
   authenticator->Resume();
   base::RunLoop().RunUntilIdle();
 
   // Verify that transport-info that the first transport-info message was
   // received.
   ASSERT_EQ(client_transport_.received_messages().size(), 1U);
   EXPECT_EQ("1", client_transport_.received_messages()[0]->Attr(buzz::QN_ID));
 }
 
+TEST_F(JingleSessionTest, TestSessionPlugin) {
+  host_plugin_.Clear();
+  client_plugin_.Clear();
+  CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
+  ASSERT_NO_FATAL_FAILURE(
+      InitiateConnection(3, FakeAuthenticator::ACCEPT, false));
+  ExpectPluginMessagesEqual();
+}
+
+TEST_F(JingleSessionTest, SessionPluginShouldNotBeInvolvedInSessionTerminate) {
+  host_plugin_.Clear();
+  client_plugin_.Clear();
+  CreateSessionManagers(1, FakeAuthenticator::REJECT);
+  InitiateConnection(1, FakeAuthenticator::ACCEPT, true);
+  // It's expected the client sends one more plugin message than host, the host
+  // won't send plugin message in the SESSION_TERMINATE message.
+  ASSERT_EQ(client_plugin_.outgoing_messages().size() - 1,
+            client_plugin_.incoming_messages().size());
+  ExpectPluginMessagesEqual();
+}
+
+TEST_F(JingleSessionTest, ImmediatelyCloseSessionAfterConnect) {
+  CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
+  client_session_ = client_server_->Connect(host_jid_,
+      base::MakeUnique<FakeAuthenticator>(
+          FakeAuthenticator::CLIENT, 3, FakeAuthenticator::ACCEPT, true));
+  client_session_->Close(HOST_OVERLOAD);
+  base::RunLoop().RunUntilIdle();
+  // We should only send a SESSION_TERMINATE message if the session has been
+  // closed before SESSION_INITIATE message.
+  ASSERT_EQ(1U, host_signal_strategy_->received_messages().size());
+}
+
 }  // namespace protocol
 }  // namespace remoting