Update ProtocolPerfTest to run host and client on different threads

Previously the host and client were running on the main thread, so they
both would compete for it and that skews the perf numbers, particularly
with NSS SSL sockets because they use a separate thread.

BUG=394067
R=rmsousa@chromium.org

Review URL: https://codereview.chromium.org/414443009

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@285738 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 55 insertions, 31 deletions

diff --git a/remoting/signaling/fake_signal_strategy.cc b/remoting/signaling/fake_signal_strategy.cc
index 8ce08c0..9e17e1d 100644
--- a/remoting/signaling/fake_signal_strategy.cc
+++ b/remoting/signaling/fake_signal_strategy.cc
@@ -19,13 +19,15 @@ namespace remoting {
 // static
 void FakeSignalStrategy::Connect(FakeSignalStrategy* peer1,
                                  FakeSignalStrategy* peer2) {
-  peer1->peer_ = peer2;
-  peer2->peer_ = peer1;
+  DCHECK(peer1->main_thread_->BelongsToCurrentThread());
+  DCHECK(peer2->main_thread_->BelongsToCurrentThread());
+  peer1->ConnectTo(peer2);
+  peer2->ConnectTo(peer1);
 }
 
 FakeSignalStrategy::FakeSignalStrategy(const std::string& jid)
-    : jid_(jid),
-      peer_(NULL),
+    : main_thread_(base::ThreadTaskRunnerHandle::Get()),
+      jid_(jid),
       last_id_(0),
       weak_factory_(this) {
 
@@ -38,6 +40,22 @@ FakeSignalStrategy::~FakeSignalStrategy() {
   }
 }
 
+void FakeSignalStrategy::ConnectTo(FakeSignalStrategy* peer) {
+  PeerCallback peer_callback =
+      base::Bind(&FakeSignalStrategy::DeliverMessageOnThread,
+                 main_thread_,
+                 weak_factory_.GetWeakPtr());
+  if (peer->main_thread_->BelongsToCurrentThread()) {
+    peer->SetPeerCallback(peer_callback);
+  } else {
+    peer->main_thread_->PostTask(
+        FROM_HERE,
+        base::Bind(&FakeSignalStrategy::SetPeerCallback,
+                   base::Unretained(peer),
+                   peer_callback));
+  }
+}
+
 void FakeSignalStrategy::Connect() {
   DCHECK(CalledOnValidThread());
   FOR_EACH_OBSERVER(Listener, listeners_,
@@ -78,8 +96,8 @@ bool FakeSignalStrategy::SendStanza(scoped_ptr<buzz::XmlElement> stanza) {
 
   stanza->SetAttr(buzz::QN_FROM, jid_);
 
-  if (peer_) {
-    peer_->OnIncomingMessage(stanza.Pass());
+  if (!peer_callback_.is_null()) {
+    peer_callback_.Run(stanza.Pass());
     return true;
   } else {
     return false;
@@ -91,35 +109,41 @@ std::string FakeSignalStrategy::GetNextId() {
   return base::IntToString(last_id_);
 }
 
+// static
+void FakeSignalStrategy::DeliverMessageOnThread(
+    scoped_refptr<base::SingleThreadTaskRunner> thread,
+    base::WeakPtr<FakeSignalStrategy> target,
+    scoped_ptr<buzz::XmlElement> stanza) {
+  thread->PostTask(FROM_HERE,
+                   base::Bind(&FakeSignalStrategy::OnIncomingMessage,
+                              target, base::Passed(&stanza)));
+}
+
 void FakeSignalStrategy::OnIncomingMessage(
     scoped_ptr<buzz::XmlElement> stanza) {
-  pending_messages_.push(stanza.get());
+  DCHECK(CalledOnValidThread());
+
+  buzz::XmlElement* stanza_ptr = stanza.get();
   received_messages_.push_back(stanza.release());
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&FakeSignalStrategy::DeliverIncomingMessages,
-                            weak_factory_.GetWeakPtr()));
-}
-
-void FakeSignalStrategy::DeliverIncomingMessages() {
-  while (!pending_messages_.empty()) {
-    buzz::XmlElement* stanza = pending_messages_.front();
-    const std::string& to_field = stanza->Attr(buzz::QN_TO);
-    if (to_field != jid_) {
-      LOG(WARNING) << "Dropping stanza that is addressed to " << to_field
-                   << ". Local jid: " << jid_
-                   << ". Message content: " << stanza->Str();
-      return;
-    }
-
-    ObserverListBase<Listener>::Iterator it(listeners_);
-    Listener* listener;
-    while ((listener = it.GetNext()) != NULL) {
-      if (listener->OnSignalStrategyIncomingStanza(stanza))
-        break;
-    }
-
-    pending_messages_.pop();
+
+  const std::string& to_field = stanza_ptr->Attr(buzz::QN_TO);
+  if (to_field != jid_) {
+    LOG(WARNING) << "Dropping stanza that is addressed to " << to_field
+                 << ". Local jid: " << jid_
+                 << ". Message content: " << stanza_ptr->Str();
+    return;
   }
+
+  ObserverListBase<Listener>::Iterator it(listeners_);
+  Listener* listener;
+  while ((listener = it.GetNext()) != NULL) {
+    if (listener->OnSignalStrategyIncomingStanza(stanza_ptr))
+      break;
+  }
+}
+
+void FakeSignalStrategy::SetPeerCallback(const PeerCallback& peer_callback) {
+  peer_callback_ = peer_callback;
 }
 
 }  // namespace remoting