diff --git a/peerconnection/samples/client/conductor.cc b/peerconnection/samples/client/conductor.cc
index 698ba48..e0c029f 100644
--- a/peerconnection/samples/client/conductor.cc
+++ b/peerconnection/samples/client/conductor.cc
@@ -12,6 +12,7 @@
 
 #include "peerconnection/samples/client/defaults.h"
 #include "talk/base/logging.h"
+#include "talk/session/phone/videorendererfactory.h"
 
 Conductor::Conductor(PeerConnectionClient* client, MainWnd* main_wnd)
   : handshake_(NONE),
@@ -70,6 +71,8 @@
 
 void Conductor::DeletePeerConnection() {
   peer_connection_.reset();
+  local_renderer_.reset();
+  remote_renderer_.reset();
   handshake_ = NONE;
 }
 
@@ -79,8 +82,14 @@
     main_wnd_->SwitchToStreamingUI();
 
     if (peer_connection_->SetVideoCapture("")) {
-      peer_connection_->SetVideoRenderer(-1, main_wnd_->handle(), 0,
-                                         0.7f, 0.7f, 0.95f, 0.95f);
+      if (!local_renderer_.get()) {
+        // The window will be resized according to the stream properties
+        // when streaming starts.
+        local_renderer_.reset(
+            cricket::VideoRendererFactory::CreateGuiVideoRenderer(100, 100));
+      }
+      if (local_renderer_.get())
+        peer_connection_->SetLocalVideoRenderer(local_renderer_.get());
     } else {
       ASSERT(false);
     }
@@ -130,8 +139,13 @@
     video_channel_ = channel_id;
     waiting_for_video_ = false;
     LOG(INFO) << "Setting video renderer for channel: " << channel_id;
-    bool ok = peer_connection_->SetVideoRenderer(channel_id,
-        main_wnd_->handle(), 1, 0.0f, 0.0f, 1.0f, 1.0f);
+    if (!remote_renderer_.get()) {
+      // The window size will be automatically corrected.
+      remote_renderer_.reset(
+          cricket::VideoRendererFactory::CreateGuiVideoRenderer(100, 100));
+    }
+    bool ok = peer_connection_->SetVideoRenderer(stream_id,
+                                                 remote_renderer_.get());
     ASSERT(ok);
   } else {
     ASSERT(audio_channel_ == -1);
diff --git a/peerconnection/samples/client/conductor.h b/peerconnection/samples/client/conductor.h
index ce968d7..3b9d471 100644
--- a/peerconnection/samples/client/conductor.h
+++ b/peerconnection/samples/client/conductor.h
@@ -19,6 +19,9 @@
 #include "talk/app/peerconnection.h"
 #include "talk/base/scoped_ptr.h"
 
+namespace cricket {
+class VideoRenderer;
+}  // namespace cricket
 
 class Conductor
   : public webrtc::PeerConnectionObserver,
@@ -112,6 +115,8 @@
   MainWnd* main_wnd_;
   int video_channel_;
   int audio_channel_;
+  talk_base::scoped_ptr<cricket::VideoRenderer> local_renderer_;
+  talk_base::scoped_ptr<cricket::VideoRenderer> remote_renderer_;
 };
 
 #endif  // PEERCONNECTION_SAMPLES_CLIENT_CONDUCTOR_H_
diff --git a/third_party_mods/libjingle/libjingle.gyp b/third_party_mods/libjingle/libjingle.gyp
index 42f34bb..bad09b5 100644
--- a/third_party_mods/libjingle/libjingle.gyp
+++ b/third_party_mods/libjingle/libjingle.gyp
@@ -466,7 +466,7 @@
         'source/talk/session/phone/devicemanager.cc',
         'source/talk/session/phone/devicemanager.h',
         'source/talk/session/phone/filemediaengine.cc',
-        'source/talk/session/phone/filemediaengine.h',       
+        'source/talk/session/phone/filemediaengine.h',   
         'source/talk/session/phone/mediachannel.h',
         'source/talk/session/phone/mediaengine.cc',
         'source/talk/session/phone/mediaengine.h',
@@ -494,9 +494,17 @@
         'source/talk/session/tunnel/tunnelsessionclient.cc',
         'source/talk/session/tunnel/tunnelsessionclient.h',
       ],
-      'conditions': [        
+      'conditions': [
+        ['OS=="win"', {
+          'sources': [
+            'source/talk/session/phone/gdivideorenderer.cc',
+            'source/talk/session/phone/gdivideorenderer.h',
+          ],
+        }],   
         ['OS=="linux"', {
           'sources': [
+            #'source/talk/session/phone/gtkvideorenderer.cc',
+            #'source/talk/session/phone/gtkvideorenderer.h', 
             'source/talk/session/phone/libudevsymboltable.cc',
             'source/talk/session/phone/libudevsymboltable.h',
             'source/talk/session/phone/v4llookup.cc',
@@ -539,8 +547,6 @@
         'source/talk/app/voicemediaengine.h',
         'source/talk/app/webrtc_json.cc',
         'source/talk/app/webrtc_json.h',
-        'source/talk/app/webrtcchannelmanager.cc',
-        'source/talk/app/webrtcchannelmanager.h',
         'source/talk/app/webrtcsession.cc',
         'source/talk/app/webrtcsession.h',
         'source/talk/app/webrtcsessionimpl.cc',
@@ -556,8 +562,8 @@
             ],
           },{
             'sources': [        
-	          'source/talk/app/p2p_transport_manager.cc',
-	          'source/talk/app/p2p_transport_manager.h',
+              'source/talk/app/p2p_transport_manager.cc',
+              'source/talk/app/p2p_transport_manager.h',
             ],
           }],
         ],
diff --git a/third_party_mods/libjingle/source/talk/app/peerconnection.cc b/third_party_mods/libjingle/source/talk/app/peerconnection.cc
index 4a1962f..87805c1 100644
--- a/third_party_mods/libjingle/source/talk/app/peerconnection.cc
+++ b/third_party_mods/libjingle/source/talk/app/peerconnection.cc
@@ -115,7 +115,7 @@
                              cricket::PORTALLOCATOR_DISABLE_RELAY);
 
   // create channel manager
-  channel_manager_.reset(new WebRtcChannelManager(media_thread_.get()));
+  channel_manager_.reset(new cricket::ChannelManager(media_thread_.get()));
 
   //start the media thread
   media_thread_->SetPriority(talk_base::PRIORITY_HIGH);
@@ -244,24 +244,22 @@
   return channel_manager_->SetAudioOptions(wave_in_device, wave_out_device, opts);
 }
 
+bool PeerConnection::SetLocalVideoRenderer(cricket::VideoRenderer* renderer) {
+  return channel_manager_->SetLocalRenderer(renderer);
+}
+
+bool PeerConnection::SetVideoRenderer(const std::string& stream_id,
+    cricket::VideoRenderer* renderer) {
+  ASSERT(session_ != NULL);
+  return session_->SetVideoRenderer(stream_id, renderer);
+}
+
 bool PeerConnection::SetVideoRenderer(const std::string& stream_id,
     ExternalRenderer* external_renderer) {
   ASSERT(session_ != NULL);
   return session_->SetVideoRenderer(stream_id, external_renderer);
 }
 
-bool PeerConnection::SetVideoRenderer(int channel_id,
-                                      void* window,
-                                      unsigned int zOrder,
-                                      float left,
-                                      float top,
-                                      float right,
-                                      float bottom) {
-  ASSERT(session_ != NULL);
-  return session_->SetVideoRenderer(channel_id, window, zOrder, left, top,
-                                    right, bottom);
-}
-
 bool PeerConnection::SetVideoCapture(const std::string& cam_device) {
   return channel_manager_->SetVideoOptions(cam_device);
 }
diff --git a/third_party_mods/libjingle/source/talk/app/peerconnection.h b/third_party_mods/libjingle/source/talk/app/peerconnection.h
index 9ab8da5..e39c88b 100644
--- a/third_party_mods/libjingle/source/talk/app/peerconnection.h
+++ b/third_party_mods/libjingle/source/talk/app/peerconnection.h
@@ -10,7 +10,7 @@
 #include "talk/base/thread.h"
 #include "talk/base/scoped_ptr.h"
 #include "talk/base/basicpacketsocketfactory.h"
-#include "talk/app/webrtcchannelmanager.h"
+#include "talk/session/phone/channelmanager.h"
 
 namespace Json {
 class Value;
@@ -18,6 +18,8 @@
 
 namespace cricket {
 class BasicPortAllocator;
+class ChannelManager;
+class VideoRenderer;
 }
 
 #ifdef PLATFORM_CHROMIUM
@@ -76,16 +78,13 @@
   bool SetAudioDevice(const std::string& wave_in_device,
                       const std::string& wave_out_device, int opts);
   // Set the video renderer
+  bool SetLocalVideoRenderer(cricket::VideoRenderer* renderer);
+  bool SetVideoRenderer(const std::string& stream_id,
+                        cricket::VideoRenderer* renderer);
+
   bool SetVideoRenderer(const std::string& stream_id,
                         ExternalRenderer* external_renderer);
-  // Set channel_id to -1 for the local preview
-  bool SetVideoRenderer(int channel_id,
-                        void* window,
-                        unsigned int zOrder,
-                        float left,
-                        float top,
-                        float right,
-                        float bottom);
+
   // Set video capture device
   // For Chromium the cam_device should use the capture session id.
   // For standalone app, cam_device is the camera name. It will try to
@@ -120,7 +119,7 @@
 
   std::string config_;
   talk_base::scoped_ptr<talk_base::Thread> media_thread_;
-  talk_base::scoped_ptr<WebRtcChannelManager> channel_manager_;
+  talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
   talk_base::scoped_ptr<talk_base::NetworkManager> network_manager_;
   talk_base::scoped_ptr<cricket::BasicPortAllocator> port_allocator_;
   talk_base::scoped_ptr<talk_base::BasicPacketSocketFactory> socket_factory_;
diff --git a/third_party_mods/libjingle/source/talk/app/session_test/session_test_main.cc b/third_party_mods/libjingle/source/talk/app/session_test/session_test_main.cc
index 99af54e..e783bdf 100644
--- a/third_party_mods/libjingle/source/talk/app/session_test/session_test_main.cc
+++ b/third_party_mods/libjingle/source/talk/app/session_test/session_test_main.cc
@@ -20,6 +20,7 @@
 #include "talk/app/peerconnection.h"
 #include "talk/app/session_test/main_wnd.h"
 #include "talk/base/logging.h"
+#include "talk/session/phone/videorendererfactory.h"
 
 static const char kAudioLabel[] = "audio_label";
 static const char kVideoLabel[] = "video_label";
@@ -217,6 +218,7 @@
   }
 
   void OnConnect(talk_base::AsyncSocket* socket) {
+    ASSERT(!onconnect_data_.empty());
     int sent = socket->Send(onconnect_data_.c_str(), onconnect_data_.length());
     ASSERT(sent == onconnect_data_.length());
     onconnect_data_.clear();
@@ -385,8 +387,10 @@
       notification_data_.clear();
     }
 
-    if (hanging_get_.GetState() == talk_base::Socket::CS_CLOSED)
+    if (hanging_get_.GetState() == talk_base::Socket::CS_CLOSED &&
+        state_ == CONNECTED) {
       hanging_get_.Connect(server_address_);
+    }
   }
 
   // Parses a single line entry in the form "<name>,<id>,<connected>"
