First version of the peerconnection client application for Linux.

I made several updates to the Windows version as well so that both
implementations share
a big portion of the code.
The underlying PeerConnection notifications have changed a bit since the last
update
so that there's still a known issue that I plan to fix in my next change:

  // TODO(tommi): There's a problem now with terminating connections:
  // When ending a conversation, both peers now send a signaling message
  // that indicates that their ports are closed (port=0).  The trouble this
  // causes us here is that we can interpret such a message as an invite
  // to a new conversation.  So, currently there is a bug that ending
  // a conversation can immediately start a new one.
  // To fix this I plan to change how conversations start and have a special
  // notification message via the server that prepares a client for a
  // conversation instead of automatically recognizing the first signaling
  // message as an invite.
Review URL: http://webrtc-codereview.appspot.com/112008

git-svn-id: http://webrtc.googlecode.com/svn/trunk@446 4adac7df-926f-26a2-2b94-8c16560cd09d

peerconnection/samples/client/linux/main.cc

@@ -10,17 +10,71 @@
 
 #include <gtk/gtk.h>
 
+#include "peerconnection/samples/client/conductor.h"
 #include "peerconnection/samples/client/linux/main_wnd.h"
+#include "peerconnection/samples/client/peer_connection_client.h"
+
+#include "talk/base/thread.h"
+
+class CustomSocketServer : public talk_base::PhysicalSocketServer {
+ public:
+  CustomSocketServer(talk_base::Thread* thread, GtkMainWnd* wnd)
+      : thread_(thread), wnd_(wnd), conductor_(NULL), client_(NULL) {}
+  virtual ~CustomSocketServer() {}
+  
+  void set_client(PeerConnectionClient* client) { client_ = client; }
+  void set_conductor(Conductor* conductor) { conductor_ = conductor; }
+
+  // Override so that we can also pump the GTK message loop.
+  virtual bool Wait(int cms, bool process_io) {
+    // Pump GTK events.
+    // TODO(tommi): We really should move either the socket server or UI to a
+    // different thread.  Alternatively we could look at merging the two loops
+    // by implementing a dispatcher for the socket server and/or use
+    // g_main_context_set_poll_func.
+      while (gtk_events_pending())
+        gtk_main_iteration();
+    
+    if (!wnd_->IsWindow() && !conductor_->connection_active() &&
+        client_ != NULL && !client_->is_connected()) {
+      thread_->Quit();
+    }
+    return talk_base::PhysicalSocketServer::Wait(0/*cms == -1 ? 1 : cms*/,
+                                                 process_io);
+  }
+
+ protected:
+  talk_base::Thread* thread_;
+  GtkMainWnd* wnd_;
+  Conductor* conductor_;
+  PeerConnectionClient* client_;
+};
 
 int main(int argc, char* argv[]) {
   gtk_init(&argc, &argv);
   g_type_init();
+  g_thread_init(NULL);
 
   GtkMainWnd wnd;
   wnd.Create();
-  gtk_main();
+
+  talk_base::AutoThread auto_thread;
+  talk_base::Thread* thread = talk_base::Thread::Current();
+  CustomSocketServer socket_server(thread, &wnd);
+  thread->set_socketserver(&socket_server);
+
+  // Must be constructed after we set the socketserver.
+  PeerConnectionClient client;
+  Conductor conductor(&client, &wnd);
+  socket_server.set_client(&client);
+  socket_server.set_conductor(&conductor);
+
+  thread->Run();
+
+  // gtk_main();
   wnd.Destroy();
 
+  thread->set_socketserver(NULL);
   // TODO(tommi): Run the Gtk main loop to tear down the connection.
   //while (gtk_events_pending()) {
   //  gtk_main_iteration();