Jingle_glue bugfixes.

remoting/jingle_glue/jingle_test_client.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 #if !defined(OS_WIN)
 extern "C" {
 #include <unistd.h>
 }
 #endif  // !defined(OS_WIN)
 
 #include <iostream>
 #include <list>
 
 #include "base/at_exit.h"
+#include "base/nss_util.h"
+#include "base/time.h"
 #include "media/base/data_buffer.h"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/jingle_channel.h"
 #include "remoting/jingle_glue/jingle_client.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 
 using remoting::JingleClient;
 using remoting::JingleChannel;
 using remoting::kChromotingTokenServiceName;
 
 class JingleTestClient : public JingleChannel::Callback,
-                         public JingleClient::Callback {
+                         public JingleClient::Callback,
+                         public base::RefCountedThreadSafe<JingleTestClient> {
  public:
+  JingleTestClient()
+      : closed_event_(true, false) {
+  }
+
   virtual ~JingleTestClient() {}
 
   void Run(const std::string& username, const std::string& auth_token,
            const std::string& host_jid) {
-    // TODO(hclam): Fix the threading problem.
     remoting::JingleThread jingle_thread;
     jingle_thread.Start();
     client_ = new JingleClient(&jingle_thread);
     client_->Init(username, auth_token, kChromotingTokenServiceName, this);
 
     if (host_jid != "") {
       scoped_refptr<JingleChannel> channel = client_->Connect(host_jid, this);
       channels_.push_back(channel);
     }
 
@@ skipping 11 matching lines @@
           memcpy(buf, line.c_str(), line.length());
           (*it)->Write(new media::DataBuffer(buf, line.length()));
         }
       }
 
       if (line == "exit")
         break;
     }
 
     while (!channels_.empty()) {
-      channels_.front()->Close();
+      closed_event_.Reset();
+      channels_.front()->Close(
+          NewRunnableMethod(this, &JingleTestClient::OnClosed));
+      // Wait until channel is closed. If it is not closed within 0.1 seconds
+      // continue closing everything else.
+      closed_event_.TimedWait(base::TimeDelta::FromMilliseconds(100));
       channels_.pop_front();
     }
 
     client_->Close();
     jingle_thread.Stop();
   }
 
   // JingleChannel::Callback interface.
   void OnStateChange(JingleChannel* channel, JingleChannel::State state) {
     LOG(INFO) << "State of " << channel->jid() << " changed to " << state;
@@ skipping 22 matching lines @@
     return true;
   }
 
   void OnNewConnection(JingleClient* client,
                        scoped_refptr<JingleChannel> channel) {
     std::cerr << "Connected to " << channel->jid() << std::endl;
     AutoLock auto_lock(channels_lock_);
     channels_.push_back(channel);
   }
 
+  void OnClosed() {
+    closed_event_.Signal();
+  }
+
  private:
   typedef std::list<scoped_refptr<JingleChannel> > ChannelsList;
 
   scoped_refptr<JingleClient> client_;
   ChannelsList channels_;
   Lock channels_lock_;
+  base::WaitableEvent closed_event_;
 };
 
 int main(int argc, char** argv) {
   if (argc > 2)
     std::cerr << "Usage: " << argv[0] << " [<host_jid>]" << std::endl;
 
   base::AtExitManager exit_manager;
 
+  base::EnsureNSPRInit();
+  base::EnsureNSSInit();
+
   std::string host_jid = argc == 2 ? argv[1] : "";
 
   std::string username;
   std::cout << "JID: ";
   std::cin >> username;
 
   std::string auth_token;
   std::cout << "Auth token: ";
   std::cin >> auth_token;
 
-  JingleTestClient client;
+  scoped_refptr<JingleTestClient> client = new JingleTestClient();
 
-  client.Run(username, auth_token, host_jid);
+  client->Run(username, auth_token, host_jid);
 
   return 0;
 }