@@ -446,7 +450,9 @@
 
   void OnClose(talk_base::AsyncSocket* socket, int err) {
     LOG(INFO) << __FUNCTION__;
+
     socket->Close();
+
     if (err != WSAECONNREFUSED) {
       if (socket == &hanging_get_) {
         if (state_ == CONNECTED) {
@@ -553,6 +559,7 @@
 
   void DeletePeerConnection() {
     peer_connection_.reset();
+    handshake_ = NONE;
   }
 
   void StartCaptureDevice() {
@@ -561,8 +568,11 @@
       main_wnd_->SwitchToStreamingUI();
 
       if (peer_connection_->SetVideoCapture("")) {
-        peer_connection_->SetVideoRenderer(-1, main_wnd_->handle(), 0,
-                                           0.7f, 0.7f, 0.95f, 0.95f);
+        if (!local_renderer_.get()) {
+          local_renderer_.reset(
+              cricket::VideoRendererFactory::CreateGuiVideoRenderer(176, 144));
+        }
+        peer_connection_->SetLocalVideoRenderer(local_renderer_.get());
       } else {
         ASSERT(false);
       }
@@ -612,8 +622,12 @@
       video_channel_ = channel_id;
       waiting_for_video_ = false;
       LOG(INFO) << "Setting video renderer for channel: " << channel_id;
-      bool ok = peer_connection_->SetVideoRenderer(channel_id,
-          main_wnd_->handle(), 1, 0.0f, 0.0f, 1.0f, 1.0f);
+      if (!remote_renderer_.get()) {
+          remote_renderer_.reset(
+              cricket::VideoRendererFactory::CreateGuiVideoRenderer(352, 288));
+      }
+      bool ok = peer_connection_->SetVideoRenderer(stream_id,
+                                                   remote_renderer_.get());
       ASSERT(ok);
     } else {
       ASSERT(audio_channel_ == -1);
@@ -774,7 +788,6 @@
       LOG(INFO) << "PEER_CONNECTION_CLOSED";
       DeletePeerConnection();
       ::InvalidateRect(main_wnd_->handle(), NULL, TRUE);
-      handshake_ = NONE;
       waiting_for_audio_ = false;
       waiting_for_video_ = false;
       peer_id_ = -1;
@@ -790,7 +803,12 @@
         DisconnectFromServer();
       }
     } else if (msg == SEND_MESSAGE_TO_PEER) {
-      client_->SendToPeer(peer_id_, *reinterpret_cast<std::string*>(lp));
+      bool ok = client_->SendToPeer(peer_id_,
+                                    *reinterpret_cast<std::string*>(lp));
+      if (!ok) {
+        LOG(LS_ERROR) << "SendToPeer failed";
+        DisconnectFromServer();
+      }
     } else {
       ret = false;
     }
@@ -808,6 +826,8 @@
   MainWnd* main_wnd_;
   int video_channel_;
   int audio_channel_;
+  scoped_ptr<cricket::VideoRenderer> local_renderer_;
+  scoped_ptr<cricket::VideoRenderer> remote_renderer_;
 };
 
 int PASCAL wWinMain(HINSTANCE instance, HINSTANCE prev_instance,
diff --git a/third_party_mods/libjingle/source/talk/app/videoengine.h b/third_party_mods/libjingle/source/talk/app/videoengine.h
index aa7fb62..3b724bb 100644
--- a/third_party_mods/libjingle/source/talk/app/videoengine.h
+++ b/third_party_mods/libjingle/source/talk/app/videoengine.h
@@ -31,6 +31,7 @@
 
 #include "talk/base/common.h"
 #include "common_types.h"
+#include "modules/interface/module_common_types.h"
 #include "video_engine/main/interface/vie_base.h"
 #include "video_engine/main/interface/vie_capture.h"
 #include "video_engine/main/interface/vie_codec.h"
diff --git a/third_party_mods/libjingle/source/talk/app/videomediaengine.cc b/third_party_mods/libjingle/source/talk/app/videomediaengine.cc
index dd5bdde..95387bf 100644
--- a/third_party_mods/libjingle/source/talk/app/videomediaengine.cc
+++ b/third_party_mods/libjingle/source/talk/app/videomediaengine.cc
@@ -14,6 +14,7 @@
 #include "talk/app/voicemediaengine.h"
 
 #include "modules/video_capture/main/interface/video_capture.h"
+#include "vplib.h"
 
 #ifndef ARRAYSIZE
 #define ARRAYSIZE(a)  (sizeof(a) / sizeof((a)[0]))
@@ -25,6 +26,213 @@
 static const int kStartVideoBitrate = 300;
 static const int kMaxVideoBitrate = 1000;
 
+CricketWebRTCVideoFrame::CricketWebRTCVideoFrame() {
+}
+
+CricketWebRTCVideoFrame::~CricketWebRTCVideoFrame() {
+  // TODO(ronghuawu): should the CricketWebRTCVideoFrame owns the buffer?
+  WebRtc_UWord8* newMemory = NULL;
+  WebRtc_UWord32 newLength = 0;
+  WebRtc_UWord32 newSize = 0;
+  video_frame_.Swap(newMemory, newLength, newSize);
+}
+
+void CricketWebRTCVideoFrame::Attach(unsigned char* buffer, int bufferSize,
+                                     int w, int h) {
+  WebRtc_UWord8* newMemory = buffer;
+  WebRtc_UWord32 newLength = bufferSize;
+  WebRtc_UWord32 newSize = bufferSize;
+  video_frame_.Swap(newMemory, newLength, newSize);
+  video_frame_.SetWidth(w);
+  video_frame_.SetHeight(h);
+}
+
+size_t CricketWebRTCVideoFrame::GetWidth() const { 
+  return video_frame_.Width();
+}
+size_t CricketWebRTCVideoFrame::GetHeight() const { 
+  return video_frame_.Height();
+}
+
+const uint8* CricketWebRTCVideoFrame::GetYPlane() const {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  return buffer;
+}
+
+const uint8* CricketWebRTCVideoFrame::GetUPlane() const {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  if (buffer)
+    buffer += (video_frame_.Width() * video_frame_.Height());
+  return buffer;
+}
+
+const uint8* CricketWebRTCVideoFrame::GetVPlane() const {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  if (buffer)
+    buffer += (video_frame_.Width() * video_frame_.Height() * 5 / 4);
+  return buffer;
+}
+
+uint8* CricketWebRTCVideoFrame::GetYPlane() {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  return buffer;
+}
+
+uint8* CricketWebRTCVideoFrame::GetUPlane() {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  if (buffer)
+    buffer += (video_frame_.Width() * video_frame_.Height());
+  return buffer;
+}
+
+uint8* CricketWebRTCVideoFrame::GetVPlane() {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  if (buffer)
+    buffer += (video_frame_.Width() * video_frame_.Height() * 3 / 2);
+  return buffer;
+}
+
+cricket::VideoFrame* CricketWebRTCVideoFrame::Copy() const {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  if (buffer) {
+    int new_buffer_size = video_frame_.Length();
+    unsigned char* new_buffer = new unsigned char[new_buffer_size];
+    memcpy(new_buffer, buffer, new_buffer_size);
+    CricketWebRTCVideoFrame* copy = new CricketWebRTCVideoFrame();
+    copy->Attach(new_buffer, new_buffer_size,
+                 video_frame_.Width(), video_frame_.Height());
+    copy->SetTimeStamp(video_frame_.TimeStamp());
+    copy->SetElapsedTime(elapsed_time_);
+    return copy;
+  }
+  return NULL;
+}
+
+size_t CricketWebRTCVideoFrame::CopyToBuffer(
+    uint8* buffer, size_t size) const {
+  if (!video_frame_.Buffer()) {
+    return 0;
+  }
+
+  size_t needed = video_frame_.Length();
+  if (needed <= size) {
+    memcpy(buffer, video_frame_.Buffer(), needed);
+  }
+  return needed;
+}
+
+size_t CricketWebRTCVideoFrame::ConvertToRgbBuffer(uint32 to_fourcc,
+                                                   uint8* buffer,
+                                                   size_t size,
+                                                   size_t pitch_rgb) const {
+  if (!video_frame_.Buffer()) {
+    return 0;
+  }
+
+  size_t width = video_frame_.Width();
+  size_t height = video_frame_.Height();
+  // See http://www.virtualdub.org/blog/pivot/entry.php?id=190 for a good
+  // explanation of pitch and why this is the amount of space we need.
+  size_t needed = pitch_rgb * (height - 1) + 4 * width;
+
+  if (needed > size) {
+    LOG(LS_WARNING) << "RGB buffer is not large enough";
+    return needed;
+  }
+
+  VideoType outgoingVideoType = kUnknown;
+  switch (to_fourcc) {
+    case cricket::FOURCC_ARGB:
+      outgoingVideoType = kARGB;
+      break;
+    default:
+      LOG(LS_WARNING) << "RGB type not supported: " << to_fourcc;
+      break;
+  }
+
+  if (outgoingVideoType != kUnknown)
+    ConvertFromI420(outgoingVideoType, video_frame_.Buffer(),
+                    width, height, buffer);
+
+  return needed;
+}
+
+// TODO(ronghuawu): Implement StretchToPlanes
+void CricketWebRTCVideoFrame::StretchToPlanes(
+    uint8* y, uint8* u, uint8* v,
+    int32 dst_pitch_y, int32 dst_pitch_u, int32 dst_pitch_v,
+    size_t width, size_t height, bool interpolate, bool crop) const {
+}
+
+size_t CricketWebRTCVideoFrame::StretchToBuffer(size_t w, size_t h,
+                                                uint8* buffer, size_t size,
+                                                bool interpolate,
+                                                bool crop) const {
+  if (!video_frame_.Buffer()) {
+    return 0;
+  }
+
+  size_t needed = video_frame_.Length();
+
+  if (needed <= size) {
+    uint8* bufy = buffer;
+    uint8* bufu = bufy + w * h;
+    uint8* bufv = bufu + ((w + 1) >> 1) * ((h + 1) >> 1);
+    StretchToPlanes(bufy, bufu, bufv, w, (w + 1) >> 1, (w + 1) >> 1, w, h,
+                    interpolate, crop);
+  }
+  return needed;
+}
+
+void CricketWebRTCVideoFrame::StretchToFrame(cricket::VideoFrame *target,
+                                             bool interpolate, bool crop) const {
+  if (!target) return;
+
+  StretchToPlanes(target->GetYPlane(),
+                  target->GetUPlane(),
+                  target->GetVPlane(),
+                  target->GetYPitch(),
+                  target->GetUPitch(),
+                  target->GetVPitch(),
+                  target->GetWidth(),
+                  target->GetHeight(),
+                  interpolate, crop);
+  target->SetElapsedTime(GetElapsedTime());
+  target->SetTimeStamp(GetTimeStamp());
+}
+
+cricket::VideoFrame* CricketWebRTCVideoFrame::Stretch(size_t w, size_t h,
+                                                      bool interpolate, bool crop) const {
+  // TODO(ronghuawu): implement
+  CricketWebRTCVideoFrame* frame = new CricketWebRTCVideoFrame();
+  return frame;
+}
+
+CricketWebRTCVideoRenderer::CricketWebRTCVideoRenderer
+    (cricket::VideoRenderer* renderer)
+  :renderer_(renderer) {
+}
+
+CricketWebRTCVideoRenderer::~CricketWebRTCVideoRenderer() {
+}
+
+int CricketWebRTCVideoRenderer::FrameSizeChange(unsigned int width,
+                                                unsigned int height,
+                                                unsigned int numberOfStreams) {
+  ASSERT(renderer_ != NULL);
+  width_ = width;
+  height_ = height;
+  number_of_streams_ = numberOfStreams;
+  return renderer_->SetSize(width_, height_, 0) ? 0 : -1;
+}
+
+int CricketWebRTCVideoRenderer::DeliverFrame(unsigned char* buffer,
+                                             int bufferSize) {
+  ASSERT(renderer_ != NULL);
+  video_frame_.Attach(buffer, bufferSize, width_, height_);
+  return renderer_->RenderFrame(&video_frame_) ? 0 : -1;
+}
+
 const RtcVideoEngine::VideoCodecPref RtcVideoEngine::kVideoCodecPrefs[] = {
     {"VP8", 104, 0},
     {"H264", 105, 1}
@@ -231,29 +439,23 @@
   return (capture_id_ != -1);
 }
 
-bool RtcVideoEngine::SetVideoRenderer(int channel_id,
-                                      void* window,
-                                      unsigned int zOrder,
-                                      float left,
-                                      float top,
-                                      float right,
-                                      float bottom) {
-  int ret;
-  if (channel_id == -1)
-    channel_id = capture_id_;
-  ret = video_engine_->render()->AddRenderer(
-      channel_id, window, zOrder, left, top, right, bottom);
-  if (ret !=0 )
-    return false;
-  ret = video_engine_->render()->StartRender(channel_id);
-  if (ret !=0 )
-      return false;
-  return true;
-}
-
 bool RtcVideoEngine::SetLocalRenderer(cricket::VideoRenderer* renderer) {
-  LOG(LS_WARNING) << "Not required call SetLocalRenderer for webrtc";
-  return false;
+  if (!local_renderer_.get()) {
+    local_renderer_.reset(new CricketWebRTCVideoRenderer(renderer));
+  } else {
+    // Renderer already set
+    return true;
+  }
+
+  int ret;
+  ret = video_engine_->render()->AddRenderer(capture_id_,
+                                             kVideoI420,
+                                             local_renderer_.get());
+  if (ret != 0)
+    return false;
+  ret = video_engine_->render()->StartRender(capture_id_);
+
+  return (ret == 0);
 }
 
 cricket::CaptureResult RtcVideoEngine::SetCapture(bool capture) {
@@ -565,7 +767,22 @@
 
 bool RtcVideoMediaChannel::SetRenderer(
     uint32 ssrc, cricket::VideoRenderer* renderer) {
-  return false;
+  if (!remote_renderer_.get()) {
+    remote_renderer_.reset(new CricketWebRTCVideoRenderer(renderer));
+  } else {
+    // Renderer already set
+    return true;
+  }
+
+  int ret;
+  ret = engine_->video_engine()->render()->AddRenderer(video_channel_,
+                                                       kVideoI420,
+                                                       remote_renderer_.get());
+  if (ret != 0)
+    return false;
+  ret = engine_->video_engine()->render()->StartRender(video_channel_);
+
+  return (ret == 0);
 }
 
 bool RtcVideoMediaChannel::SetExternalRenderer(uint32 ssrc, void* renderer)
@@ -575,12 +792,11 @@
       video_channel_,
       kVideoI420,
       static_cast<ExternalRenderer*>(renderer));
-  if (ret !=0 )
+  if (ret != 0)
     return false;
   ret = engine_->video_engine()->render()->StartRender(video_channel_);
-  if (ret !=0 )
-      return false;
-  return true;
+
+  return (ret == 0);
 }
 
 bool RtcVideoMediaChannel::GetStats(cricket::VideoMediaInfo* info) {
diff --git a/third_party_mods/libjingle/source/talk/app/videomediaengine.h b/third_party_mods/libjingle/source/talk/app/videomediaengine.h
index a5e9fce..4fdb629 100644
--- a/third_party_mods/libjingle/source/talk/app/videomediaengine.h
+++ b/third_party_mods/libjingle/source/talk/app/videomediaengine.h
@@ -49,6 +49,74 @@
 class RtcVoiceEngine;
 class ExternalRenderer;
 
+// CricketWebRTCVideoFrame only supports I420
+class CricketWebRTCVideoFrame : public cricket::VideoFrame {
+ public:
+  CricketWebRTCVideoFrame();
+  ~CricketWebRTCVideoFrame();
+
+  void Attach(unsigned char* buffer, int bufferSize, int w, int h);
+
+  virtual size_t GetWidth() const;
+  virtual size_t GetHeight() const;
+  virtual const uint8* GetYPlane() const;
+  virtual const uint8* GetUPlane() const;
+  virtual const uint8* GetVPlane() const;
+  virtual uint8* GetYPlane();
+  virtual uint8* GetUPlane();
+  virtual uint8* GetVPlane();
+  virtual int32 GetYPitch() const { return video_frame_.Width(); }
+  virtual int32 GetUPitch() const { return video_frame_.Width() / 2; }
+  virtual int32 GetVPitch() const { return video_frame_.Width() / 2; }
+
+  virtual size_t GetPixelWidth() const { return 1; }
+  virtual size_t GetPixelHeight() const { return 1; }
+  virtual int64 GetElapsedTime() const { return elapsed_time_; }
+  virtual int64 GetTimeStamp() const { return video_frame_.TimeStamp(); }
+  virtual void SetElapsedTime(int64 elapsed_time) {
+    elapsed_time_ = elapsed_time;
+  }
+  virtual void SetTimeStamp(int64 time_stamp) {
+    video_frame_.SetTimeStamp(time_stamp);
+  }
+
+  virtual VideoFrame* Copy() const;
+  virtual size_t CopyToBuffer(uint8* buffer, size_t size) const;
+  virtual size_t ConvertToRgbBuffer(uint32 to_fourcc, uint8* buffer,
+                                    size_t size, size_t pitch_rgb) const;
+  virtual void StretchToPlanes(uint8* y, uint8* u, uint8* v,
+                               int32 pitchY, int32 pitchU, int32 pitchV,
+                               size_t width, size_t height,
+                               bool interpolate, bool crop) const;
+  virtual size_t StretchToBuffer(size_t w, size_t h, uint8* buffer, size_t size,
+                                 bool interpolate, bool crop) const;
+  virtual void StretchToFrame(VideoFrame* target, bool interpolate,
+                              bool crop) const;
+  virtual VideoFrame* Stretch(size_t w, size_t h, bool interpolate,
+                              bool crop) const;
+
+ private:
+  webrtc::VideoFrame video_frame_;
+  int64 elapsed_time_;
+};
+
+class CricketWebRTCVideoRenderer : public ExternalRenderer {
+ public:
+  CricketWebRTCVideoRenderer(cricket::VideoRenderer* renderer);
+
+  virtual int FrameSizeChange(unsigned int width, unsigned int height,
+                              unsigned int numberOfStreams);
+  virtual int DeliverFrame(unsigned char* buffer, int bufferSize);
+  virtual ~CricketWebRTCVideoRenderer();
+
+ private:
+  cricket::VideoRenderer*  renderer_;
+  CricketWebRTCVideoFrame  video_frame_;
+  unsigned int width_;
+  unsigned int height_;
+  unsigned int number_of_streams_;
+};
+
 class RtcVideoEngine : public ViEBaseObserver, public TraceCallback {
  public:
   RtcVideoEngine();
@@ -72,13 +140,6 @@
   bool SetOptions(int options);
   //TODO - need to change this interface for webrtc
   bool SetCaptureDevice(const cricket::Device* device);
-  bool SetVideoRenderer(int channel_id,
-                        void* window,
-                        unsigned int zOrder,
-                        float left,
-                        float top,
-                        float right,
-                        float bottom);
   bool SetLocalRenderer(cricket::VideoRenderer* renderer);
   cricket::CaptureResult SetCapture(bool capture);
   const std::vector<cricket::VideoCodec>& codecs() const;
@@ -133,6 +194,7 @@
   cricket::VideoEncoderConfig default_encoder_config_;
   cricket::VideoCodec default_codec_;
   bool capture_started_;
+  talk_base::scoped_ptr<CricketWebRTCVideoRenderer> local_renderer_;
 };
 
 class RtcVideoMediaChannel: public cricket::VideoMediaChannel,
@@ -188,6 +250,7 @@
   bool sending_;
   bool render_started_;
   webrtc::VideoCodec send_codec_;
+  talk_base::scoped_ptr<CricketWebRTCVideoRenderer> remote_renderer_;
 };
 
 }
diff --git a/third_party_mods/libjingle/source/talk/app/webrtcchannelmanager.cc b/third_party_mods/libjingle/source/talk/app/webrtcchannelmanager.cc
deleted file mode 100644
index 8b624fd..0000000
--- a/third_party_mods/libjingle/source/talk/app/webrtcchannelmanager.cc
+++ /dev/null
@@ -1,137 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-// Author: mallinath@google.com (Mallinath Bareddy)
-
-#include "talk/app/webrtcchannelmanager.h"
-
-namespace webrtc {
-
-struct VideoCaptureDeviceParams : public talk_base::MessageData {
-  VideoCaptureDeviceParams(const std::string& cam_device)
-      : cam_device(cam_device),
-        result(false) {}
-  const std::string cam_device;
-  bool result;
-};
-
-struct RenderParams : public talk_base::MessageData {
-  RenderParams(int channel_id,
-               void* window,
-               unsigned int zOrder,
-               float left,
-               float top,
-               float right,
-               float bottom)
-  :channel_id(channel_id)
-  ,window(window)
-  ,zOrder(zOrder)
-  ,left(left)
-  ,top(top)
-  ,right(right)
-  ,bottom(bottom) {}
-
-  int channel_id;
-  void* window;
-  unsigned int zOrder;
-  float left;
-  float top;
-  float right;
-  float bottom;
-  bool result;
-};
-
-bool WebRtcChannelManager::Init() {
-  return MaybeInit();
-}
-
-cricket::VoiceChannel* WebRtcChannelManager::CreateVoiceChannel(
-    cricket::BaseSession* s, const std::string& content_name, bool rtcp) {
-  return (MaybeInit()) ?
-      ChannelManager::CreateVoiceChannel(s, content_name, rtcp) : NULL;
-}
-
-cricket::VideoChannel* WebRtcChannelManager::CreateVideoChannel(
-    cricket::BaseSession* s, const std::string& content_name, bool rtcp,
-    cricket::VoiceChannel* vc) {
-  return (MaybeInit()) ?
-      ChannelManager::CreateVideoChannel(s, content_name, rtcp, vc) : NULL;
-
-}
-
-cricket::Soundclip* WebRtcChannelManager::CreateSoundclip() {
-  return (MaybeInit()) ? ChannelManager::CreateSoundclip() : NULL;
-}
-void WebRtcChannelManager::DestroyVoiceChannel(cricket::VoiceChannel* vc) {
-  ChannelManager::DestroyVoiceChannel(vc);
-  MaybeTerm();
-}
-void WebRtcChannelManager::DestroyVideoChannel(cricket::VideoChannel* vc) {
-  ChannelManager::DestroyVideoChannel(vc);
-  MaybeTerm();
-}
-void WebRtcChannelManager::DestroySoundclip(cricket::Soundclip* s) {
-  ChannelManager::DestroySoundclip(s);
-  MaybeTerm();
-}
-
-bool WebRtcChannelManager::MaybeInit() {
-  bool ret = initialized();
-  if (!ret) {
-    ret = ChannelManager::Init();
-  }
-  return ret;
-}
-
-void WebRtcChannelManager::MaybeTerm() {
-  if (initialized() && !has_channels()) {
-    Terminate();
-  }
-}
-
-bool WebRtcChannelManager::SetVideoRenderer(int channel_id,
-                                            void* window,
-                                            unsigned int zOrder,
-                                            float left,
-                                            float top,
-                                            float right,
-                                            float bottom) {
-  if (MaybeInit()) {
-    RenderParams params(channel_id, window, zOrder, left, top, right, bottom);
-    return cricket::ChannelManager::Send(MSG_SETRTC_VIDEORENDERER, &params);
-  } else {
-    return false;
-  }
-}
-
-void WebRtcChannelManager::SetVideoRenderer_w(int channel_id,
-                                              void* window,
-                                              unsigned int zOrder,
-                                              float left,
-                                              float top,
-                                              float right,
-                                              float bottom) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
-  ASSERT(initialized());
-  media_engine()->SetVideoRenderer(channel_id, window, zOrder, left, top, right, bottom);
-}
-
-void WebRtcChannelManager::OnMessage(talk_base::Message *message) {
-  talk_base::MessageData* data = message->pdata;
-  switch(message->message_id) {
-    case MSG_SETRTC_VIDEORENDERER: {
-      RenderParams* p = static_cast<RenderParams*>(data);
-      SetVideoRenderer_w(p->channel_id,
-                         p->window,
-                         p->zOrder,
-                         p->left,
-                         p->top,
-                         p->right,
-                         p->bottom);
-      break;
-    }
-    default: {
-      ChannelManager::OnMessage(message);
-    }
-  }
-}
-
-} // namespace webrtc
diff --git a/third_party_mods/libjingle/source/talk/app/webrtcchannelmanager.h b/third_party_mods/libjingle/source/talk/app/webrtcchannelmanager.h
deleted file mode 100644
index b8f15a8..0000000
--- a/third_party_mods/libjingle/source/talk/app/webrtcchannelmanager.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-// Author: mallinath@google.com (Mallinath Bareddy)
-
-
-#ifndef TALK_APP_WEBRTC_WEBRTCCHANNELMANAGER_H_
-#define TALK_APP_WEBRTC_WEBRTCCHANNELMANAGER_H_
-
-#include "talk/session/phone/channelmanager.h"
-
-namespace webrtc {
-
-class AudioDeviceModule;
-
-enum {
-  MSG_SETRTC_VIDEORENDERER = 21, // Set internal video renderer
-};
-
-// WebRtcChannelManager automatically takes care of initialization and
-// cricket::ChannelManager. Terminates when not needed
-
-class WebRtcChannelManager : public cricket::ChannelManager {
- public:
-  WebRtcChannelManager(talk_base::Thread* worker_thread)
-      : ChannelManager(worker_thread) {
-  }
-
-  WebRtcChannelManager(cricket::MediaEngine* me, cricket::DeviceManager* dm,
-                       talk_base::Thread* worker_thread)
-      : ChannelManager(me, dm, worker_thread) {
-  }
-
-  bool Init();
-  cricket::VoiceChannel* CreateVoiceChannel(
-      cricket::BaseSession* s, const std::string& content_name, bool rtcp);
-  cricket::VideoChannel* CreateVideoChannel(
-      cricket::BaseSession* s, const std::string& content_name, bool rtcp,
-      cricket::VoiceChannel* vc);
-  cricket::Soundclip* CreateSoundclip();
-  void DestroyVoiceChannel(cricket::VoiceChannel* vc);
-  void DestroyVideoChannel(cricket::VideoChannel* vc);
-  void DestroySoundclip(cricket::Soundclip* s);
-
-  bool SetVideoRenderer(int channel_id,
-                        void* window,
-                        unsigned int zOrder,
-                        float left,
-                        float top,
-                        float right,
-                        float bottom);
-
- private:
-  bool MaybeInit();
-  void MaybeTerm();
-  void SetExternalAdm_w(AudioDeviceModule* external_adm);
-  void SetVideoRenderer_w(int channel_id,
-                          void* window,
-                          unsigned int zOrder,
-                          float left,
-                          float top,
-                          float right,
-                          float bottom);
-  void OnMessage(talk_base::Message *message);
-};
-
-} // namespace webrtc
-
-
-#endif /* TALK_APP_WEBRTC_WEBRTCCHANNELMANAGER_H_ */
diff --git a/third_party_mods/libjingle/source/talk/app/webrtcsessionimpl.cc b/third_party_mods/libjingle/source/talk/app/webrtcsessionimpl.cc
index 7c916c9..f71f6aa 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtcsessionimpl.cc
+++ b/third_party_mods/libjingle/source/talk/app/webrtcsessionimpl.cc
@@ -29,20 +29,19 @@
 #include <string>
 #include <vector>
 
+#include "talk/app/pc_transport_impl.h"
+#include "talk/app/peerconnection.h"
+#include "talk/app/webrtc_json.h"
 #include "talk/base/common.h"
 #include "talk/base/json.h"
 #include "talk/base/scoped_ptr.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/sessiondescription.h"
 #include "talk/p2p/base/p2ptransport.h"
-#include "talk/session/phone/mediasessionclient.h"
 #include "talk/session/phone/channel.h"
-#include "talk/session/phone/voicechannel.h"
 #include "talk/session/phone/channelmanager.h"
-#include "talk/app/webrtc_json.h"
-#include "talk/app/webrtcchannelmanager.h"
-#include "talk/app/peerconnection.h"
-#include "talk/app/pc_transport_impl.h"
+#include "talk/session/phone/mediasessionclient.h"
+#include "talk/session/phone/voicechannel.h"
 
 using namespace cricket;
 
@@ -55,7 +54,7 @@
   MSG_RTC_SETVIDEOCAPTURE = 4,
   MSG_RTC_CANDIDATETIMEOUT = 5,
   MSG_RTC_SETEXTERNALRENDERER = 6,
-  MSG_RTC_SETRENDERER = 7,
+  MSG_RTC_SETCRICKETRENDERER = 7,
   MSG_RTC_CHANNELENABLE = 8,
   MSG_RTC_SIGNALONWRITABLESTATE = 9,
   MSG_RTC_DESTROYVOICECHANNEL = 10,
@@ -107,29 +106,15 @@
   bool result;
 };
 
-struct RenderParams : public talk_base::MessageData {
-  RenderParams(int channel_id,
-               void* window,
-               unsigned int zOrder,
-               float left,
-               float top,
-               float right,
-               float bottom)
-  :channel_id(channel_id)
-  ,window(window)
-  ,zOrder(zOrder)
-  ,left(left)
-  ,top(top)
-  ,right(right)
-  ,bottom(bottom) {}
+struct CricketRenderParams : public talk_base::MessageData {
+  CricketRenderParams(const std::string& stream_id,
+                      cricket::VideoRenderer* renderer)
+      : stream_id(stream_id),
+        renderer(renderer),
+        result(false) {}
 
-  int channel_id;
-  void* window;
-  unsigned int zOrder;
-  float left;
-  float top;
-  float right;
-  float bottom;
+  const std::string stream_id;
+  cricket::VideoRenderer* renderer;
   bool result;
 };
 
@@ -159,7 +144,7 @@
     const std::string& id,
     const std::string& direction,
     cricket::PortAllocator* allocator,
-    WebRtcChannelManager* channelmgr,
+    cricket::ChannelManager* channelmgr,
     PeerConnection* connection,
     talk_base::Thread* signaling_thread)
   : WebRTCSession(id, direction, allocator, connection, signaling_thread),
@@ -203,7 +188,7 @@
       this, &WebRTCSessionImpl::OnVoiceChannelCreated);
 
   signaling_thread_->Post(this, MSG_RTC_CREATEAUDIOCHANNEL,
-                          new CreateChannelParams(stream_id, false, NULL));
+                          new CreateChannelParams(stream_id, true, NULL));
   return true;
 }
 
@@ -255,7 +240,7 @@
       this, &WebRTCSessionImpl::OnVideoChannelCreated);
 
   signaling_thread_->Post(this, MSG_RTC_CREATEVIDEOCHANNEL,
-                          new CreateChannelParams(stream_id, false, NULL));
+                          new CreateChannelParams(stream_id, true, NULL));
   return true;
 }
 
@@ -304,6 +289,33 @@
 }
 
 bool WebRTCSessionImpl::SetVideoRenderer(const std::string& stream_id,
+    cricket::VideoRenderer* renderer) {
+  if(signaling_thread_ != talk_base::Thread::Current()) {
+    signaling_thread_->Post(this, MSG_RTC_SETCRICKETRENDERER,
+                            new CricketRenderParams(stream_id, renderer),
+                            true);
+    return true;
+  }
+
+  ASSERT(signaling_thread_ == talk_base::Thread::Current());
+
+  bool ret = false;
+  StreamMap::iterator iter;
+  for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
+    StreamInfo* stream_info = (*iter);
+    if (stream_info->stream_id.compare(stream_id) == 0) {
+      ASSERT(stream_info->channel != NULL);
+      ASSERT(stream_info->video);
+      cricket::VideoChannel* channel = static_cast<cricket::VideoChannel*>(
+          stream_info->channel);
+      ret = channel->SetRenderer(0, renderer);
+      break;
+    }
+  }
+  return ret;
+}
+
+bool WebRTCSessionImpl::SetVideoRenderer(const std::string& stream_id,
     ExternalRenderer* external_renderer) {
   if(signaling_thread_ != talk_base::Thread::Current()) {
     signaling_thread_->Post(this, MSG_RTC_SETEXTERNALRENDERER,
@@ -330,30 +342,6 @@
   return ret;
 }
 
-bool WebRTCSessionImpl::SetVideoRenderer(int channel_id,
-                                         void* window,
-                                         unsigned int zOrder,
-                                         float left,
-                                         float top,
-                                         float right,
-                                         float bottom) {
-  signaling_thread_->Post(this, MSG_RTC_SETRENDERER,
-                          new RenderParams(channel_id, window, zOrder, left, top, right, bottom),
-                          true);
-  return true;
-}
-
-bool WebRTCSessionImpl::SetVideoRenderer_w(int channel_id,
-                                           void* window,
-                                           unsigned int zOrder,
-                                           float left,
-                                           float top,
-                                           float right,
-                                           float bottom) {
-  ASSERT(signaling_thread_ == talk_base::Thread::Current());
-  return channel_manager_->SetVideoRenderer(channel_id, window, zOrder, left, top, right, bottom);
-}
-
 void WebRTCSessionImpl::OnMessage(talk_base::Message* message) {
   using talk_base::TypedMessageData;
   talk_base::MessageData* data = message->pdata;
@@ -420,31 +408,25 @@
       break;
     }
     case MSG_RTC_SETVIDEOCAPTURE : {
-      CaptureParams* p = static_cast<CaptureParams*>(data);
+      CaptureParams* p = reinterpret_cast<CaptureParams*>(data);
       p->result = SetVideoCapture_w(p->capture);
       delete p;
       break;
     }
     case MSG_RTC_SETEXTERNALRENDERER : {
-      ExternalRenderParams* p = static_cast<ExternalRenderParams*> (data);
+      ExternalRenderParams* p = reinterpret_cast<ExternalRenderParams*>(data);
       p->result = SetVideoRenderer(p->stream_id, p->external_renderer);
       delete p;
       break;
     }
-    case MSG_RTC_SETRENDERER : {
-      RenderParams* p = static_cast<RenderParams*> (data);
-      p->result = SetVideoRenderer_w(p->channel_id,
-                                     p->window,
-                                     p->zOrder,
-                                     p->left,
-                                     p->top,
-                                     p->right,
-                                     p->bottom);
+    case MSG_RTC_SETCRICKETRENDERER : {
+      CricketRenderParams* p = reinterpret_cast<CricketRenderParams*>(data);
+      p->result = SetVideoRenderer(p->stream_id, p->renderer);
       delete p;
       break;
     }
     case MSG_RTC_CHANNELENABLE : {
-      ChannelEnableParams* p = static_cast<ChannelEnableParams*> (data);
+      ChannelEnableParams* p = reinterpret_cast<ChannelEnableParams*>(data);
       ChannelEnable_w(p->channel, p->enable);
       delete p;
       break;
@@ -707,8 +689,6 @@
       break;
     }
   }
-
-  ASSERT(found);
 }
 
 void WebRTCSessionImpl::DestroyVoiceChannel_w(
diff --git a/third_party_mods/libjingle/source/talk/app/webrtcsessionimpl.h b/third_party_mods/libjingle/source/talk/app/webrtcsessionimpl.h
index 20a141a..95db057 100644
--- a/third_party_mods/libjingle/source/talk/app/webrtcsessionimpl.h
+++ b/third_party_mods/libjingle/source/talk/app/webrtcsessionimpl.h
@@ -79,7 +79,6 @@
 
 class ExternalRenderer;
 class PeerConnection;
-class WebRtcChannelManager;
 
 class WebRTCSessionImpl: public WebRTCSession {
 
@@ -88,7 +87,7 @@
   WebRTCSessionImpl(const std::string& id,
                     const std::string& direction,
                     cricket::PortAllocator* allocator,
-                    WebRtcChannelManager* channelmgr,
+                    cricket::ChannelManager* channelmgr,
                     PeerConnection* connection,
                     talk_base::Thread* signaling_thread);
 
@@ -131,14 +130,10 @@
                      cricket::TransportChannel* channel);
   void OnMessageReceived(const char* data, size_t data_size);
   bool SetVideoRenderer(const std::string& stream_id,
+                        cricket::VideoRenderer* renderer);
+  bool SetVideoRenderer(const std::string& stream_id,
                         ExternalRenderer* external_renderer);
-  bool SetVideoRenderer(int channel_id,
-                        void* window,
-                        unsigned int zOrder,
-                        float left,
-                        float top,
-                        float right,
-                        float bottom);
+
   sigslot::signal2<cricket::VideoChannel*, std::string&> SignalVideoChannel;
   sigslot::signal2<cricket::VoiceChannel*, std::string&> SignalVoiceChannel;
   sigslot::signal1<WebRTCSessionImpl*> SignalOnRemoveStream;
@@ -155,13 +150,6 @@
   }
 
  private:
-  bool SetVideoRenderer_w(int channel_id,
-                          void* window,
-                          unsigned int zOrder,
-                          float left,
-                          float top,
-                          float right,
-                          float bottom);
   void ChannelEnable_w(cricket::BaseChannel* channel, bool enable);
 
   void OnVoiceChannelError(cricket::VoiceChannel* voice_channel, uint32 ssrc,
@@ -232,7 +220,7 @@
 
   void SendLocalDescription_w();
 
-  WebRtcChannelManager* channel_manager_;
+  cricket::ChannelManager* channel_manager_;
   std::vector<StreamInfo*> streams_;
   TransportChannelMap transport_channels_;
   bool all_writable_;
diff --git a/third_party_mods/libjingle/source/talk/session/phone/channelmanager.cc b/third_party_mods/libjingle/source/talk/session/phone/channelmanager.cc
deleted file mode 100644
index 1c76f02..0000000
--- a/third_party_mods/libjingle/source/talk/session/phone/channelmanager.cc
+++ /dev/null
@@ -1,798 +0,0 @@
-/*
- * libjingle
- * Copyright 2004--2008, Google Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  1. Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *  2. Redistributions in binary form must reproduce the above copyright notice,
- *     this list of conditions and the following disclaimer in the documentation
- *     and/or other materials provided with the distribution.
- *  3. The name of the author may not be used to endorse or promote products
- *     derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "talk/session/phone/channelmanager.h"
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <algorithm>
-
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/sigslotrepeater.h"
-#include "talk/base/stringencode.h"
-#include "talk/session/phone/mediaengine.h"
-#include "talk/session/phone/soundclip.h"
-
-namespace cricket {
-
-enum {
-  MSG_CREATEVOICECHANNEL = 1,
-  MSG_DESTROYVOICECHANNEL = 2,
-  MSG_SETAUDIOOPTIONS = 3,
-  MSG_GETOUTPUTVOLUME = 4,
-  MSG_SETOUTPUTVOLUME = 5,
-  MSG_SETLOCALMONITOR = 6,
-  MSG_SETVOICELOGGING = 7,
-  MSG_CREATEVIDEOCHANNEL = 11,
-  MSG_DESTROYVIDEOCHANNEL = 12,
-  MSG_SETVIDEOOPTIONS = 13,
-  MSG_SETLOCALRENDERER = 14,
-  MSG_SETDEFAULTVIDEOENCODERCONFIG = 15,
-  MSG_SETVIDEOLOGGING = 16,
-  MSG_CREATESOUNDCLIP = 17,
-  MSG_DESTROYSOUNDCLIP = 18,
-  MSG_CAMERASTARTED = 19,
-  MSG_SETVIDEOCAPTURE = 20,
-};
-
-struct CreationParams : public talk_base::MessageData {
-  CreationParams(BaseSession* session, const std::string& content_name,
-                 bool rtcp, VoiceChannel* voice_channel)
-      : session(session),
-        content_name(content_name),
-        rtcp(rtcp),
-        voice_channel(voice_channel),
-        video_channel(NULL) {}
-  BaseSession* session;
-  std::string content_name;
-  bool rtcp;
-  VoiceChannel* voice_channel;
-  VideoChannel* video_channel;
-};
-
-struct AudioOptions : public talk_base::MessageData {
-  AudioOptions(int o, const Device* in, const Device* out)
-      : options(o), in_device(in), out_device(out) {}
-  int options;
-  const Device* in_device;
-  const Device* out_device;
-  bool result;
-};
-
-struct VolumeLevel : public talk_base::MessageData {
-  VolumeLevel() : level(-1), result(false) {}
-  explicit VolumeLevel(int l) : level(l), result(false) {}
-  int level;
-  bool result;
-};
-
-struct VideoOptions : public talk_base::MessageData {
-  explicit VideoOptions(const Device* d) : cam_device(d), result(false) {}
-  const Device* cam_device;
-  bool result;
-};
-
-struct DefaultVideoEncoderConfig : public talk_base::MessageData {
-  explicit DefaultVideoEncoderConfig(const VideoEncoderConfig& c)
-      : config(c), result(false) {}
-  VideoEncoderConfig config;
-  bool result;
-};
-
-struct LocalMonitor : public talk_base::MessageData {
-  explicit LocalMonitor(bool e) : enable(e), result(false) {}
-  bool enable;
-  bool result;
-};
-
-struct LocalRenderer : public talk_base::MessageData {
-  explicit LocalRenderer(VideoRenderer* r) : renderer(r), result(false) {}
-  VideoRenderer* renderer;
-  bool result;
-};
-
-struct LoggingOptions : public talk_base::MessageData {
-  explicit LoggingOptions(int lev, const char* f) : level(lev), filter(f) {}
-  int level;
-  std::string filter;
-};
-
-struct CaptureParams : public talk_base::MessageData {
-  explicit CaptureParams(bool c) : capture(c), result(CR_FAILURE) {}
-
-  bool capture;
-  CaptureResult result;
-};
-
-ChannelManager::ChannelManager(talk_base::Thread* worker_thread)
-    : media_engine_(MediaEngine::Create()),
-      device_manager_(new DeviceManager()),
-      initialized_(false),
-      main_thread_(talk_base::Thread::Current()),
-      worker_thread_(worker_thread),
-      audio_in_device_(DeviceManager::kDefaultDeviceName),
-      audio_out_device_(DeviceManager::kDefaultDeviceName),
-      audio_options_(MediaEngine::DEFAULT_AUDIO_OPTIONS),
-      local_renderer_(NULL),
-      capturing_(false),
-      monitoring_(false) {
-  Construct();
-}
-
-ChannelManager::ChannelManager(MediaEngine* me, DeviceManager* dm,
-                               talk_base::Thread* worker_thread)
-    : media_engine_(me),
-      device_manager_(dm),
-      initialized_(false),
-      main_thread_(talk_base::Thread::Current()),
-      worker_thread_(worker_thread),
-      audio_in_device_(DeviceManager::kDefaultDeviceName),
-      audio_out_device_(DeviceManager::kDefaultDeviceName),
-      audio_options_(MediaEngine::DEFAULT_AUDIO_OPTIONS),
-      local_renderer_(NULL),
-      capturing_(false),
-      monitoring_(false) {
-  Construct();
-}
-
-void ChannelManager::Construct() {
-  // Init the device manager immediately, and set up our default video device.
-  SignalDevicesChange.repeat(device_manager_->SignalDevicesChange);
-  device_manager_->Init();
-  // Set camera_device_ to the name of the default video capturer.
-  SetVideoOptions(DeviceManager::kDefaultDeviceName);
-
-  // Camera is started asynchronously, request callbacks when startup
-  // completes to be able to forward them to the rendering manager.
-  media_engine_->SignalVideoCaptureResult.connect(
-      this, &ChannelManager::OnVideoCaptureResult);
-}
-
-ChannelManager::~ChannelManager() {
-  if (initialized_)
-    Terminate();
-}
-
-int ChannelManager::GetCapabilities() {
-  return media_engine_->GetCapabilities() & device_manager_->GetCapabilities();
-}
-
-void ChannelManager::GetSupportedAudioCodecs(
-    std::vector<AudioCodec>* codecs) const {
-  codecs->clear();
-
-  for (std::vector<AudioCodec>::const_iterator it =
-           media_engine_->audio_codecs().begin();
-      it != media_engine_->audio_codecs().end(); ++it) {
-    codecs->push_back(*it);
-  }
-}
-
-void ChannelManager::GetSupportedVideoCodecs(
-    std::vector<VideoCodec>* codecs) const {
-  codecs->clear();
-
-  std::vector<VideoCodec>::const_iterator it;
-  for (it = media_engine_->video_codecs().begin();
-      it != media_engine_->video_codecs().end(); ++it) {
-    codecs->push_back(*it);
-  }
-}
-
-bool ChannelManager::Init() {
-  ASSERT(!initialized_);
-  if (initialized_) {
-    return false;
-  }
-
-  ASSERT(worker_thread_ != NULL);
-  if (worker_thread_ && worker_thread_->started()) {
-    if (media_engine_->Init()) {
-      initialized_ = true;
-      // Now that we're initialized, apply any stored preferences. A preferred
-      // device might have been unplugged. In this case, we fallback to the
-      // default device but keep the user preferences. The preferences are
-      // changed only when the Javascript FE changes them.
-      const std::string preferred_audio_in_device = audio_in_device_;
-      const std::string preferred_audio_out_device = audio_out_device_;
-      const std::string preferred_camera_device = camera_device_;
-      Device device;
-      if (!device_manager_->GetAudioInputDevice(audio_in_device_, &device)) {
-        LOG(LS_WARNING) << "The preferred microphone '" << audio_in_device_
-                        << "' is unavailable. Fall back to the default.";
-        audio_in_device_ = DeviceManager::kDefaultDeviceName;
-      }
-      if (!device_manager_->GetAudioOutputDevice(audio_out_device_, &device)) {
-        LOG(LS_WARNING) << "The preferred speaker '" << audio_out_device_
-                        << "' is unavailable. Fall back to the default.";
-        audio_out_device_ = DeviceManager::kDefaultDeviceName;
-      }
-      if (!device_manager_->GetVideoCaptureDevice(camera_device_, &device)) {
-        if (!camera_device_.empty()) {
-          LOG(LS_WARNING) << "The preferred camera '" << camera_device_
-                          << "' is unavailable. Fall back to the default.";
-        }
-        camera_device_ = DeviceManager::kDefaultDeviceName;
-      }
-
-      if (!SetAudioOptions(audio_in_device_, audio_out_device_,
-                           audio_options_)) {
-        LOG(LS_WARNING) << "Failed to SetAudioOptions with"
-                        << " microphone: " << audio_in_device_
-                        << " speaker: " << audio_out_device_
-                        << " options: " << audio_options_;
-      }
-      if (!SetVideoOptions(camera_device_) && !camera_device_.empty()) {
-        LOG(LS_WARNING) << "Failed to SetVideoOptions with camera: "
-                        << camera_device_;
-      }
-
-      // Restore the user preferences.
-      audio_in_device_ = preferred_audio_in_device;
-      audio_out_device_ = preferred_audio_out_device;
-      camera_device_ = preferred_camera_device;
-
-      // Now apply the default video codec that has been set earlier.
-      if (default_video_encoder_config_.max_codec.id != 0) {
-        SetDefaultVideoEncoderConfig(default_video_encoder_config_);
-      }
-      // And the local renderer.
-      if (local_renderer_) {
-        SetLocalRenderer(local_renderer_);
-      }
-    }
-
-  }
-  return initialized_;
-}
-
-void ChannelManager::Terminate() {
-  ASSERT(initialized_);
-  if (!initialized_) {
-    return;
-  }
-
-  // Need to destroy the voice/video channels
-  while (!video_channels_.empty()) {
-    DestroyVideoChannel_w(video_channels_.back());
-  }
-  while (!voice_channels_.empty()) {
-    DestroyVoiceChannel_w(voice_channels_.back());
-  }
-  while (!soundclips_.empty()) {
-    DestroySoundclip_w(soundclips_.back());
-  }
-
-  media_engine_->Terminate();
-  initialized_ = false;
-}
-
-VoiceChannel* ChannelManager::CreateVoiceChannel(
-    BaseSession* session, const std::string& content_name, bool rtcp) {
-  CreationParams params(session, content_name, rtcp, NULL);
-  return (Send(MSG_CREATEVOICECHANNEL, &params)) ? params.voice_channel : NULL;
-}
-
-VoiceChannel* ChannelManager::CreateVoiceChannel_w(
-    BaseSession* session, const std::string& content_name, bool rtcp) {
-  talk_base::CritScope cs(&crit_);
-
-  // This is ok to alloc from a thread other than the worker thread
-  ASSERT(initialized_);
-  VoiceMediaChannel* media_channel = media_engine_->CreateChannel();
-  if (media_channel == NULL)
-    return NULL;
-
-  VoiceChannel* voice_channel = new VoiceChannel(
-      worker_thread_, media_engine_.get(), media_channel,
-      session, content_name, rtcp);
-  voice_channels_.push_back(voice_channel);
-  return voice_channel;
-}
-
-void ChannelManager::DestroyVoiceChannel(VoiceChannel* voice_channel) {
-  if (voice_channel) {
-    talk_base::TypedMessageData<VoiceChannel *> data(voice_channel);
-    Send(MSG_DESTROYVOICECHANNEL, &data);
-  }
-}
-
-void ChannelManager::DestroyVoiceChannel_w(VoiceChannel* voice_channel) {
-  talk_base::CritScope cs(&crit_);
-  // Destroy voice channel.
-  ASSERT(initialized_);
-  VoiceChannels::iterator it = std::find(voice_channels_.begin(),
-      voice_channels_.end(), voice_channel);
-  ASSERT(it != voice_channels_.end());
-  if (it == voice_channels_.end())
-    return;
-
-  voice_channels_.erase(it);
-  delete voice_channel;
-}
-
-VideoChannel* ChannelManager::CreateVideoChannel(
-    BaseSession* session, const std::string& content_name, bool rtcp,
-    VoiceChannel* voice_channel) {
-  CreationParams params(session, content_name, rtcp, voice_channel);
-  return (Send(MSG_CREATEVIDEOCHANNEL, &params)) ? params.video_channel : NULL;
-}
-
-VideoChannel* ChannelManager::CreateVideoChannel_w(
-    BaseSession* session, const std::string& content_name, bool rtcp,
-    VoiceChannel* voice_channel) {
-  talk_base::CritScope cs(&crit_);
-
-  // This is ok to alloc from a thread other than the worker thread
-  ASSERT(initialized_);
-  VideoMediaChannel* media_channel =
-      // voice_channel can be NULL in case of NullVoiceEngine.
-      media_engine_->CreateVideoChannel(voice_channel ?
-          voice_channel->media_channel() : NULL);
-  if (media_channel == NULL)
-    return NULL;
-
-  VideoChannel* video_channel = new VideoChannel(
-      worker_thread_, media_engine_.get(), media_channel,
-      session, content_name, rtcp, voice_channel);
-  video_channels_.push_back(video_channel);
-  return video_channel;
-}
-
-void ChannelManager::DestroyVideoChannel(VideoChannel* video_channel) {
-  if (video_channel) {
-    talk_base::TypedMessageData<VideoChannel *> data(video_channel);
-    Send(MSG_DESTROYVIDEOCHANNEL, &data);
-  }
-}
-
-void ChannelManager::DestroyVideoChannel_w(VideoChannel *video_channel) {
-  talk_base::CritScope cs(&crit_);
-  // Destroy voice channel.
-  ASSERT(initialized_);
-  VideoChannels::iterator it = std::find(video_channels_.begin(),
-      video_channels_.end(), video_channel);
-  if (it == video_channels_.end())
-    return;
-
-  video_channels_.erase(it);
-  delete video_channel;
-}
-
-Soundclip* ChannelManager::CreateSoundclip() {
-  talk_base::TypedMessageData<Soundclip*> data(NULL);
-  Send(MSG_CREATESOUNDCLIP, &data);
-  return data.data();
-}
-
-Soundclip* ChannelManager::CreateSoundclip_w() {
-  talk_base::CritScope cs(&crit_);
-
-  ASSERT(initialized_);
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
-
-  SoundclipMedia* soundclip_media = media_engine_->CreateSoundclip();
-  if (!soundclip_media) {
-    return NULL;
-  }
-
-  Soundclip* soundclip = new Soundclip(worker_thread_, soundclip_media);
-  soundclips_.push_back(soundclip);
-  return soundclip;
-}
-
-void ChannelManager::DestroySoundclip(Soundclip* soundclip) {
-  if (soundclip) {
-    talk_base::TypedMessageData<Soundclip*> data(soundclip);
-    Send(MSG_DESTROYSOUNDCLIP, &data);
-  }
-}
-
-void ChannelManager::DestroySoundclip_w(Soundclip* soundclip) {
-  talk_base::CritScope cs(&crit_);
-  // Destroy soundclip.
-  ASSERT(initialized_);
-  Soundclips::iterator it = std::find(soundclips_.begin(),
-      soundclips_.end(), soundclip);
-  ASSERT(it != soundclips_.end());
-  if (it == soundclips_.end())
-    return;
-
-  soundclips_.erase(it);
-  delete soundclip;
-}
-
-bool ChannelManager::GetAudioOptions(std::string* in_name,
-                                     std::string* out_name, int* opts) {
-  *in_name = audio_in_device_;
-  *out_name = audio_out_device_;
-  *opts = audio_options_;
-  return true;
-}
-
-bool ChannelManager::SetAudioOptions(const std::string& in_name,
-                                     const std::string& out_name, int opts) {
-  // Get device ids from DeviceManager.
-  Device in_dev, out_dev;
-  if (!device_manager_->GetAudioInputDevice(in_name, &in_dev)) {
-    LOG(LS_WARNING) << "Failed to GetAudioInputDevice: " << in_name;
-    return false;
-  }
-  if (!device_manager_->GetAudioOutputDevice(out_name, &out_dev)) {
-    LOG(LS_WARNING) << "Failed to GetAudioOutputDevice: " << out_name;
-    return false;
-  }
-
-  // If we're initialized, pass the settings to the media engine.
-  bool ret = true;
-  if (initialized_) {
-    AudioOptions options(opts, &in_dev, &out_dev);
-    ret = (Send(MSG_SETAUDIOOPTIONS, &options) && options.result);
-  }
-
-  // If all worked well, save the values for use in GetAudioOptions.
-  if (ret) {
-    audio_options_ = opts;
-    audio_in_device_ = in_name;
-    audio_out_device_ = out_name;
-  }
-  return ret;
-}
-
-bool ChannelManager::SetAudioOptions_w(int opts, const Device* in_dev,
-    const Device* out_dev) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
-  ASSERT(initialized_);
-
-  // Set audio options
-  bool ret = media_engine_->SetAudioOptions(opts);
-
-  // Set the audio devices
-  if (ret) {
-    talk_base::CritScope cs(&crit_);
-    ret = media_engine_->SetSoundDevices(in_dev, out_dev);
-  }
-
-  return ret;
-}
-
-bool ChannelManager::GetOutputVolume(int* level) {
-  VolumeLevel volume;
-  if (!Send(MSG_GETOUTPUTVOLUME, &volume) || !volume.result) {
-    return false;
-  }
-
-  *level = volume.level;
-  return true;
-}
-
-bool ChannelManager::GetOutputVolume_w(int* level) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
-  ASSERT(initialized_);
-  return media_engine_->GetOutputVolume(level);
-}
-
-bool ChannelManager::SetOutputVolume(int level) {
-  VolumeLevel volume(level);
-  return (Send(MSG_SETOUTPUTVOLUME, &volume) && volume.result);
-}
-
-bool ChannelManager::SetOutputVolume_w(int level) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
-  ASSERT(initialized_);
-  return media_engine_->SetOutputVolume(level);
-}
-
-bool ChannelManager::GetVideoOptions(std::string* cam_name) {
-  *cam_name = camera_device_;
-  return true;
-}
-
-bool ChannelManager::SetVideoOptions(const std::string& cam_name) {
-  Device device;
-  if (!device_manager_->GetVideoCaptureDevice(cam_name, &device)) {
-    if (!cam_name.empty()) {
-      LOG(LS_WARNING) << "Device manager can't find camera: " << cam_name;
-    }
-    return false;
-  }
-
-  // If we're running, tell the media engine about it.
-  bool ret = true;
-  if (initialized_) {
-    VideoOptions options(&device);
-    ret = (Send(MSG_SETVIDEOOPTIONS, &options) && options.result);
-  }
-
-  // If everything worked, retain the name of the selected camera.
-  if (ret) {
-    camera_device_ = device.name;
-  }
-  return ret;
-}
-
-bool ChannelManager::SetVideoOptions_w(const Device* cam_device) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
-  ASSERT(initialized_);
-
-  // Set the video input device
-  return media_engine_->SetVideoCaptureDevice(cam_device);
-}
-
-bool ChannelManager::SetDefaultVideoEncoderConfig(const VideoEncoderConfig& c) {
-  bool ret = true;
-  if (initialized_) {
-    DefaultVideoEncoderConfig config(c);
-    ret = Send(MSG_SETDEFAULTVIDEOENCODERCONFIG, &config) && config.result;
-  }
-  if (ret) {
-    default_video_encoder_config_ = c;
-  }
-  return ret;
-}
-
-bool ChannelManager::SetDefaultVideoEncoderConfig_w(
-    const VideoEncoderConfig& c) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
-  ASSERT(initialized_);
-  return media_engine_->SetDefaultVideoEncoderConfig(c);
-}
-
-bool ChannelManager::SetLocalMonitor(bool enable) {
-  LocalMonitor monitor(enable);
-  bool ret = Send(MSG_SETLOCALMONITOR, &monitor) && monitor.result;
-  if (ret) {
-    monitoring_ = enable;
-  }
-  return ret;
-}
-
-bool ChannelManager::SetLocalMonitor_w(bool enable) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
-  ASSERT(initialized_);
-  return media_engine_->SetLocalMonitor(enable);
-}
-
-bool ChannelManager::SetLocalRenderer(VideoRenderer* renderer) {
-  bool ret = true;
-  if (initialized_) {
-    LocalRenderer local(renderer);
-    ret = (Send(MSG_SETLOCALRENDERER, &local) && local.result);
-  }
-  if (ret) {
-    local_renderer_ = renderer;
-  }
-  return ret;
-}
-
-bool ChannelManager::SetLocalRenderer_w(VideoRenderer* renderer) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
-  ASSERT(initialized_);
-  return media_engine_->SetLocalRenderer(renderer);
-}
-
-CaptureResult ChannelManager::SetVideoCapture(bool capture) {
-  bool ret;
-  CaptureParams capture_params(capture);
-  ret = (Send(MSG_SETVIDEOCAPTURE, &capture_params) &&
-         (capture_params.result != CR_FAILURE));
-  if (ret) {
-    capturing_ = capture;
-  }
-  return capture_params.result;
-}
-
-CaptureResult ChannelManager::SetVideoCapture_w(bool capture) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
-  ASSERT(initialized_);
-  return media_engine_->SetVideoCapture(capture);
-}
-
-void ChannelManager::SetVoiceLogging(int level, const char* filter) {
-  SetMediaLogging(false, level, filter);
-}
-
-void ChannelManager::SetVideoLogging(int level, const char* filter) {
-  SetMediaLogging(true, level, filter);
-}
-
-void ChannelManager::SetMediaLogging(bool video, int level,
-                                     const char* filter) {
-  // Can be called before initialization; in this case, the worker function
-  // is simply called on the main thread.
-  if (initialized_) {
-    LoggingOptions options(level, filter);
-    Send((video) ? MSG_SETVIDEOLOGGING : MSG_SETVOICELOGGING, &options);
-  } else {
-    SetMediaLogging_w(video, level, filter);
-  }
-}
-
-void ChannelManager::SetMediaLogging_w(bool video, int level,
-                                       const char* filter) {
-  // Can be called before initialization
-  ASSERT(worker_thread_ == talk_base::Thread::Current() || !initialized_);
-  if (video) {
-    media_engine_->SetVideoLogging(level, filter);
-  } else {
-    media_engine_->SetVoiceLogging(level, filter);
-  }
-}
-
-bool ChannelManager::Send(uint32 id, talk_base::MessageData* data) {
-  if (!worker_thread_ || !initialized_) return false;
-  worker_thread_->Send(this, id, data);
-  return true;
-}
-
-void ChannelManager::OnVideoCaptureResult(CaptureResult result) {
-  capturing_ = result == CR_SUCCESS;
-  main_thread_->Post(this, MSG_CAMERASTARTED,
-                     new talk_base::TypedMessageData<CaptureResult>(result));
-}
-
-void ChannelManager::OnMessage(talk_base::Message* message) {
-  talk_base::MessageData* data = message->pdata;
-  switch (message->message_id) {
-    case MSG_CREATEVOICECHANNEL: {
-      CreationParams* p = static_cast<CreationParams*>(data);
-      p->voice_channel =
-          CreateVoiceChannel_w(p->session, p->content_name, p->rtcp);
-      break;
-    }
-    case MSG_DESTROYVOICECHANNEL: {
-      VoiceChannel* p = static_cast<talk_base::TypedMessageData<VoiceChannel*>*>
-          (data)->data();
-      DestroyVoiceChannel_w(p);
-      break;
-    }
-    case MSG_CREATEVIDEOCHANNEL: {
-      CreationParams* p = static_cast<CreationParams*>(data);
-      p->video_channel = CreateVideoChannel_w(p->session, p->content_name,
-                                              p->rtcp, p->voice_channel);
-      break;
-    }
-    case MSG_DESTROYVIDEOCHANNEL: {
-      VideoChannel* p = static_cast<talk_base::TypedMessageData<VideoChannel*>*>
-          (data)->data();
-      DestroyVideoChannel_w(p);
-      break;
-    }
-    case MSG_CREATESOUNDCLIP: {
-      talk_base::TypedMessageData<Soundclip*> *p =
-          static_cast<talk_base::TypedMessageData<Soundclip*>*>(data);
-      p->data() = CreateSoundclip_w();
-      break;
-    }
-    case MSG_DESTROYSOUNDCLIP: {
-      talk_base::TypedMessageData<Soundclip*> *p =
-          static_cast<talk_base::TypedMessageData<Soundclip*>*>(data);
-      DestroySoundclip_w(p->data());
-      break;
-    }
-    case MSG_SETAUDIOOPTIONS: {
-      AudioOptions* p = static_cast<AudioOptions*>(data);
-      p->result = SetAudioOptions_w(p->options,
-                                    p->in_device, p->out_device);
-      break;
-    }
-    case MSG_GETOUTPUTVOLUME: {
-      VolumeLevel* p = static_cast<VolumeLevel*>(data);
-      p->result = GetOutputVolume_w(&p->level);
-      break;
-    }
-    case MSG_SETOUTPUTVOLUME: {
-      VolumeLevel* p = static_cast<VolumeLevel*>(data);
-      p->result = SetOutputVolume_w(p->level);
-      break;
-    }
-    case MSG_SETLOCALMONITOR: {
-      LocalMonitor* p = static_cast<LocalMonitor*>(data);
-      p->result = SetLocalMonitor_w(p->enable);
-      break;
-    }
-    case MSG_SETVIDEOOPTIONS: {
-      VideoOptions* p = static_cast<VideoOptions*>(data);
-      p->result = SetVideoOptions_w(p->cam_device);
-      break;
-    }
-    case MSG_SETDEFAULTVIDEOENCODERCONFIG: {
-      DefaultVideoEncoderConfig* p =
-          static_cast<DefaultVideoEncoderConfig*>(data);
-      p->result = SetDefaultVideoEncoderConfig_w(p->config);
-      break;
-    }
-    case MSG_SETLOCALRENDERER: {
-      LocalRenderer* p = static_cast<LocalRenderer*>(data);
-      p->result = SetLocalRenderer_w(p->renderer);
-      break;
-    }
-    case MSG_SETVIDEOCAPTURE: {
-      CaptureParams* p = static_cast<CaptureParams*>(data);
-      p->result = SetVideoCapture_w(p->capture);
-      break;
-    }
-    case MSG_SETVOICELOGGING:
-    case MSG_SETVIDEOLOGGING: {
-      LoggingOptions* p = static_cast<LoggingOptions*>(data);
-      bool video = (message->message_id == MSG_SETVIDEOLOGGING);
-      SetMediaLogging_w(video, p->level, p->filter.c_str());
-      break;
-    }
-    case MSG_CAMERASTARTED: {
-      talk_base::TypedMessageData<CaptureResult>* data =
-          static_cast<talk_base::TypedMessageData<CaptureResult>*>(
-              message->pdata);
-      SignalVideoCaptureResult(data->data());
-      delete data;
-      break;
-    }
-  }
-}
-
-static void GetDeviceNames(const std::vector<Device>& devs,
-                           std::vector<std::string>* names) {
-  names->clear();
-  for (size_t i = 0; i < devs.size(); ++i) {
-    names->push_back(devs[i].name);
-  }
-}
-
-bool ChannelManager::GetAudioInputDevices(std::vector<std::string>* names) {
-  names->clear();
-  std::vector<Device> devs;
-  bool ret = device_manager_->GetAudioInputDevices(&devs);
-  if (ret)
-    GetDeviceNames(devs, names);
-
-  return ret;
-}
-
-bool ChannelManager::GetAudioOutputDevices(std::vector<std::string>* names) {
-  names->clear();
-  std::vector<Device> devs;
-  bool ret = device_manager_->GetAudioOutputDevices(&devs);
-  if (ret)
-    GetDeviceNames(devs, names);
-
-  return ret;
-}
-
-bool ChannelManager::GetVideoCaptureDevices(std::vector<std::string>* names) {
-  names->clear();
-  std::vector<Device> devs;
-  bool ret = device_manager_->GetVideoCaptureDevices(&devs);
-  if (ret)
-    GetDeviceNames(devs, names);
-
-  return ret;
-}
-
-}  // namespace cricket
diff --git a/third_party_mods/libjingle/source/talk/session/phone/channelmanager.h b/third_party_mods/libjingle/source/talk/session/phone/channelmanager.h
deleted file mode 100644
index bfdf5d5..0000000
--- a/third_party_mods/libjingle/source/talk/session/phone/channelmanager.h
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
- * libjingle
- * Copyright 2004--2008, Google Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  1. Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *  2. Redistributions in binary form must reproduce the above copyright notice,
- *     this list of conditions and the following disclaimer in the documentation
- *     and/or other materials provided with the distribution.
- *  3. The name of the author may not be used to endorse or promote products
- *     derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef TALK_SESSION_PHONE_CHANNELMANAGER_H_
-#define TALK_SESSION_PHONE_CHANNELMANAGER_H_
-
-#include <string>
-#include <vector>
-
-#include "talk/base/criticalsection.h"
-#include "talk/base/sigslotrepeater.h"
-#include "talk/base/thread.h"
-#include "talk/p2p/base/session.h"
-#include "talk/session/phone/voicechannel.h"
-#include "talk/session/phone/mediaengine.h"
-#include "talk/session/phone/devicemanager.h"
-
-namespace cricket {
-
-class Soundclip;
-class VoiceChannel;
-
-// ChannelManager allows the MediaEngine to run on a separate thread, and takes
-// care of marshalling calls between threads. It also creates and keeps track of
-// voice and video channels; by doing so, it can temporarily pause all the
-// channels when a new audio or video device is chosen. The voice and video
-// channels are stored in separate vectors, to easily allow operations on just
-// voice or just video channels.
-// ChannelManager also allows the application to discover what devices it has
-// using device manager.
-class ChannelManager : public talk_base::MessageHandler,
-                       public sigslot::has_slots<> {
- public:
-  // Creates the channel manager, and specifies the worker thread to use.
-  explicit ChannelManager(talk_base::Thread* worker);
-  // For testing purposes. Allows the media engine and dev manager to be mocks.
-  // The ChannelManager takes ownership of these objects.
-  ChannelManager(MediaEngine* me, DeviceManager* dm, talk_base::Thread* worker);
-  ~ChannelManager();
-
-  // Accessors for the worker thread, allowing it to be set after construction,
-  // but before Init. set_worker_thread will return false if called after Init.
-  talk_base::Thread* worker_thread() const { return worker_thread_; }
-  bool set_worker_thread(talk_base::Thread* thread) {
-    if (initialized_) return false;
-    worker_thread_ = thread;
-    return true;
-  }
-
-  // Gets capabilities. Can be called prior to starting the media engine.
-  int GetCapabilities();
-
-  // Retrieves the list of supported audio & video codec types.
-  // Can be called before starting the media engine.
-  void GetSupportedAudioCodecs(std::vector<AudioCodec>* codecs) const;
-  void GetSupportedVideoCodecs(std::vector<VideoCodec>* codecs) const;
-
-  // Indicates whether the media engine is started.
-  bool initialized() const { return initialized_; }
-  // Starts up the media engine.
-  bool Init();
-  // TODO: Remove this temporary API once Flute is updated.
-  bool Init(talk_base::Thread* thread) {
-    return set_worker_thread(thread) && Init();
-  }
-  // Shuts down the media engine.
-  void Terminate();
-
-  // The operations below all occur on the worker thread.
-
-  // Creates a voice channel, to be associated with the specified session.
-  VoiceChannel* CreateVoiceChannel(
-      BaseSession* session, const std::string& content_name, bool rtcp);
-  // Destroys a voice channel created with the Create API.
-  void DestroyVoiceChannel(VoiceChannel* voice_channel);
-  // Creates a video channel, synced with the specified voice channel, and
-  // associated with the specified session.
-  VideoChannel* CreateVideoChannel(
-      BaseSession* session, const std::string& content_name, bool rtcp,
-      VoiceChannel* voice_channel);
-  // Destroys a video channel created with the Create API.
-  void DestroyVideoChannel(VideoChannel* video_channel);
-
-  // Creates a soundclip.
-  Soundclip* CreateSoundclip();
-  // Destroys a soundclip created with the Create API.
-  void DestroySoundclip(Soundclip* soundclip);
-
-  // Indicates whether any channels exist.
-  bool has_channels() const {
-    return (!voice_channels_.empty() || !video_channels_.empty() ||
-            !soundclips_.empty());
-  }
-
-  // Configures the audio and video devices.
-  bool GetAudioOptions(std::string* wave_in_device,
-                       std::string* wave_out_device, int* opts);
-  bool SetAudioOptions(const std::string& wave_in_device,
-                       const std::string& wave_out_device, int opts);
-  bool GetOutputVolume(int* level);
-  bool SetOutputVolume(int level);
-  bool GetVideoOptions(std::string* cam_device);
-  bool SetVideoOptions(const std::string& cam_device);
-  bool SetDefaultVideoEncoderConfig(const VideoEncoderConfig& config);
-
-  // Starts/stops the local microphone and enables polling of the input level.
-  bool SetLocalMonitor(bool enable);
-  bool monitoring() const { return monitoring_; }
-  // Sets the local renderer where to renderer the local camera.
-  bool SetLocalRenderer(VideoRenderer* renderer);
-  // Starts and stops the local camera and renders it to the local renderer.
-  CaptureResult SetVideoCapture(bool capture);
-  bool capturing() const { return capturing_; }
-
-  // Configures the logging output of the mediaengine(s).
-  void SetVoiceLogging(int level, const char* filter);
-  void SetVideoLogging(int level, const char* filter);
-
-  // The operations below occur on the main thread.
-
-  bool GetAudioInputDevices(std::vector<std::string>* names);
-  bool GetAudioOutputDevices(std::vector<std::string>* names);
-  bool GetVideoCaptureDevices(std::vector<std::string>* names);
-  sigslot::repeater0<> SignalDevicesChange;
-  sigslot::signal1<CaptureResult> SignalVideoCaptureResult;
-
- protected:
-  bool Send(uint32 id, talk_base::MessageData* pdata);
-  void OnMessage(talk_base::Message *message);
-  MediaEngine* media_engine() { return media_engine_.get(); }
-
- private:
-  typedef std::vector<VoiceChannel*> VoiceChannels;
-  typedef std::vector<VideoChannel*> VideoChannels;
-  typedef std::vector<Soundclip*> Soundclips;
-
-  void Construct();
-  VoiceChannel* CreateVoiceChannel_w(
-      BaseSession* session, const std::string& content_name, bool rtcp);
-  void DestroyVoiceChannel_w(VoiceChannel* voice_channel);
-  VideoChannel* CreateVideoChannel_w(
-      BaseSession* session, const std::string& content_name, bool rtcp,
-      VoiceChannel* voice_channel);
-  void DestroyVideoChannel_w(VideoChannel* video_channel);
-  Soundclip* CreateSoundclip_w();
-  void DestroySoundclip_w(Soundclip* soundclip);
-  bool SetAudioOptions_w(int opts, const Device* in_dev,
-                         const Device* out_dev);
-  bool GetOutputVolume_w(int* level);
-  bool SetOutputVolume_w(int level);
-  bool SetLocalMonitor_w(bool enable);
-  bool SetVideoOptions_w(const Device* cam_device);
-  bool SetDefaultVideoEncoderConfig_w(const VideoEncoderConfig& config);
-  bool SetLocalRenderer_w(VideoRenderer* renderer);
-  CaptureResult SetVideoCapture_w(bool capture);
-  void SetMediaLogging(bool video, int level, const char* filter);
-  void SetMediaLogging_w(bool video, int level, const char* filter);
-  void OnVideoCaptureResult(CaptureResult result);
-
-  talk_base::CriticalSection crit_;
-  talk_base::scoped_ptr<MediaEngine> media_engine_;
-  talk_base::scoped_ptr<DeviceManager> device_manager_;
-  bool initialized_;
-  talk_base::Thread* main_thread_;
-  talk_base::Thread* worker_thread_;
-
-  VoiceChannels voice_channels_;
-  VideoChannels video_channels_;
-  Soundclips soundclips_;
-
-  std::string audio_in_device_;
-  std::string audio_out_device_;
-  int audio_options_;
-  std::string camera_device_;
-  VideoEncoderConfig default_video_encoder_config_;
-  VideoRenderer* local_renderer_;
-
-  bool capturing_;
-  bool monitoring_;
-};
-
-}  // namespace cricket
-
-#endif  // TALK_SESSION_PHONE_CHANNELMANAGER_H_
diff --git a/third_party_mods/libjingle/source/talk/session/phone/mediaengine.h b/third_party_mods/libjingle/source/talk/session/phone/mediaengine.h
deleted file mode 100644
index 05f0821..0000000
--- a/third_party_mods/libjingle/source/talk/session/phone/mediaengine.h
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- * libjingle
- * Copyright 2004--2007, Google Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  1. Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *  2. Redistributions in binary form must reproduce the above copyright notice,
- *     this list of conditions and the following disclaimer in the documentation
- *     and/or other materials provided with the distribution.
- *  3. The name of the author may not be used to endorse or promote products
- *     derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef TALK_SESSION_PHONE_MEDIAENGINE_H_
-#define TALK_SESSION_PHONE_MEDIAENGINE_H_
-
-#ifdef OSX
-#include <CoreAudio/CoreAudio.h>
-#endif
-
-#include <string>
-#include <vector>
-
-#include "talk/base/sigslotrepeater.h"
-#include "talk/session/phone/codec.h"
-#include "talk/session/phone/devicemanager.h"
-#include "talk/session/phone/mediachannel.h"
-#include "talk/session/phone/videocommon.h"
-
-namespace cricket {
-
-// A class for playing out soundclips.
-class SoundclipMedia {
- public:
-  enum SoundclipFlags {
-    SF_LOOP = 1,
-  };
-
-  virtual ~SoundclipMedia() {}
-
-  // Plays a sound out to the speakers with the given audio stream. The stream
-  // must be 16-bit little-endian 16 kHz PCM. If a stream is already playing
-  // on this SoundclipMedia, it is stopped. If clip is NULL, nothing is played.
-  // Returns whether it was successful.
-  virtual bool PlaySound(const char *clip, int len, int flags) = 0;
-};
-
-// MediaEngine is an abstraction of a media engine which can be subclassed
-// to support different media componentry backends. It supports voice and
-// video operations in the same class to facilitate proper synchronization
-// between both media types.
-class MediaEngine {
- public:
-  // TODO: Move this to a global location (also used in DeviceManager)
-  // Capabilities of the media engine.
-  enum Capabilities {
-    AUDIO_RECV = 1 << 0,
-    AUDIO_SEND = 1 << 1,
-    VIDEO_RECV = 1 << 2,
-    VIDEO_SEND = 1 << 3,
-  };
-
-  // Bitmask flags for options that may be supported by the media engine
-  // implementation
-  enum AudioOptions {
-    ECHO_CANCELLATION = 1 << 0,
-    AUTO_GAIN_CONTROL = 1 << 1,
-    DEFAULT_AUDIO_OPTIONS = ECHO_CANCELLATION | AUTO_GAIN_CONTROL
-  };
-  enum VideoOptions {
-  };
-
-  virtual ~MediaEngine() {}
-  static MediaEngine* Create();
-
-  // Initialization
-  // Starts the engine.
-  virtual bool Init() = 0;
-  // Shuts down the engine.
-  virtual void Terminate() = 0;
-  // Returns what the engine is capable of, as a set of Capabilities, above.
-  virtual int GetCapabilities() = 0;
-
-  // MediaChannel creation
-  // Creates a voice media channel. Returns NULL on failure.
-  virtual VoiceMediaChannel *CreateChannel() = 0;
-  // Creates a video media channel, paired with the specified voice channel.
-  // Returns NULL on failure.
-  virtual VideoMediaChannel *CreateVideoChannel(
-      VoiceMediaChannel* voice_media_channel) = 0;
-
-  // Creates a soundclip object for playing sounds on. Returns NULL on failure.
-  virtual SoundclipMedia *CreateSoundclip() = 0;
-
-  // Configuration
-  // Sets global audio options. "options" are from AudioOptions, above.
-  virtual bool SetAudioOptions(int options) = 0;
-  // Sets global video options. "options" are from VideoOptions, above.
-  virtual bool SetVideoOptions(int options) = 0;
-  // Sets the default (maximum) codec/resolution and encoder option to capture
-  // and encode video.
-  virtual bool SetDefaultVideoEncoderConfig(const VideoEncoderConfig& config)
-      = 0;
-
-  // Device selection
-  // TODO: Add method for selecting the soundclip device.
-  virtual bool SetSoundDevices(const Device* in_device,
-                               const Device* out_device) = 0;
-  virtual bool SetVideoCaptureDevice(const Device* cam_device) = 0;
-  virtual bool SetVideoRenderer(int channel_id,
-                                void* window,
-                                unsigned int zOrder,
-                                float left,
-                                float top,
-                                float right,
-                                float bottom) = 0;
-
-  // Device configuration
-  // Gets the current speaker volume, as a value between 0 and 255.
-  virtual bool GetOutputVolume(int* level) = 0;
-  // Sets the current speaker volume, as a value between 0 and 255.
-  virtual bool SetOutputVolume(int level) = 0;
-
-  // Local monitoring
-  // Gets the current microphone level, as a value between 0 and 10.
-  virtual int GetInputLevel() = 0;
-  // Starts or stops the local microphone. Useful if local mic info is needed
-  // prior to a call being connected; the mic will be started automatically
-  // when a VoiceMediaChannel starts sending.
-  virtual bool SetLocalMonitor(bool enable) = 0;
-  // Installs a callback for raw frames from the local camera.
-  virtual bool SetLocalRenderer(VideoRenderer* renderer) = 0;
-  // Starts/stops local camera.
-  virtual CaptureResult SetVideoCapture(bool capture) = 0;
-
-  virtual const std::vector<AudioCodec>& audio_codecs() = 0;
-  virtual const std::vector<VideoCodec>& video_codecs() = 0;
-
-  // Logging control
-  virtual void SetVoiceLogging(int min_sev, const char* filter) = 0;
-  virtual void SetVideoLogging(int min_sev, const char* filter) = 0;
-
-  sigslot::repeater1<CaptureResult> SignalVideoCaptureResult;
-};
-
-// CompositeMediaEngine constructs a MediaEngine from separate
-// voice and video engine classes.
-template<class VOICE, class VIDEO>
-class CompositeMediaEngine : public MediaEngine {
- public:
-  CompositeMediaEngine() {}
-  virtual ~CompositeMediaEngine() {}
-  virtual bool Init() {
-    if (!voice_.Init())
-      return false;
-    if (!video_.Init()) {
-      voice_.Terminate();
-      return false;
-    }
-    SignalVideoCaptureResult.repeat(video_.SignalCaptureResult);
-    return true;
-  }
-  virtual void Terminate() {
-    video_.Terminate();
-    voice_.Terminate();
-  }
-
-  virtual int GetCapabilities() {
-    return (voice_.GetCapabilities() | video_.GetCapabilities());
-  }
-  virtual VoiceMediaChannel *CreateChannel() {
-    return voice_.CreateChannel();
-  }
-  virtual VideoMediaChannel *CreateVideoChannel(VoiceMediaChannel* channel) {
-    return video_.CreateChannel(channel);
-  }
-  virtual SoundclipMedia *CreateSoundclip() {
-    return voice_.CreateSoundclip();
-  }
-
-  virtual bool SetAudioOptions(int o) {
-    return voice_.SetOptions(o);
-  }
-  virtual bool SetVideoOptions(int o) {
-    return video_.SetOptions(o);
-  }
-  virtual bool SetDefaultVideoEncoderConfig(const VideoEncoderConfig& config) {
-    return video_.SetDefaultEncoderConfig(config);
-  }
-
-  virtual bool SetSoundDevices(const Device* in_device,
-                               const Device* out_device) {
-    return voice_.SetDevices(in_device, out_device);
-  }
-
-  virtual bool SetVideoCaptureDevice(const Device* cam_device) {
-    return video_.SetCaptureDevice(cam_device);
-  }
-
-  virtual bool SetVideoRenderer(int channel_id,
-                                void* window,
-                                unsigned int zOrder,
-                                float left,
-                                float top,
-                                float right,
-                                float bottom) {
-    return video_.SetVideoRenderer(channel_id,
-                                   window,
-                                   zOrder,
-                                   left,
-                                   top,
-                                   right,
-                                   bottom);
-  }
-
-  virtual bool GetOutputVolume(int* level) {
-    return voice_.GetOutputVolume(level);
-  }
-
-  virtual bool SetOutputVolume(int level) {
-    return voice_.SetOutputVolume(level);
-  }
-
-  virtual int GetInputLevel() {
-    return voice_.GetInputLevel();
-  }
-  virtual bool SetLocalMonitor(bool enable) {
-    return voice_.SetLocalMonitor(enable);
-  }
-  virtual bool SetLocalRenderer(VideoRenderer* renderer) {
-    return video_.SetLocalRenderer(renderer);
-  }
-  virtual CaptureResult SetVideoCapture(bool capture) {
-    return video_.SetCapture(capture);
-  }
-
-  virtual const std::vector<AudioCodec>& audio_codecs() {
-    return voice_.codecs();
-  }
-  virtual const std::vector<VideoCodec>& video_codecs() {
-    return video_.codecs();
-  }
-
-  virtual void SetVoiceLogging(int min_sev, const char* filter) {
-    return voice_.SetLogging(min_sev, filter);
-  }
-  virtual void SetVideoLogging(int min_sev, const char* filter) {
-    return video_.SetLogging(min_sev, filter);
-  }
-
- protected:
-  VOICE voice_;
-  VIDEO video_;
-};
-
-// NullVoiceEngine can be used with CompositeMediaEngine in the case where only
-// a video engine is desired.
-class NullVoiceEngine {
- public:
-  bool Init() { return true; }
-  void Terminate() {}
-  int GetCapabilities() { return 0; }
-  // If you need this to return an actual channel, use FakeMediaEngine instead.
-  VoiceMediaChannel* CreateChannel() {
-    return NULL;
-  }
-  SoundclipMedia* CreateSoundclip() {
-    return NULL;
-  }
-  bool SetOptions(int opts) { return true; }
-  bool SetDevices(const Device* in_device, const Device* out_device) {
-    return true;
-  }
-  bool GetOutputVolume(int* level) { *level = 0; return true; }
-  bool SetOutputVolume(int level) { return true; }
-  int GetInputLevel() { return 0; }
-  bool SetLocalMonitor(bool enable) { return true; }
-  const std::vector<AudioCodec>& codecs() { return codecs_; }
-  void SetLogging(int min_sev, const char* filter) {}
- private:
-  std::vector<AudioCodec> codecs_;
-};
-
-// NullVideoEngine can be used with CompositeMediaEngine in the case where only
-// a voice engine is desired.
-class NullVideoEngine {
- public:
-  bool Init() { return true; }
-  void Terminate() {}
-  int GetCapabilities() { return 0; }
-  // If you need this to return an actual channel, use FakeMediaEngine instead.
-  VideoMediaChannel* CreateChannel(
-      VoiceMediaChannel* voice_media_channel) {
-    return NULL;
-  }
-  bool SetOptions(int opts) { return true; }
-  bool SetDefaultEncoderConfig(const VideoEncoderConfig& config) {
-    return true;
-  }
-  bool SetCaptureDevice(const Device* cam_device) { return true; }
-  bool SetLocalRenderer(VideoRenderer* renderer) { return true; }
-  CaptureResult SetCapture(bool capture) { return CR_SUCCESS;  }
-  const std::vector<VideoCodec>& codecs() { return codecs_; }
-  void SetLogging(int min_sev, const char* filter) {}
-  sigslot::signal1<CaptureResult> SignalCaptureResult;
- private:
-  std::vector<VideoCodec> codecs_;
-};
-
-typedef CompositeMediaEngine<NullVoiceEngine, NullVideoEngine> NullMediaEngine;
-
-}  // namespace cricket
-
-#endif  // TALK_SESSION_PHONE_MEDIAENGINE_H_