diff --git a/CHANGELOG b/CHANGELOG
index 1d52975..ecc343f 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,5 +1,9 @@
 Libjingle
 
+0.6.12 - Feb 07, 2012
+  - PeerConnection client for windows.
+  - Bug fixes.
+
 0.6.11 - Jan 24, 2012
   - Improved ipv6 support.
   - Initial DTLS support.
diff --git a/talk/app/webrtc/peerconnectionfactory_unittest.cc b/talk/app/webrtc/peerconnectionfactory_unittest.cc
index 7a3b15f..5056e17 100644
--- a/talk/app/webrtc/peerconnectionfactory_unittest.cc
+++ b/talk/app/webrtc/peerconnectionfactory_unittest.cc
@@ -49,18 +49,15 @@
 };
 
 TEST(PeerConnectionFactory, CreatePCUsingInternalModules) {
-  NullPeerConnectionObserver observer;
   talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory(
       CreatePeerConnectionFactory());
   ASSERT_TRUE(factory.get() != NULL);
-  talk_base::scoped_refptr<PeerConnectionInterface> pc1(
-      factory->CreatePeerConnection("", &observer));
-  EXPECT_TRUE(pc1.get() == NULL);
 
-  talk_base::scoped_refptr<PeerConnectionInterface> pc2(
+  NullPeerConnectionObserver observer;
+  talk_base::scoped_refptr<PeerConnectionInterface> pc(
       factory->CreatePeerConnection(kStunConfiguration, &observer));
 
-  EXPECT_TRUE(pc2.get() != NULL);
+  EXPECT_TRUE(pc.get() != NULL);
 }
 
 TEST(PeerConnectionFactory, CreatePCUsingExternalModules) {
@@ -75,14 +72,9 @@
   ASSERT_TRUE(factory.get() != NULL);
 
   NullPeerConnectionObserver observer;
-  talk_base::scoped_refptr<webrtc::PeerConnectionInterface> pc1(
-      factory->CreatePeerConnection("", &observer));
-
-  EXPECT_TRUE(pc1.get() == NULL);
-
-  talk_base::scoped_refptr<PeerConnectionInterface> pc2(
+  talk_base::scoped_refptr<PeerConnectionInterface> pc(
       factory->CreatePeerConnection(kStunConfiguration, &observer));
-  EXPECT_TRUE(pc2.get() != NULL);
+  EXPECT_TRUE(pc.get() != NULL);
 }
 
 }  // namespace webrtc
diff --git a/talk/app/webrtc/peerconnectionimpl.cc b/talk/app/webrtc/peerconnectionimpl.cc
index fdc2659..7f990f1 100644
--- a/talk/app/webrtc/peerconnectionimpl.cc
+++ b/talk/app/webrtc/peerconnectionimpl.cc
@@ -124,7 +124,7 @@
     case STUNS:
     case INVALID:
     default:
-      ASSERT(!"Configuration not supported");
+      LOG(WARNING) << "Configuration not supported";
       return false;
   }
   return true;
@@ -199,8 +199,7 @@
   std::vector<PortAllocatorFactoryInterface::StunConfiguration> stun_config;
   std::vector<PortAllocatorFactoryInterface::TurnConfiguration> turn_config;
 
-  if (!ParseConfigString(configuration, &stun_config, &turn_config))
-    return false;
+  ParseConfigString(configuration, &stun_config, &turn_config);
 
   port_allocator_.reset(factory_->port_allocator_factory()->CreatePortAllocator(
       stun_config, turn_config));
diff --git a/talk/app/webrtc/peerconnectionimpl_unittest.cc b/talk/app/webrtc/peerconnectionimpl_unittest.cc
index 0dae92c..5363af6 100644
--- a/talk/app/webrtc/peerconnectionimpl_unittest.cc
+++ b/talk/app/webrtc/peerconnectionimpl_unittest.cc
@@ -39,6 +39,7 @@
 static const char kStreamLabel1[] = "local_stream_1";
 static const char kStreamLabel2[] = "local_stream_2";
 static const char kStunConfiguration[] = "STUN stun.l.google.com:19302";
+static const char kInvalidConfiguration[] = "a13151913541234:19302";
 static const uint32 kTimeout = 5000U;
 
 using talk_base::scoped_ptr;
@@ -159,12 +160,22 @@
         talk_base::Thread::Current(), talk_base::Thread::Current(),
         port_allocator_factory_.get(), NULL);
     ASSERT_TRUE(pc_factory_.get() != NULL);
+  }
+
+  void CreatePeerConnection() {
     pc_ = pc_factory_->CreatePeerConnection(kStunConfiguration, &observer_);
     ASSERT_TRUE(pc_.get() != NULL);
     observer_.SetPeerConnectionInterface(pc_.get());
     EXPECT_EQ(PeerConnectionInterface::kNegotiating, observer_.state_);
   }
 
+  void CreatePeerConnectionWithInvalidConfiguration() {
+    pc_ = pc_factory_->CreatePeerConnection(kInvalidConfiguration, &observer_);
+    ASSERT_TRUE(pc_.get() != NULL);
+    observer_.SetPeerConnectionInterface(pc_.get());
+    EXPECT_EQ(PeerConnectionInterface::kNegotiating, observer_.state_);
+  }
+
   void AddStream(const std::string& label) {
     // Create a local stream.
     scoped_refptr<LocalMediaStreamInterface> stream(
@@ -188,7 +199,13 @@
   MockPeerConnectionObserver observer_;
 };
 
+TEST_F(PeerConnectionImplTest, CreatePeerConnectionWithInvalidConfiguration) {
+  CreatePeerConnectionWithInvalidConfiguration();
+  AddStream(kStreamLabel1);
+}
+
 TEST_F(PeerConnectionImplTest, AddStream) {
+  CreatePeerConnection();
   AddStream(kStreamLabel1);
   ASSERT_EQ(1u, pc_->local_streams()->count());
   EXPECT_EQ(kStreamLabel1, pc_->local_streams()->at(0)->label());
@@ -206,7 +223,8 @@
   EXPECT_EQ(kStreamLabel1, pc_->remote_streams()->at(0)->label());
 }
 
-TEST_F(PeerConnectionImplTest, UpdateStream) {
+TEST_F(PeerConnectionImplTest, DISABLED_UpdateStream) {
+  CreatePeerConnection();
   AddStream(kStreamLabel1);
   WAIT(PeerConnectionInterface::kNegotiating == observer_.state_, kTimeout);
   pc_->ProcessSignalingMessage(CreateAnswerMessage(observer_.last_message_));
@@ -241,6 +259,7 @@
 }
 
 TEST_F(PeerConnectionImplTest, SendClose) {
+  CreatePeerConnection();
   pc_->Close();
   EXPECT_EQ(RoapMessageBase::kShutdown, observer_.last_message_.type());
   EXPECT_EQ(PeerConnectionInterface::kClosing, observer_.state_);
@@ -249,6 +268,7 @@
 }
 
 TEST_F(PeerConnectionImplTest, ReceiveClose) {
+  CreatePeerConnection();
   pc_->ProcessSignalingMessage(CreateShutdownMessage());
   EXPECT_EQ_WAIT(RoapMessageBase::kOk, observer_.last_message_.type(),
                  kTimeout);
@@ -256,6 +276,7 @@
 }
 
 TEST_F(PeerConnectionImplTest, ReceiveCloseWhileExpectingAnswer) {
+  CreatePeerConnection();
   AddStream(kStreamLabel1);
 
   // Receive the shutdown message.
diff --git a/talk/app/webrtc/webrtcsdp.cc b/talk/app/webrtc/webrtcsdp.cc
index 6986a8b..bdf4d00 100644
--- a/talk/app/webrtc/webrtcsdp.cc
+++ b/talk/app/webrtc/webrtcsdp.cc
@@ -118,7 +118,6 @@
 static const int kDefaultVideoPreference = 0;
 
 static void BuildMediaDescription(const cricket::ContentInfo& content_info,
-                                  const std::vector<Candidate>& candidates,
                                   const MediaType media_type,
                                   std::string* message);
 static void BuildRtpMap(const MediaContentDescription* media_desc,
@@ -131,13 +130,13 @@
 static bool ParseSessionDescription(const std::string& message, size_t* pos);
 static bool ParseTimeDescription(const std::string& message, size_t* pos);
 static bool ParseMediaDescription(const std::string& message, size_t* pos,
-                                  cricket::SessionDescription* desc,
-                                  std::vector<Candidate>* candidates);
+                                  cricket::SessionDescription* desc);
 static bool ParseContent(const std::string& message,
                          const MediaType media_type,
                          size_t* pos,
-                         ContentDescription* content,
-                         std::vector<Candidate>* candidates);
+                         ContentDescription* content);
+static bool ParseCandidates(const std::string& message,
+                            std::vector<Candidate>* candidates);
 
 // Helper functions
 #define LOG_PREFIX_PARSING_ERROR(line_prefix) LOG(LS_ERROR) \
@@ -202,6 +201,12 @@
 
 std::string SdpSerialize(const cricket::SessionDescription& desc,
                          const std::vector<Candidate>& candidates) {
+  return SdpFormat(SdpSerializeSessionDescription(desc),
+                   SdpSerializeCandidates(candidates));
+}
+
+std::string SdpSerializeSessionDescription(
+    const cricket::SessionDescription& desc) {
   std::string message;
 
   // Session Description.
@@ -221,21 +226,61 @@
 
   // Media Description
   if (audio_content) {
-    BuildMediaDescription(*audio_content, candidates,
-        cricket::MEDIA_TYPE_AUDIO, &message);
+    BuildMediaDescription(*audio_content, cricket::MEDIA_TYPE_AUDIO, &message);
   }
 
   if (video_content) {
-    BuildMediaDescription(*video_content, candidates,
-        cricket::MEDIA_TYPE_VIDEO, &message);
+    BuildMediaDescription(*video_content, cricket::MEDIA_TYPE_VIDEO, &message);
   }
 
   return message;
 }
 
+std::string SdpSerializeCandidates(const std::vector<Candidate>& candidates) {
+  std::string message;
+  // rfc5245
+  // a=candidate:<foundation> <component-id> <transport> <priority>
+  // <connection-address> <port> typ <candidate-types>
+  // [raddr <connection-address>] [rport <port>]
+  BuildCandidate(candidates, cricket::MEDIA_TYPE_AUDIO, &message);
+  BuildCandidate(candidates, cricket::MEDIA_TYPE_VIDEO, &message);
+  return message;
+}
+
+std::string SdpFormat(const std::string& desc, const std::string& candidates) {
+  std::string sdp;  // New sdp message.
+
+  std::vector<Candidate> candidates_vector;
+  if (!ParseCandidates(candidates, &candidates_vector))
+    return sdp;
+
+  size_t pos = 0;
+  std::string line;
+  while (GetLine(desc, &pos, &line)) {
+    AddLine(line, &sdp);  // Copy old line to new sdp.
+    if (!HasPrefix(line, kLinePrefixMedia)) {
+      continue;  // Loop until the next m line.
+    }
+    if (HasAttribute(line, kMediaTypeVideo)) {
+      BuildCandidate(candidates_vector, cricket::MEDIA_TYPE_VIDEO, &sdp);
+    } else if (HasAttribute(line, kMediaTypeAudio)) {
+      BuildCandidate(candidates_vector, cricket::MEDIA_TYPE_AUDIO, &sdp);
+    }
+  }
+
+  return sdp;
+}
+
+
 bool SdpDeserialize(const std::string& message,
                     cricket::SessionDescription* desc,
                     std::vector<Candidate>* candidates) {
+  return SdpDeserializeSessionDescription(message, desc) &&
+         SdpDeserializeCandidates(message, candidates);
+}
+
+bool SdpDeserializeSessionDescription(const std::string& message,
+                                      cricket::SessionDescription* desc) {
   size_t current_pos = 0;
 
   // Session Description
@@ -249,15 +294,19 @@
   }
 
   // Media Description
-  if (!ParseMediaDescription(message, &current_pos, desc, candidates)) {
+  if (!ParseMediaDescription(message, &current_pos, desc)) {
     return false;
   }
 
   return true;
 }
 
+bool SdpDeserializeCandidates(const std::string& message,
+                              std::vector<Candidate>* candidates) {
+  return ParseCandidates(message, candidates);
+}
+
 void BuildMediaDescription(const cricket::ContentInfo& content_info,
-                           const std::vector<Candidate>& candidates,
                            const MediaType media_type,
                            std::string* message) {
   ASSERT(message != NULL);
@@ -335,12 +384,6 @@
   // [/<encodingparameters>]
   BuildRtpMap(media_desc, media_type, message);
 
-  // rfc5245
-  // a=candidate:<foundation> <component-id> <transport> <priority>
-  // <connection-address> <port> typ <candidate-types>
-  // [raddr <connection-address>] [rport <port>]
-  BuildCandidate(candidates, media_type, message);
-
   // draft - Mechanisms for Media Source Selection in SDP
   // a=ssrc:<ssrc-id> <attribute>:<value>
   // a=ssrc:<ssrc-id> cname:<value> mslabel:<value> label:<value>
@@ -521,10 +564,8 @@
 }
 
 bool ParseMediaDescription(const std::string& message, size_t* pos,
-                           cricket::SessionDescription* desc,
-                           std::vector<Candidate>* candidates) {
+                           cricket::SessionDescription* desc) {
   ASSERT(desc != NULL);
-  ASSERT(candidates != NULL);
 
   std::string line;
 
@@ -545,7 +586,7 @@
       LOG(LS_WARNING) << "Unsupported media type: " << line;
     }
 
-    if (!ParseContent(message, media_type, pos, content, candidates))
+    if (!ParseContent(message, media_type, pos, content))
       return false;
   }
   return true;
@@ -554,9 +595,7 @@
 bool ParseContent(const std::string& message,
                   const MediaType media_type,
                   size_t* pos,
-                  ContentDescription* content,
-                  std::vector<Candidate>* candidates) {
-  ASSERT(candidates != NULL);
+                  ContentDescription* content) {
   std::string line;
   // Loop until the next m line
   while (!HasPrefix(message, kLinePrefixMedia, *pos)) {
@@ -625,57 +664,7 @@
       const std::string key_params = fields[2];
       media_desc->AddCrypto(CryptoParams(tag, crypto_suite, key_params, ""));
     } else if (HasAttribute(line, kAttributeCandidate)) {
-      // a=candidate:<foundation> <component-id> <transport> <priority>
-      // <connection-address> <port> typ <candidate-types>
-      // [raddr <connection-address>] [rport <port>]
-      // *(SP extension-att-name SP extension-att-value)
-      // 8 mandatory fields
-      if (fields.size() < 8 || (fields[6] != kAttributeCandidateTyp)) {
-        LOG_LINE_PARSING_ERROR(line);
-        return false;
-      }
-      const std::string transport = fields[2];
-      const float priority = talk_base::FromString<float>(fields[3]);
-      const std::string connection_address = fields[4];
-      const int port = talk_base::FromString<int>(fields[5]);
-      std::string candidate_type;
-      const std::string type = fields[7];
-      if (type == kCandidateHost) {
-        candidate_type = cricket::LOCAL_PORT_TYPE;
-      } else if (type == kCandidateSrflx) {
-        candidate_type = cricket::STUN_PORT_TYPE;
-      } else if (type == kCandidateRelay) {
-        candidate_type = cricket::RELAY_PORT_TYPE;
-      } else {
-        LOG(LS_ERROR) << "Unsupported candidate type from line: " << line;
-        return false;
-      }
-
-      // extension
-      std::string name;
-      std::string network_name;
-      std::string username;
-      std::string password;
-      uint32 generation = 0;
-      for (size_t i = 8; i < (fields.size() - 1); ++i) {
-        const std::string field = fields.at(i);
-        if (field == kAttributeCandidateName) {
-          name = fields.at(++i);
-        } else if (field == kAttributeCandidateNetworkName) {
-          network_name = fields.at(++i);
-        } else if (field == kAttributeCandidateUsername) {
-          username = fields.at(++i);
-        } else if (field == kAttributeCandidatePassword) {
-          password = fields.at(++i);
-        } else if (field == kAttributeCandidateGeneration) {
-          generation = talk_base::FromString<uint32>(fields.at(++i));
-        }
-      }
-
-      SocketAddress address(connection_address, port);
-      Candidate candidate(name, transport, address, priority, username,
-          password, candidate_type, network_name, generation);
-      candidates->push_back(candidate);
+      continue;  // Parse candidates separately.
     } else if (HasAttribute(line, kAttributeRtpmap)) {
       // a=rtpmap:<payload type> <encoding name>/<clock rate>
       // [/<encodingparameters>]
@@ -715,4 +704,73 @@
   return true;
 }
 
+bool ParseCandidates(const std::string& message,
+                     std::vector<Candidate>* candidates) {
+  ASSERT(candidates != NULL);
+  std::string line;
+  size_t pos = 0;
+
+  // Loop until the next attribute line.
+  while (GetLine(message, &pos, &line)) {
+    if (!HasPrefix(line, kLinePrefixAttributes) ||
+        !HasAttribute(line, kAttributeCandidate)) {
+      continue;  // Only parse candidates
+    }
+    std::vector<std::string> fields;
+    talk_base::split(line.substr(kLinePrefixLength), kSdpDelimiter, &fields);
+    // a=candidate:<foundation> <component-id> <transport> <priority>
+    // <connection-address> <port> typ <candidate-types>
+    // [raddr <connection-address>] [rport <port>]
+    // *(SP extension-att-name SP extension-att-value)
+    // 8 mandatory fields
+    if (fields.size() < 8 || (fields[6] != kAttributeCandidateTyp)) {
+      LOG_LINE_PARSING_ERROR(line);
+      return false;
+    }
+    const std::string transport = fields[2];
+    const float priority = talk_base::FromString<float>(fields[3]);
+    const std::string connection_address = fields[4];
+    const int port = talk_base::FromString<int>(fields[5]);
+    std::string candidate_type;
+    const std::string type = fields[7];
+    if (type == kCandidateHost) {
+      candidate_type = cricket::LOCAL_PORT_TYPE;
+    } else if (type == kCandidateSrflx) {
+      candidate_type = cricket::STUN_PORT_TYPE;
+    } else if (type == kCandidateRelay) {
+      candidate_type = cricket::RELAY_PORT_TYPE;
+    } else {
+      LOG(LS_ERROR) << "Unsupported candidate type from line: " << line;
+      return false;
+    }
+
+    // extension
+    std::string name;
+    std::string network_name;
+    std::string username;
+    std::string password;
+    uint32 generation = 0;
+    for (size_t i = 8; i < (fields.size() - 1); ++i) {
+      const std::string field = fields.at(i);
+      if (field == kAttributeCandidateName) {
+        name = fields.at(++i);
+      } else if (field == kAttributeCandidateNetworkName) {
+        network_name = fields.at(++i);
+      } else if (field == kAttributeCandidateUsername) {
+        username = fields.at(++i);
+      } else if (field == kAttributeCandidatePassword) {
+        password = fields.at(++i);
+      } else if (field == kAttributeCandidateGeneration) {
+        generation = talk_base::FromString<uint32>(fields.at(++i));
+      }
+    }
+
+    SocketAddress address(connection_address, port);
+    Candidate candidate(name, transport, address, priority, username,
+        password, candidate_type, network_name, generation);
+    candidates->push_back(candidate);
+  }
+  return true;
+}
+
 }  // namespace webrtc
diff --git a/talk/app/webrtc/webrtcsdp.h b/talk/app/webrtc/webrtcsdp.h
index 32131b1..e5c1b12 100644
--- a/talk/app/webrtc/webrtcsdp.h
+++ b/talk/app/webrtc/webrtcsdp.h
@@ -48,13 +48,23 @@
 
 namespace webrtc {
 
-// Serializes the passed in SessionDescription and Candidates to an SDP string.
+// Serializes the passed in SessionDescription and Candidates to a SDP string.
 // desc - The SessionDescription object to be serialized.
 // candidates - The Set of Candidate objects to be serialized.
 // return - SDP string serialized from the arguments.
 std::string SdpSerialize(const cricket::SessionDescription& desc,
                          const std::vector<cricket::Candidate>& candidates);
 
+// Serializes the passed in SessionDescription to a SDP string.
+// desc - The SessionDescription object to be serialized.
+std::string SdpSerializeSessionDescription(
+    const cricket::SessionDescription& desc);
+
+// Serializes the passed in Candidates to a SDP string.
+// candidates - The Set of Candidate objects to be serialized.
+std::string SdpSerializeCandidates(
+    const std::vector<cricket::Candidate>& candidates);
+
 // Deserializes the passed in SDP string to a SessionDescription and Candidates.
 // message - SDP string to be Deserialized.
 // desc - The SessionDescription object deserialized from the SDP string.
@@ -64,6 +74,26 @@
                     cricket::SessionDescription* desc,
                     std::vector<cricket::Candidate>* candidates);
 
+// Deserializes the passed in SDP string to a SessionDescription.
+// Candidates are ignored.
+// message - SDP string to be Deserialized.
+// desc - The SessionDescription object deserialized from the SDP string.
+// return - true on success, false on failure.
+bool SdpDeserializeSessionDescription(const std::string& message,
+                                      cricket::SessionDescription* desc);
+
+// Deserializes the passed in SDP string to Candidates.
+// Only the candidates are parsed from the SDP string.
+// message - SDP string to be Deserialized.
+// candidates - The set of Candidate deserialized from the SDP string.
+// return - true on success, false on failure.
+bool SdpDeserializeCandidates(const std::string& message,
+                              std::vector<cricket::Candidate>* candidates);
+
+// Formats a correct SDP string by reformatting a session description and
+// candidates.
+std::string SdpFormat(const std::string& desc, const std::string& candidates);
+
 }  // namespace webrtc
 
 #endif  // TALK_APP_WEBRTC_WEBRTCSDP_H_
diff --git a/talk/app/webrtc/webrtcsdp_unittest.cc b/talk/app/webrtc/webrtcsdp_unittest.cc
index 7e34d2c..dbc7ccd 100644
--- a/talk/app/webrtc/webrtcsdp_unittest.cc
+++ b/talk/app/webrtc/webrtcsdp_unittest.cc
@@ -46,6 +46,46 @@
 using cricket::VideoContentDescription;
 
 // Reference sdp string
+static const char kSdpFullString[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=\r\n"
+    "t=0 0\r\n"
+    "a=group:BUNDLE audio video\r\n"
+    "m=audio 0 RTP/AVPF 103 104\r\n"
+    "a=candidate:1 1 udp 1 127.0.0.1 1234 typ host name rtp network_name "
+    "eth0 username user_rtp password password_rtp generation 0\r\n"
+    "a=candidate:1 1 udp 1 127.0.0.1 1235 typ host name rtcp network_name "
+    "eth0 username user_rtcp password password_rtcp generation 0\r\n"
+    "a=mid:audio\r\n"
+    "a=rtcp-mux\r\n"
+    "a=crypto:1 AES_CM_128_HMAC_SHA1_32 "
+    "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32 \r\n"
+    "a=rtpmap:103 ISAC/16000\r\n"
+    "a=rtpmap:104 ISAC/32000\r\n"
+    "a=ssrc:1 cname:stream_1_cname mslabel:local_stream_1 "
+    "label:local_audio_1\r\n"
+    "a=ssrc:4 cname:stream_2_cname mslabel:local_stream_2 "
+    "label:local_audio_2\r\n"
+    "m=video 0 RTP/AVPF 120\r\n"
+    "a=candidate:1 1 udp 1 127.0.0.1 1236 typ host name video_rtcp "
+    "network_name eth0 username user_video_rtcp password password_video_rtcp "
+    "generation 0\r\n"
+    "a=candidate:1 1 udp 1 127.0.0.1 1237 typ host name video_rtp "
+    "network_name eth0 username user_video_rtp password password_video_rtp "
+    "generation 0\r\n"
+    "a=mid:video\r\n"
+    "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
+    "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32 \r\n"
+    "a=rtpmap:120 VP8/0\r\n"
+    "a=ssrc:2 cname:stream_1_cname mslabel:local_stream_1 "
+    "label:local_video_1\r\n"
+    "a=ssrc:3 cname:stream_1_cname mslabel:local_stream_1 "
+    "label:local_video_2\r\n"
+    "a=ssrc:5 cname:stream_2_cname mslabel:local_stream_2 "
+    "label:local_video_3\r\n";
+
+// SDP reference string without the candidates.
 static const char kSdpString[] =
     "v=0\r\n"
     "o=- 0 0 IN IP4 127.0.0.1\r\n"
@@ -59,10 +99,6 @@
     "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32 \r\n"
     "a=rtpmap:103 ISAC/16000\r\n"
     "a=rtpmap:104 ISAC/32000\r\n"
-    "a=candidate:1 1 udp 1 127.0.0.1 1234 typ host name rtp network_name "
-    "eth0 username user_rtp password password_rtp generation 0\r\n"
-    "a=candidate:1 1 udp 1 127.0.0.1 1235 typ host name rtcp network_name "
-    "eth0 username user_rtcp password password_rtcp generation 0\r\n"
     "a=ssrc:1 cname:stream_1_cname mslabel:local_stream_1 "
     "label:local_audio_1\r\n"
     "a=ssrc:4 cname:stream_2_cname mslabel:local_stream_2 "
@@ -72,12 +108,6 @@
     "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
     "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32 \r\n"
     "a=rtpmap:120 VP8/0\r\n"
-    "a=candidate:1 1 udp 1 127.0.0.1 1236 typ host name video_rtcp "
-    "network_name eth0 username user_video_rtcp password password_video_rtcp "
-    "generation 0\r\n"
-    "a=candidate:1 1 udp 1 127.0.0.1 1237 typ host name video_rtp "
-    "network_name eth0 username user_video_rtp password password_video_rtp "
-    "generation 0\r\n"
     "a=ssrc:2 cname:stream_1_cname mslabel:local_stream_1 "
     "label:local_video_1\r\n"
     "a=ssrc:3 cname:stream_1_cname mslabel:local_stream_1 "
@@ -85,6 +115,19 @@
     "a=ssrc:5 cname:stream_2_cname mslabel:local_stream_2 "
     "label:local_video_3\r\n";
 
+// Candidates reference string.
+static const char kSdpCandidates[] =
+    "a=candidate:1 1 udp 1 127.0.0.1 1234 typ host name rtp network_name "
+    "eth0 username user_rtp password password_rtp generation 0\r\n"
+    "a=candidate:1 1 udp 1 127.0.0.1 1235 typ host name rtcp network_name "
+    "eth0 username user_rtcp password password_rtcp generation 0\r\n"
+    "a=candidate:1 1 udp 1 127.0.0.1 1236 typ host name video_rtcp "
+    "network_name eth0 username user_video_rtcp password password_video_rtcp "
+    "generation 0\r\n"
+    "a=candidate:1 1 udp 1 127.0.0.1 1237 typ host name video_rtp "
+    "network_name eth0 username user_video_rtp password password_video_rtp "
+    "generation 0\r\n";
+
 static const char kSdpDestroyer[] = "!@#$%^&";
 
 // MediaStream 1
@@ -201,6 +244,10 @@
     // cryptos
     EXPECT_EQ(acd1->cryptos().size(), acd2->cryptos().size());
     EXPECT_EQ(vcd1->cryptos().size(), vcd2->cryptos().size());
+    if (acd1->cryptos().size() != acd2->cryptos().size() ||
+        vcd1->cryptos().size() != vcd2->cryptos().size()) {
+      return false;
+    }
     for (size_t i = 0; i< acd1->cryptos().size(); ++i) {
       const CryptoParams c1 = acd1->cryptos().at(i);
       const CryptoParams c2 = acd2->cryptos().at(i);
@@ -214,7 +261,11 @@
 
     // codecs
     EXPECT_EQ(acd1->codecs().size(), acd2->codecs().size());
+    if (acd1->codecs().size() != acd2->codecs().size())
+      return false;
     EXPECT_EQ(vcd1->codecs().size(), vcd2->codecs().size());
+    if (vcd1->codecs().size() != vcd2->codecs().size())
+      return false;
     for (size_t i = 0; i< acd1->codecs().size(); ++i) {
       const AudioCodec c1 = acd1->codecs().at(i);
       const AudioCodec c2 = acd2->codecs().at(i);
@@ -238,7 +289,8 @@
 
   bool CompareCandidates(const Candidates& cs1, const Candidates& cs2) {
     EXPECT_EQ(cs1.size(), cs2.size());
-
+    if (cs1.size() != cs2.size())
+      return false;
     for (size_t i = 0; i< cs1.size(); ++i) {
       const cricket::Candidate c1 = cs1.at(i);
       const cricket::Candidate c2 = cs2.at(i);
@@ -250,7 +302,7 @@
   bool ReplaceAndTryToParse(const char* search, const char* replace) {
     SessionDescription desc;
     std::vector<cricket::Candidate> candidates;
-    std::string sdp = kSdpString;
+    std::string sdp = kSdpFullString;
     talk_base::replace_substrs(search, strlen(search), replace,
         strlen(replace), &sdp);
     return webrtc::SdpDeserialize(sdp, &desc, &candidates);
@@ -264,17 +316,38 @@
 TEST_F(WebRtcSdpTest, Serialize) {
   std::string message = webrtc::SdpSerialize(desc_, candidates_);
   LOG(LS_INFO) << "SDP: " << message;
+  EXPECT_EQ(std::string(kSdpFullString), message);
+}
+
+TEST_F(WebRtcSdpTest, SerializeSessionDescription) {
+  std::string message = webrtc::SdpSerializeSessionDescription(desc_);
   EXPECT_EQ(std::string(kSdpString), message);
 }
 
+TEST_F(WebRtcSdpTest, SerializeCandidates) {
+  std::string message = webrtc::SdpSerializeCandidates(candidates_);
+  EXPECT_EQ(std::string(kSdpCandidates), message);
+}
+
 TEST_F(WebRtcSdpTest, Deserialize) {
   SessionDescription desc;
   std::vector<cricket::Candidate> candidates;
   // Deserialize
-  EXPECT_TRUE(webrtc::SdpDeserialize(kSdpString, &desc, &candidates));
+  EXPECT_TRUE(webrtc::SdpDeserialize(kSdpFullString, &desc, &candidates));
   // Verify
   LOG(LS_INFO) << "SDP: " << webrtc::SdpSerialize(desc, candidates);
   EXPECT_TRUE(CompareSessionDescription(desc_, desc));
+}
+
+TEST_F(WebRtcSdpTest, DeserializeSessionDescription) {
+  SessionDescription desc;
+  EXPECT_TRUE(webrtc::SdpDeserializeSessionDescription(kSdpString, &desc));
+  EXPECT_TRUE(CompareSessionDescription(desc_, desc));
+}
+
+TEST_F(WebRtcSdpTest, DeserializeCandidates) {
+  std::vector<cricket::Candidate> candidates;
+  EXPECT_TRUE(webrtc::SdpDeserializeCandidates(kSdpCandidates, &candidates));
   EXPECT_TRUE(CompareCandidates(candidates_, candidates));
 }
 
@@ -294,3 +367,8 @@
   // Broken media description
   EXPECT_EQ(true, ReplaceAndTryToParse("video 0 RTP/AVPF", kSdpDestroyer));
 }
+
+TEST_F(WebRtcSdpTest, FormatSdp) {
+  std::string full_sdp = webrtc::SdpFormat(kSdpString, kSdpCandidates);
+  EXPECT_EQ(kSdpFullString, full_sdp);
+}
diff --git a/talk/base/nat_unittest.cc b/talk/base/nat_unittest.cc
index a7fc3b1..8f87b3a 100644
--- a/talk/base/nat_unittest.cc
+++ b/talk/base/nat_unittest.cc
@@ -218,7 +218,7 @@
   explicit TestVirtualSocketServer(SocketServer* ss)
       : VirtualSocketServer(ss) {}
   // Expose this publicly
-  uint32 GetNextIP() { return VirtualSocketServer::GetNextIP(); }
+  IPAddress GetNextIP(int af) { return VirtualSocketServer::GetNextIP(af); }
 };
 
 TEST(NatTest, TestVirtual) {
@@ -227,10 +227,11 @@
   TestVirtualSocketServer* ext_vss = new TestVirtualSocketServer(
       new PhysicalSocketServer());
 
+  // TODO: IPv6ize this test when the NAT stuff is v6ed.
   SocketAddress int_addr, ext_addrs[4];
-  int_addr.SetIP(IPAddress(int_vss->GetNextIP()));
-  ext_addrs[0].SetIP(IPAddress(ext_vss->GetNextIP()));
-  ext_addrs[1].SetIP(IPAddress(ext_vss->GetNextIP()));
+  int_addr.SetIP(int_vss->GetNextIP(int_addr.ipaddr().family()));
+  ext_addrs[0].SetIP(ext_vss->GetNextIP(int_addr.ipaddr().family()));
+  ext_addrs[1].SetIP(ext_vss->GetNextIP(int_addr.ipaddr().family()));
   ext_addrs[2].SetIP(ext_addrs[0].ipaddr());
   ext_addrs[3].SetIP(ext_addrs[1].ipaddr());
 
diff --git a/talk/base/natserver.cc b/talk/base/natserver.cc
index 7107f77..d287059 100644
--- a/talk/base/natserver.cc
+++ b/talk/base/natserver.cc
@@ -2,26 +2,26 @@
  * libjingle
  * Copyright 2004--2005, Google Inc.
  *
- * Redistribution and use in source and binary forms, with or without 
+ * 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, 
+ *  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 
+ *  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 
+ * 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, 
+ * 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 
+ * 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.
  */
 
diff --git a/talk/base/socket.h b/talk/base/socket.h
index a55b3dc..ad8eee6 100644
--- a/talk/base/socket.h
+++ b/talk/base/socket.h
@@ -180,9 +180,10 @@
 
   enum Option {
     OPT_DONTFRAGMENT,
-    OPT_RCVBUF,  // receive buffer size
-    OPT_SNDBUF,  // send buffer size
-    OPT_NODELAY  // whether Nagle algorithm is enabled
+    OPT_RCVBUF,      // receive buffer size
+    OPT_SNDBUF,      // send buffer size
+    OPT_NODELAY,     // whether Nagle algorithm is enabled
+    OPT_IPV6_V6ONLY  // Whether the socket is IPv6 only.
   };
   virtual int GetOption(Option opt, int* value) = 0;
   virtual int SetOption(Option opt, int value) = 0;
diff --git a/talk/base/virtualsocket_unittest.cc b/talk/base/virtualsocket_unittest.cc
index 1c44fe7..93fb5ef 100644
--- a/talk/base/virtualsocket_unittest.cc
+++ b/talk/base/virtualsocket_unittest.cc
@@ -26,7 +26,9 @@
  */
 
 #include <time.h>
-
+#ifdef POSIX
+#include <netinet/in.h>
+#endif
 #include <cmath>
 
 #include "talk/base/logging.h"
@@ -39,487 +41,6 @@
 
 using namespace talk_base;
 
-class VirtualSocketServerTest : public testing::Test {
- public:
-  VirtualSocketServerTest() : ss_(new VirtualSocketServer(NULL)) {
-  }
-
- protected:
-  virtual void SetUp() {
-    Thread::Current()->set_socketserver(ss_);
-  }
-  virtual void TearDown() {
-    Thread::Current()->set_socketserver(NULL);
-  }
-
-  VirtualSocketServer* ss_;
-};
-
-TEST_F(VirtualSocketServerTest, basic) {
-  SocketAddress addr1(IPAddress(INADDR_ANY), 5000);
-  AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
-  socket->Bind(addr1);
-  addr1 = socket->GetLocalAddress();
-
-  TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
-  AsyncSocket* socket2 = ss_->CreateAsyncSocket(SOCK_DGRAM);
-  TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
-
-  SocketAddress addr2;
-  EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
-  EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr2));
-
-  SocketAddress addr3;
-  EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr2));
-  EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr3));
-  EXPECT_EQ(addr3, addr1);
-
-  for (int i = 0; i < 10; i++) {
-    client2 = new TestClient(AsyncUDPSocket::Create(ss_, SocketAddress()));
-
-    SocketAddress addr4;
-    EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
-    EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr4));
-    EXPECT_EQ(addr4.ipaddr().v4AddressAsHostOrderInteger(),
-              addr2.ipaddr().v4AddressAsHostOrderInteger() + 1);
-    EXPECT_EQ(addr4.port(), addr2.port() + 1);
-
-    SocketAddress addr5;
-    EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr4));
-    EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr5));
-    EXPECT_EQ(addr5, addr1);
-
-    addr2 = addr4;
-  }
-}
-
-TEST_F(VirtualSocketServerTest, connect) {
-  testing::StreamSink sink;
-  SocketAddress accept_addr;
-  const SocketAddress kEmptyAddr;
-
-  // Create client
-  AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(client);
-  EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
-  EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
-
-  // Create server
-  AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(server);
-  EXPECT_NE(0, server->Listen(5));  // Bind required
-  EXPECT_EQ(0, server->Bind(kEmptyAddr));
-  EXPECT_EQ(0, server->Listen(5));
-  EXPECT_EQ(server->GetState(), AsyncSocket::CS_CONNECTING);
-
-  // No pending server connections
-  EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
-  EXPECT_TRUE(NULL == server->Accept(&accept_addr));
-  EXPECT_EQ(accept_addr, kEmptyAddr);
-
-  // Attempt connect to listening socket
-  EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
-  EXPECT_NE(client->GetLocalAddress(), kEmptyAddr);  // Implicit Bind
-  EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress());
-
-  // Client is connecting
-  EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
-  EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
-  EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
-
-  ss_->ProcessMessagesUntilIdle();
-
-  // Client still connecting
-  EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
-  EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
-  EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
-
-  // Server has pending connection
-  EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
-  Socket* accepted = server->Accept(&accept_addr);
-  EXPECT_TRUE(NULL != accepted);
-  EXPECT_NE(accept_addr, kEmptyAddr);
-  EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
-
-  EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
-  EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress());
-  EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
-
-  ss_->ProcessMessagesUntilIdle();
-
-  // Client has connected
-  EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTED);
-  EXPECT_TRUE(sink.Check(client, testing::SSE_OPEN));
-  EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
-  EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
-  EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
-}
-
-TEST_F(VirtualSocketServerTest, connect_to_non_listener) {
-  testing::StreamSink sink;
-  SocketAddress accept_addr;
-  const SocketAddress kEmptyAddr;
-
-  // Create client
-  AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(client);
-
-  // Create server
-  AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(server);
-  EXPECT_EQ(0, server->Bind(kEmptyAddr));
-
-  // Attempt connect to non-listening socket
-  EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
-
-  ss_->ProcessMessagesUntilIdle();
-
-  // No pending server connections
-  EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
-  EXPECT_TRUE(NULL == server->Accept(&accept_addr));
-  EXPECT_EQ(accept_addr, kEmptyAddr);
-
-  // Connection failed
-  EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
-  EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
-  EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
-  EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
-}
-
-TEST_F(VirtualSocketServerTest, close_during_connect) {
-  testing::StreamSink sink;
-  SocketAddress accept_addr;
-  const SocketAddress kEmptyAddr;
-
-  // Create client and server
-  AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(client);
-  AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(server);
-
-  // Initiate connect
-  EXPECT_EQ(0, server->Bind(kEmptyAddr));
-  EXPECT_EQ(0, server->Listen(5));
-  EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
-
-  // Server close before socket enters accept queue
-  EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
-  server->Close();
-
-  ss_->ProcessMessagesUntilIdle();
-
-  // Result: connection failed
-  EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
-  EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
-
-  // New server
-  delete server;
-  server = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(server);
-
-  // Initiate connect
-  EXPECT_EQ(0, server->Bind(kEmptyAddr));
-  EXPECT_EQ(0, server->Listen(5));
-  EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
-
-  ss_->ProcessMessagesUntilIdle();
-
-  // Server close while socket is in accept queue
-  EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
-  server->Close();
-
-  ss_->ProcessMessagesUntilIdle();
-
-  // Result: connection failed
-  EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
-  EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
-
-  // New server
-  delete server;
-  server = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(server);
-
-  // Initiate connect
-  EXPECT_EQ(0, server->Bind(kEmptyAddr));
-  EXPECT_EQ(0, server->Listen(5));
-  EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
-
-  ss_->ProcessMessagesUntilIdle();
-
-  // Server accepts connection
-  EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
-  AsyncSocket* accepted = server->Accept(&accept_addr);
-  ASSERT_TRUE(NULL != accepted);
-  sink.Monitor(accepted);
-
-  // Client closes before connection complets
-  EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
-
-  // Connected message has not been processed yet.
-  EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
-  client->Close();
-
-  ss_->ProcessMessagesUntilIdle();
-
-  // Result: accepted socket closes
-  EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED);
-  EXPECT_TRUE(sink.Check(accepted, testing::SSE_CLOSE));
-  EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
-}
-
-TEST_F(VirtualSocketServerTest, close) {
-  testing::StreamSink sink;
-  const SocketAddress kEmptyAddr;
-
-  // Create clients
-  AsyncSocket* a = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(a);
-  a->Bind(kEmptyAddr);
-
-  AsyncSocket* b = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(b);
-  b->Bind(kEmptyAddr);
-
-  EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
-  EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
-
-  ss_->ProcessMessagesUntilIdle();
-
-  EXPECT_TRUE(sink.Check(a, testing::SSE_OPEN));
-  EXPECT_EQ(a->GetState(), AsyncSocket::CS_CONNECTED);
-  EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress());
-
-  EXPECT_TRUE(sink.Check(b, testing::SSE_OPEN));
-  EXPECT_EQ(b->GetState(), AsyncSocket::CS_CONNECTED);
-  EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress());
-
-  EXPECT_EQ(1, a->Send("a", 1));
-  b->Close();
-  EXPECT_EQ(1, a->Send("b", 1));
-
-  ss_->ProcessMessagesUntilIdle();
-
-  char buffer[10];
-  EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
-  EXPECT_EQ(-1, b->Recv(buffer, 10));
-
-  EXPECT_TRUE(sink.Check(a, testing::SSE_CLOSE));
-  EXPECT_EQ(a->GetState(), AsyncSocket::CS_CLOSED);
-  EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
-
-  EXPECT_FALSE(sink.Check(b, testing::SSE_CLOSE));  // No signal for Closer
-  EXPECT_EQ(b->GetState(), AsyncSocket::CS_CLOSED);
-  EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
-}
-
-TEST_F(VirtualSocketServerTest, tcp_send) {
-  testing::StreamSink sink;
-  const SocketAddress kEmptyAddr;
-
-  // Connect two sockets
-  AsyncSocket* a = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(a);
-  a->Bind(kEmptyAddr);
-
-  AsyncSocket* b = ss_->CreateAsyncSocket(SOCK_STREAM);
-  sink.Monitor(b);
-  b->Bind(kEmptyAddr);
-
-  EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
-  EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
-
-  ss_->ProcessMessagesUntilIdle();
-
-  const size_t kBufferSize = 2000;
-  ss_->set_send_buffer_capacity(kBufferSize);
-  ss_->set_recv_buffer_capacity(kBufferSize);
-
-  const size_t kDataSize = 5000;
-  char send_buffer[kDataSize], recv_buffer[kDataSize];
-  for (size_t i = 0; i < kDataSize; ++i) send_buffer[i] = i;
-  memset(recv_buffer, 0, sizeof(recv_buffer));
-  size_t send_pos = 0, recv_pos = 0;
-
-  // Can't send more than send buffer in one write
-  int result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
-  EXPECT_EQ(static_cast<int>(kBufferSize), result);
-  send_pos += result;
-
-  ss_->ProcessMessagesUntilIdle();
-  EXPECT_FALSE(sink.Check(a, testing::SSE_WRITE));
-  EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
-
-  // Receive buffer is already filled, fill send buffer again
-  result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
-  EXPECT_EQ(static_cast<int>(kBufferSize), result);
-  send_pos += result;
-
-  ss_->ProcessMessagesUntilIdle();
-  EXPECT_FALSE(sink.Check(a, testing::SSE_WRITE));
-  EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
-
-  // No more room in send or receive buffer
-  result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
-  EXPECT_EQ(-1, result);
-  EXPECT_TRUE(a->IsBlocking());
-
-  // Read a subset of the data
-  result = b->Recv(recv_buffer + recv_pos, 500);
-  EXPECT_EQ(500, result);
-  recv_pos += result;
-
-  ss_->ProcessMessagesUntilIdle();
-  EXPECT_TRUE(sink.Check(a, testing::SSE_WRITE));
-  EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
-
-  // Room for more on the sending side
-  result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
-  EXPECT_EQ(500, result);
-  send_pos += result;
-
-  // Empty the recv buffer
-  while (true) {
-    result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
-    if (result < 0) {
-      EXPECT_EQ(-1, result);
-      EXPECT_TRUE(b->IsBlocking());
-      break;
-    }
-    recv_pos += result;
-  }
-
-  ss_->ProcessMessagesUntilIdle();
-  EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
-
-  // Continue to empty the recv buffer
-  while (true) {
-    result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
-    if (result < 0) {
-      EXPECT_EQ(-1, result);
-      EXPECT_TRUE(b->IsBlocking());
-      break;
-    }
-    recv_pos += result;
-  }
-
-  // Send last of the data
-  result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
-  EXPECT_EQ(500, result);
-  send_pos += result;
-
-  ss_->ProcessMessagesUntilIdle();
-  EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
-
-  // Receive the last of the data
-  while (true) {
-    result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
-    if (result < 0) {
-      EXPECT_EQ(-1, result);
-      EXPECT_TRUE(b->IsBlocking());
-      break;
-    }
-    recv_pos += result;
-  }
-
-  ss_->ProcessMessagesUntilIdle();
-  EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
-
-  // The received data matches the sent data
-  EXPECT_EQ(kDataSize, send_pos);
-  EXPECT_EQ(kDataSize, recv_pos);
-  EXPECT_EQ(0, memcmp(recv_buffer, send_buffer, kDataSize));
-}
-
-TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) {
-  const uint32 kTestMean[] = { 10, 100, 333, 1000 };
-  const double kTestDev[] = { 0.25, 0.1, 0.01 };
-  // TODO: The current code only works for 1000 data points or more.
-  const uint32 kTestSamples[] = { /*10, 100,*/ 1000 };
-  for (size_t midx = 0; midx < ARRAY_SIZE(kTestMean); ++midx) {
-    for (size_t didx = 0; didx < ARRAY_SIZE(kTestDev); ++didx) {
-      for (size_t sidx = 0; sidx < ARRAY_SIZE(kTestSamples); ++sidx) {
-        ASSERT_LT(0u, kTestSamples[sidx]);
-        const uint32 kStdDev =
-            static_cast<uint32>(kTestDev[didx] * kTestMean[midx]);
-        VirtualSocketServer::Function* f =
-            VirtualSocketServer::CreateDistribution(kTestMean[midx],
-                                                    kStdDev,
-                                                    kTestSamples[sidx]);
-        ASSERT_TRUE(NULL != f);
-        ASSERT_EQ(kTestSamples[sidx], f->size());
-        double sum = 0;
-        for (uint32 i = 0; i < f->size(); ++i) {
-          sum += (*f)[i].second;
-        }
-        const double mean = sum / f->size();
-        double sum_sq_dev = 0;
-        for (uint32 i = 0; i < f->size(); ++i) {
-          double dev = (*f)[i].second - mean;
-          sum_sq_dev += dev * dev;
-        }
-        const double stddev = std::sqrt(sum_sq_dev / f->size());
-        EXPECT_NEAR(kTestMean[midx], mean, 0.1 * kTestMean[midx])
-          << "M=" << kTestMean[midx]
-          << " SD=" << kStdDev
-          << " N=" << kTestSamples[sidx];
-        EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
-          << "M=" << kTestMean[midx]
-          << " SD=" << kStdDev
-          << " N=" << kTestSamples[sidx];
-        delete f;
-      }
-    }
-  }
-}
-
-TEST_F(VirtualSocketServerTest, TcpSendsPacketsInOrder) {
-  const SocketAddress kEmptyAddr;
-
-  // Connect two sockets
-  AsyncSocket* a = ss_->CreateAsyncSocket(SOCK_STREAM);
-  AsyncSocket* b = ss_->CreateAsyncSocket(SOCK_STREAM);
-  a->Bind(kEmptyAddr);
-  b->Bind(kEmptyAddr);
-  EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
-  EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
-  ss_->ProcessMessagesUntilIdle();
-
-  // First, deliver all packets in 0 ms.
-  char buffer[2] = { 0, 0 };
-  const size_t cNumPackets = 10;
-  for (size_t i = 0; i < cNumPackets; ++i) {
-    buffer[0] = '0' + i;
-    EXPECT_EQ(1, a->Send(buffer, 1));
-  }
-
-  ss_->ProcessMessagesUntilIdle();
-
-  for (size_t i = 0; i < cNumPackets; ++i) {
-    EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer)));
-    EXPECT_EQ(static_cast<char>('0' + i), buffer[0]);
-  }
-
-  // Next, deliver packets at random intervals
-  const uint32 mean = 50;
-  const uint32 stddev = 50;
-
-  ss_->set_delay_mean(mean);
-  ss_->set_delay_stddev(stddev);
-  ss_->UpdateDelayDistribution();
-
-  for (size_t i = 0; i < cNumPackets; ++i) {
-    buffer[0] = 'A' + i;
-    EXPECT_EQ(1, a->Send(buffer, 1));
-  }
-
-  ss_->ProcessMessagesUntilIdle();
-
-  for (size_t i = 0; i < cNumPackets; ++i) {
-    EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer)));
-    EXPECT_EQ(static_cast<char>('A' + i), buffer[0]);
-  }
-}
-
 // Sends at a constant rate but with random packet sizes.
 struct Sender : public MessageHandler {
   Sender(Thread* th, AsyncSocket* s, uint32 rt)
@@ -616,71 +137,873 @@
   uint32 samples;
 };
 
-TEST_F(VirtualSocketServerTest, bandwidth) {
-  AsyncSocket* send_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
-  AsyncSocket* recv_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
-  ASSERT_EQ(0, send_socket->Bind(SocketAddress(IPAddress(INADDR_ANY), 1000)));
-  ASSERT_EQ(0, recv_socket->Bind(SocketAddress(IPAddress(INADDR_ANY), 1000)));
-  ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
+class VirtualSocketServerTest : public testing::Test {
+ public:
+  VirtualSocketServerTest() : ss_(new VirtualSocketServer(NULL)),
+                              kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
+                              kIPv6AnyAddress(IPAddress(in6addr_any), 0) {
+  }
 
-  uint32 bandwidth = 64 * 1024;
-  ss_->set_bandwidth(bandwidth);
+  void CheckAddressIncrementalization(const SocketAddress& post,
+                                      const SocketAddress& pre) {
+    EXPECT_EQ(post.port(), pre.port() + 1);
+    IPAddress post_ip = post.ipaddr();
+    IPAddress pre_ip = pre.ipaddr();
+    EXPECT_EQ(pre_ip.family(), post_ip.family());
+    if (post_ip.family() == AF_INET) {
+      in_addr pre_ipv4 = pre_ip.ipv4_address();
+      in_addr post_ipv4 = post_ip.ipv4_address();
+      int difference = ntohl(post_ipv4.s_addr) - ntohl(pre_ipv4.s_addr);
+      EXPECT_EQ(1, difference);
+    } else if (post_ip.family() == AF_INET6) {
+      in6_addr post_ip6 = post_ip.ipv6_address();
+      in6_addr pre_ip6 = pre_ip.ipv6_address();
+      uint32* post_as_ints = reinterpret_cast<uint32*>(&post_ip6.s6_addr);
+      uint32* pre_as_ints = reinterpret_cast<uint32*>(&pre_ip6.s6_addr);
+      EXPECT_EQ(post_as_ints[3], pre_as_ints[3] + 1);
+    }
+  }
 
-  Thread* pthMain = Thread::Current();
-  Sender sender(pthMain, send_socket, 80 * 1024);
-  Receiver receiver(pthMain, recv_socket, bandwidth);
+  void BasicTest(const SocketAddress& initial_addr) {
+    AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+    socket->Bind(initial_addr);
+    SocketAddress server_addr = socket->GetLocalAddress();
+    // Make sure VSS didn't switch families on us.
+    EXPECT_EQ(server_addr.ipaddr().family(),
+              initial_addr.ipaddr().family());
 
-  pthMain->ProcessMessages(5000);
-  sender.done = true;
-  pthMain->ProcessMessages(5000);
+    TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+    AsyncSocket* socket2 = ss_->CreateAsyncSocket(SOCK_DGRAM);
+    TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
 
-  ASSERT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
-  ASSERT_TRUE(receiver.count <= 6 * bandwidth);  // queue could drain for 1 sec
+    SocketAddress client2_addr;
+    EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
+    EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
 
-  ss_->set_bandwidth(0);
+    SocketAddress client1_addr;
+    EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
+    EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
+    EXPECT_EQ(client1_addr, server_addr);
+
+    for (int i = 0; i < 10; i++) {
+      client2 = new TestClient(AsyncUDPSocket::Create(ss_, SocketAddress()));
+
+      SocketAddress next_client2_addr;
+      EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
+      EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
+      CheckAddressIncrementalization(next_client2_addr, client2_addr);
+      // EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
+
+      SocketAddress server_addr2;
+      EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
+      EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
+      EXPECT_EQ(server_addr2, server_addr);
+
+      client2_addr = next_client2_addr;
+    }
+  }
+
+  // initial_addr should be made from either INADDR_ANY or in6addr_any.
+  void ConnectTest(const SocketAddress& initial_addr) {
+    testing::StreamSink sink;
+    SocketAddress accept_addr;
+    const SocketAddress kEmptyAddr;
+
+    // Create client
+    AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(client);
+    EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+    EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
+
+    // Create server
+    AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(server);
+    EXPECT_NE(0, server->Listen(5));  // Bind required
+    EXPECT_EQ(0, server->Bind(initial_addr));
+    EXPECT_EQ(server->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+    EXPECT_EQ(0, server->Listen(5));
+    EXPECT_EQ(server->GetState(), AsyncSocket::CS_CONNECTING);
+
+    // No pending server connections
+    EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+    EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+    EXPECT_EQ(accept_addr, kEmptyAddr);
+
+    // Attempt connect to listening socket
+    EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+    EXPECT_NE(client->GetLocalAddress(), kEmptyAddr);  // Implicit Bind
+    EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress());
+
+    // Client is connecting
+    EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
+    EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
+    EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+
+    ss_->ProcessMessagesUntilIdle();
+
+    // Client still connecting
+    EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
+    EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
+    EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+
+    // Server has pending connection
+    EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
+    Socket* accepted = server->Accept(&accept_addr);
+    EXPECT_TRUE(NULL != accepted);
+    EXPECT_NE(accept_addr, kEmptyAddr);
+    EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
+
+    EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
+    EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress());
+    EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
+
+    ss_->ProcessMessagesUntilIdle();
+
+    // Client has connected
+    EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTED);
+    EXPECT_TRUE(sink.Check(client, testing::SSE_OPEN));
+    EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+    EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
+    EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
+  }
+
+  void ConnectToNonListenerTest(const SocketAddress& initial_addr) {
+    testing::StreamSink sink;
+    SocketAddress accept_addr;
+    const SocketAddress kEmptyAddr;
+
+    // Create client
+    AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(client);
+
+    // Create server
+    AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(server);
+    EXPECT_EQ(0, server->Bind(initial_addr));
+    EXPECT_EQ(server->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+    // Attempt connect to non-listening socket
+    EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+    ss_->ProcessMessagesUntilIdle();
+
+    // No pending server connections
+    EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+    EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+    EXPECT_EQ(accept_addr, kEmptyAddr);
+
+    // Connection failed
+    EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+    EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
+    EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
+    EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
+  }
+
+  void CloseDuringConnectTest(const SocketAddress& initial_addr) {
+    testing::StreamSink sink;
+    SocketAddress accept_addr;
+    const SocketAddress kEmptyAddr;
+
+    // Create client and server
+    AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(client);
+    AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(server);
+
+    // Initiate connect
+    EXPECT_EQ(0, server->Bind(initial_addr));
+    EXPECT_EQ(server->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+
+    EXPECT_EQ(0, server->Listen(5));
+    EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+    // Server close before socket enters accept queue
+    EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+    server->Close();
+
+    ss_->ProcessMessagesUntilIdle();
+
+    // Result: connection failed
+    EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+    EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
+
+    // New server
+    delete server;
+    server = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(server);
+
+    // Initiate connect
+    EXPECT_EQ(0, server->Bind(initial_addr));
+    EXPECT_EQ(server->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+
+    EXPECT_EQ(0, server->Listen(5));
+    EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+    ss_->ProcessMessagesUntilIdle();
+
+    // Server close while socket is in accept queue
+    EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
+    server->Close();
+
+    ss_->ProcessMessagesUntilIdle();
+
+    // Result: connection failed
+    EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+    EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
+
+    // New server
+    delete server;
+    server = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(server);
+
+    // Initiate connect
+    EXPECT_EQ(0, server->Bind(initial_addr));
+    EXPECT_EQ(server->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+
+    EXPECT_EQ(0, server->Listen(5));
+    EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+
+    ss_->ProcessMessagesUntilIdle();
+
+    // Server accepts connection
+    EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
+    AsyncSocket* accepted = server->Accept(&accept_addr);
+    ASSERT_TRUE(NULL != accepted);
+    sink.Monitor(accepted);
+
+    // Client closes before connection complets
+    EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
+
+    // Connected message has not been processed yet.
+    EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
+    client->Close();
+
+    ss_->ProcessMessagesUntilIdle();
+
+    // Result: accepted socket closes
+    EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED);
+    EXPECT_TRUE(sink.Check(accepted, testing::SSE_CLOSE));
+    EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
+  }
+
+  void CloseTest(const SocketAddress& initial_addr) {
+    testing::StreamSink sink;
+    const SocketAddress kEmptyAddr;
+
+    // Create clients
+    AsyncSocket* a = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(a);
+    a->Bind(initial_addr);
+    EXPECT_EQ(a->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+
+
+    AsyncSocket* b = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(b);
+    b->Bind(initial_addr);
+    EXPECT_EQ(b->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+
+    EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
+    EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
+
+    ss_->ProcessMessagesUntilIdle();
+
+    EXPECT_TRUE(sink.Check(a, testing::SSE_OPEN));
+    EXPECT_EQ(a->GetState(), AsyncSocket::CS_CONNECTED);
+    EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress());
+
+    EXPECT_TRUE(sink.Check(b, testing::SSE_OPEN));
+    EXPECT_EQ(b->GetState(), AsyncSocket::CS_CONNECTED);
+    EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress());
+
+    EXPECT_EQ(1, a->Send("a", 1));
+    b->Close();
+    EXPECT_EQ(1, a->Send("b", 1));
+
+    ss_->ProcessMessagesUntilIdle();
+
+    char buffer[10];
+    EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
+    EXPECT_EQ(-1, b->Recv(buffer, 10));
+
+    EXPECT_TRUE(sink.Check(a, testing::SSE_CLOSE));
+    EXPECT_EQ(a->GetState(), AsyncSocket::CS_CLOSED);
+    EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
+
+    EXPECT_FALSE(sink.Check(b, testing::SSE_CLOSE));  // No signal for Closer
+    EXPECT_EQ(b->GetState(), AsyncSocket::CS_CLOSED);
+    EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
+  }
+
+  void TcpSendTest(const SocketAddress& initial_addr) {
+    testing::StreamSink sink;
+    const SocketAddress kEmptyAddr;
+
+    // Connect two sockets
+    AsyncSocket* a = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(a);
+    a->Bind(initial_addr);
+    EXPECT_EQ(a->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+
+    AsyncSocket* b = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(b);
+    b->Bind(initial_addr);
+    EXPECT_EQ(b->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+
+    EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
+    EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
+
+    ss_->ProcessMessagesUntilIdle();
+
+    const size_t kBufferSize = 2000;
+    ss_->set_send_buffer_capacity(kBufferSize);
+    ss_->set_recv_buffer_capacity(kBufferSize);
+
+    const size_t kDataSize = 5000;
+    char send_buffer[kDataSize], recv_buffer[kDataSize];
+    for (size_t i = 0; i < kDataSize; ++i) send_buffer[i] = i;
+    memset(recv_buffer, 0, sizeof(recv_buffer));
+    size_t send_pos = 0, recv_pos = 0;
+
+    // Can't send more than send buffer in one write
+    int result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
+    EXPECT_EQ(static_cast<int>(kBufferSize), result);
+    send_pos += result;
+
+    ss_->ProcessMessagesUntilIdle();
+    EXPECT_FALSE(sink.Check(a, testing::SSE_WRITE));
+    EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+
+    // Receive buffer is already filled, fill send buffer again
+    result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
+    EXPECT_EQ(static_cast<int>(kBufferSize), result);
+    send_pos += result;
+
+    ss_->ProcessMessagesUntilIdle();
+    EXPECT_FALSE(sink.Check(a, testing::SSE_WRITE));
+    EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
+
+    // No more room in send or receive buffer
+    result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
+    EXPECT_EQ(-1, result);
+    EXPECT_TRUE(a->IsBlocking());
+
+    // Read a subset of the data
+    result = b->Recv(recv_buffer + recv_pos, 500);
+    EXPECT_EQ(500, result);
+    recv_pos += result;
+
+    ss_->ProcessMessagesUntilIdle();
+    EXPECT_TRUE(sink.Check(a, testing::SSE_WRITE));
+    EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+
+    // Room for more on the sending side
+    result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
+    EXPECT_EQ(500, result);
+    send_pos += result;
+
+    // Empty the recv buffer
+    while (true) {
+      result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
+      if (result < 0) {
+        EXPECT_EQ(-1, result);
+        EXPECT_TRUE(b->IsBlocking());
+        break;
+      }
+      recv_pos += result;
+    }
+
+    ss_->ProcessMessagesUntilIdle();
+    EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+
+    // Continue to empty the recv buffer
+    while (true) {
+      result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
+      if (result < 0) {
+        EXPECT_EQ(-1, result);
+        EXPECT_TRUE(b->IsBlocking());
+        break;
+      }
+      recv_pos += result;
+    }
+
+    // Send last of the data
+    result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
+    EXPECT_EQ(500, result);
+    send_pos += result;
+
+    ss_->ProcessMessagesUntilIdle();
+    EXPECT_TRUE(sink.Check(b, testing::SSE_READ));
+
+    // Receive the last of the data
+    while (true) {
+      result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos);
+      if (result < 0) {
+        EXPECT_EQ(-1, result);
+        EXPECT_TRUE(b->IsBlocking());
+        break;
+      }
+      recv_pos += result;
+    }
+
+    ss_->ProcessMessagesUntilIdle();
+    EXPECT_FALSE(sink.Check(b, testing::SSE_READ));
+
+    // The received data matches the sent data
+    EXPECT_EQ(kDataSize, send_pos);
+    EXPECT_EQ(kDataSize, recv_pos);
+    EXPECT_EQ(0, memcmp(recv_buffer, send_buffer, kDataSize));
+  }
+
+  void TcpSendsPacketsInOrderTest(const SocketAddress& initial_addr) {
+    const SocketAddress kEmptyAddr;
+
+    // Connect two sockets
+    AsyncSocket* a = ss_->CreateAsyncSocket(SOCK_STREAM);
+    AsyncSocket* b = ss_->CreateAsyncSocket(SOCK_STREAM);
+    a->Bind(initial_addr);
+    EXPECT_EQ(a->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+
+    b->Bind(initial_addr);
+    EXPECT_EQ(b->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+
+    EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
+    EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
+    ss_->ProcessMessagesUntilIdle();
+
+    // First, deliver all packets in 0 ms.
+    char buffer[2] = { 0, 0 };
+    const size_t cNumPackets = 10;
+    for (size_t i = 0; i < cNumPackets; ++i) {
+      buffer[0] = '0' + i;
+      EXPECT_EQ(1, a->Send(buffer, 1));
+    }
+
+    ss_->ProcessMessagesUntilIdle();
+
+    for (size_t i = 0; i < cNumPackets; ++i) {
+      EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer)));
+      EXPECT_EQ(static_cast<char>('0' + i), buffer[0]);
+    }
+
+    // Next, deliver packets at random intervals
+    const uint32 mean = 50;
+    const uint32 stddev = 50;
+
+    ss_->set_delay_mean(mean);
+    ss_->set_delay_stddev(stddev);
+    ss_->UpdateDelayDistribution();
+
+    for (size_t i = 0; i < cNumPackets; ++i) {
+      buffer[0] = 'A' + i;
+      EXPECT_EQ(1, a->Send(buffer, 1));
+    }
+
+    ss_->ProcessMessagesUntilIdle();
+
+    for (size_t i = 0; i < cNumPackets; ++i) {
+      EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer)));
+      EXPECT_EQ(static_cast<char>('A' + i), buffer[0]);
+    }
+  }
+
+  void BandwidthTest(const SocketAddress& initial_addr) {
+    AsyncSocket* send_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+    AsyncSocket* recv_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+    ASSERT_EQ(0, send_socket->Bind(initial_addr));
+    ASSERT_EQ(0, recv_socket->Bind(initial_addr));
+    EXPECT_EQ(send_socket->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+    EXPECT_EQ(recv_socket->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+    ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
+
+    uint32 bandwidth = 64 * 1024;
+    ss_->set_bandwidth(bandwidth);
+
+    Thread* pthMain = Thread::Current();
+    Sender sender(pthMain, send_socket, 80 * 1024);
+    Receiver receiver(pthMain, recv_socket, bandwidth);
+
+    pthMain->ProcessMessages(5000);
+    sender.done = true;
+    pthMain->ProcessMessages(5000);
+
+    ASSERT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
+    ASSERT_TRUE(receiver.count <= 6 * bandwidth);  // queue could drain for 1s
+
+    ss_->set_bandwidth(0);
+  }
+
+  void DelayTest(const SocketAddress& initial_addr) {
+    time_t seed = ::time(NULL);
+    LOG(LS_VERBOSE) << "seed = " << seed;
+    srand(seed);
+
+    const uint32 mean = 2000;
+    const uint32 stddev = 500;
+
+    ss_->set_delay_mean(mean);
+    ss_->set_delay_stddev(stddev);
+    ss_->UpdateDelayDistribution();
+
+    AsyncSocket* send_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+    AsyncSocket* recv_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+    ASSERT_EQ(0, send_socket->Bind(initial_addr));
+    ASSERT_EQ(0, recv_socket->Bind(initial_addr));
+    EXPECT_EQ(send_socket->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+    EXPECT_EQ(recv_socket->GetLocalAddress().ipaddr().family(),
+              initial_addr.ipaddr().family());
+    ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
+
+    Thread* pthMain = Thread::Current();
+    // Avg packet size is 2K, so at 200KB/s for 10s, we should see about
+    // 1000 packets, which is necessary to get a good distribution.
+    Sender sender(pthMain, send_socket, 100 * 2 * 1024);
+    Receiver receiver(pthMain, recv_socket, 0);
+
+    pthMain->ProcessMessages(10000);
+    sender.done = receiver.done = true;
+    ss_->ProcessMessagesUntilIdle();
+
+    const double sample_mean = receiver.sum / receiver.samples;
+    double num =
+        receiver.samples * receiver.sum_sq - receiver.sum * receiver.sum;
+    double den = receiver.samples * (receiver.samples - 1);
+    const double sample_stddev = std::sqrt(num / den);
+    LOG(LS_VERBOSE) << "mean=" << sample_mean << " stddev=" << sample_stddev;
+
+    EXPECT_LE(500u, receiver.samples);
+    // We initially used a 0.1 fudge factor, but on the build machine, we
+    // have seen the value differ by as much as 0.13.
+    EXPECT_NEAR(mean, sample_mean, 0.15 * mean);
+    EXPECT_NEAR(stddev, sample_stddev, 0.15 * stddev);
+
+    ss_->set_delay_mean(0);
+    ss_->set_delay_stddev(0);
+    ss_->UpdateDelayDistribution();
+  }
+
+  // Test cross-family communication between a client bound to client_addr and a
+  // server bound to server_addr. shouldSucceed indicates if communication is
+  // expected to work or not.
+  void CrossFamilyConnectionTest(const SocketAddress& client_addr,
+                                 const SocketAddress& server_addr,
+                                 bool shouldSucceed) {
+    testing::StreamSink sink;
+    SocketAddress accept_address;
+    const SocketAddress kEmptyAddr;
+
+    // Client gets a IPv4 address
+    AsyncSocket* client = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(client);
+    EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+    EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
+    client->Bind(client_addr);
+
+    // Server gets a non-mapped non-any IPv6 address.
+    // IPv4 sockets should not be able to connect to this.
+    AsyncSocket* server = ss_->CreateAsyncSocket(SOCK_STREAM);
+    sink.Monitor(server);
+    server->Bind(server_addr);
+    server->Listen(5);
+
+    if (shouldSucceed) {
+      EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
+      ss_->ProcessMessagesUntilIdle();
+      EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
+      Socket* accepted = server->Accept(&accept_address);
+      EXPECT_TRUE(NULL != accepted);
+      EXPECT_NE(kEmptyAddr, accept_address);
+      ss_->ProcessMessagesUntilIdle();
+      EXPECT_TRUE(sink.Check(client, testing::SSE_OPEN));
+      EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
+    } else {
+      // Check that the connection failed.
+      EXPECT_EQ(-1, client->Connect(server->GetLocalAddress()));
+      ss_->ProcessMessagesUntilIdle();
+
+      EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
+      EXPECT_TRUE(NULL == server->Accept(&accept_address));
+      EXPECT_EQ(accept_address, kEmptyAddr);
+      EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
+      EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
+      EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
+    }
+  }
+
+  // Test cross-family datagram sending between a client bound to client_addr
+  // and a server bound to server_addr. shouldSucceed indicates if sending is
+  // expected to succed or not.
+  void CrossFamilyDatagramTest(const SocketAddress& client_addr,
+                               const SocketAddress& server_addr,
+                               bool shouldSucceed) {
+    AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
+    socket->Bind(server_addr);
+    SocketAddress bound_server_addr = socket->GetLocalAddress();
+    TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
+
+    AsyncSocket* socket2 = ss_->CreateAsyncSocket(SOCK_DGRAM);
+    socket2->Bind(client_addr);
+    TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
+    SocketAddress client2_addr;
+
+    if (shouldSucceed) {
+      EXPECT_EQ(3, client2->SendTo("foo", 3, bound_server_addr));
+      EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
+      SocketAddress client1_addr;
+      EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
+      EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
+      EXPECT_EQ(client1_addr, bound_server_addr);
+    } else {
+      EXPECT_EQ(-1, client2->SendTo("foo", 3, bound_server_addr));
+      EXPECT_FALSE(client1->CheckNextPacket("foo", 3, 0));
+    }
+  }
+
+ protected:
+  virtual void SetUp() {
+    Thread::Current()->set_socketserver(ss_);
+  }
+  virtual void TearDown() {
+    Thread::Current()->set_socketserver(NULL);
+  }
+
+  VirtualSocketServer* ss_;
+  const SocketAddress kIPv4AnyAddress;
+  const SocketAddress kIPv6AnyAddress;
+};
+
+TEST_F(VirtualSocketServerTest, basic_v4) {
+  SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
+  BasicTest(ipv4_test_addr);
 }
 
-TEST_F(VirtualSocketServerTest, delay) {
-  time_t seed = ::time(NULL);
-  LOG(LS_VERBOSE) << "seed = " << seed;
-  srand(seed);
+TEST_F(VirtualSocketServerTest, basic_v6) {
+  SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 5000);
+  BasicTest(ipv6_test_addr);
+}
 
-  const uint32 mean = 2000;
-  const uint32 stddev = 500;
+TEST_F(VirtualSocketServerTest, connect_v4) {
+  ConnectTest(kIPv4AnyAddress);
+}
 
-  ss_->set_delay_mean(mean);
-  ss_->set_delay_stddev(stddev);
-  ss_->UpdateDelayDistribution();
+TEST_F(VirtualSocketServerTest, connect_v6) {
+  ConnectTest(kIPv6AnyAddress);
+}
 
-  AsyncSocket* send_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
-  AsyncSocket* recv_socket = ss_->CreateAsyncSocket(SOCK_DGRAM);
-  ASSERT_EQ(0, send_socket->Bind(SocketAddress(IPAddress(INADDR_ANY), 1000)));
-  ASSERT_EQ(0, recv_socket->Bind(SocketAddress(IPAddress(INADDR_ANY), 1000)));
-  ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
+TEST_F(VirtualSocketServerTest, connect_to_non_listener_v4) {
+  ConnectToNonListenerTest(kIPv4AnyAddress);
+}
 
-  Thread* pthMain = Thread::Current();
-  // Avg packet size is 2K, so at 200KB/s for 10s, we should see about
-  // 1000 packets, which is necessary to get a good distribution.
-  Sender sender(pthMain, send_socket, 100 * 2 * 1024);
-  Receiver receiver(pthMain, recv_socket, 0);
+TEST_F(VirtualSocketServerTest, connect_to_non_listener_v6) {
+  ConnectToNonListenerTest(kIPv6AnyAddress);
+}
 
-  pthMain->ProcessMessages(10000);
-  sender.done = receiver.done = true;
-  ss_->ProcessMessagesUntilIdle();
+TEST_F(VirtualSocketServerTest, close_during_connect_v4) {
+  CloseDuringConnectTest(kIPv4AnyAddress);
+}
 
-  const double sample_mean = receiver.sum / receiver.samples;
-  double num = receiver.samples * receiver.sum_sq - receiver.sum * receiver.sum;
-  double den = receiver.samples * (receiver.samples - 1);
-  const double sample_stddev = std::sqrt(num / den);
-  LOG(LS_VERBOSE) << "mean=" << sample_mean << " stddev=" << sample_stddev;
+TEST_F(VirtualSocketServerTest, close_during_connect_v6) {
+  CloseDuringConnectTest(kIPv6AnyAddress);
+}
 
-  EXPECT_LE(500u, receiver.samples);
-  // We initially used a 0.1 fudge factor, but on the build machine, we
-  // have seen the value differ by as much as 0.13.
-  EXPECT_NEAR(mean, sample_mean, 0.15 * mean);
-  EXPECT_NEAR(stddev, sample_stddev, 0.15 * stddev);
+TEST_F(VirtualSocketServerTest, close_v4) {
+  CloseTest(kIPv4AnyAddress);
+}
 
-  ss_->set_delay_mean(0);
-  ss_->set_delay_stddev(0);
-  ss_->UpdateDelayDistribution();
+TEST_F(VirtualSocketServerTest, close_v6) {
+  CloseTest(kIPv6AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, tcp_send_v4) {
+  TcpSendTest(kIPv4AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, tcp_send_v6) {
+  TcpSendTest(kIPv6AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, TcpSendsPacketsInOrder_v4) {
+  TcpSendsPacketsInOrderTest(kIPv4AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, TcpSendsPacketsInOrder_v6) {
+  TcpSendsPacketsInOrderTest(kIPv6AnyAddress);
+}
+
+TEST_F(VirtualSocketServerTest, bandwidth_v4) {
+  SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 1000);
+  BandwidthTest(ipv4_test_addr);
+}
+
+TEST_F(VirtualSocketServerTest, bandwidth_v6) {
+  SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 1000);
+  BandwidthTest(ipv6_test_addr);
+}
+
+TEST_F(VirtualSocketServerTest, delay_v4) {
+  SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 1000);
+  DelayTest(ipv4_test_addr);
+}
+
+TEST_F(VirtualSocketServerTest, delay_v6) {
+  SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 1000);
+  DelayTest(ipv6_test_addr);
+}
+
+// Works, receiving socket sees 127.0.0.2.
+TEST_F(VirtualSocketServerTest, CanConnectFromMappedIPv6ToIPv4Any) {
+  CrossFamilyConnectionTest(SocketAddress("::ffff:127.0.0.2", 0),
+                            SocketAddress("0.0.0.0", 5000),
+                            true);
+}
+
+// Fails.
+TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToIPv4Any) {
+  CrossFamilyConnectionTest(SocketAddress("::2", 0),
+                            SocketAddress("0.0.0.0", 5000),
+                            false);
+}
+
+// Fails.
+TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToMappedIPv6) {
+  CrossFamilyConnectionTest(SocketAddress("::2", 0),
+                            SocketAddress("::ffff:127.0.0.1", 5000),
+                            false);
+}
+
+// Works. receiving socket sees ::ffff:127.0.0.2.
+TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToIPv6Any) {
+  CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
+                            SocketAddress("::", 5000),
+                            true);
+}
+
+// Fails.
+TEST_F(VirtualSocketServerTest, CantConnectFromIPv4ToUnMappedIPv6) {
+  CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
+                            SocketAddress("::1", 5000),
+                            false);
+}
+
+// Works. Receiving socket sees ::ffff:127.0.0.1.
+TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToMappedIPv6) {
+  CrossFamilyConnectionTest(SocketAddress("127.0.0.1", 0),
+                            SocketAddress("::ffff:127.0.0.2", 5000),
+                            true);
+}
+
+// Works, receiving socket sees a result from GetNextIP.
+TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv6ToIPv4Any) {
+  CrossFamilyConnectionTest(SocketAddress("::", 0),
+                            SocketAddress("0.0.0.0", 5000),
+                            true);
+}
+
+// Works, receiving socket sees whatever GetNextIP gave the client.
+TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv4ToIPv6Any) {
+  CrossFamilyConnectionTest(SocketAddress(),
+                            SocketAddress("::", 5000),
+                            true);
+}
+
+TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv4ToIPv6Any) {
+  CrossFamilyDatagramTest(SocketAddress(),
+                          SocketAddress("::", 5000),
+                          true);
+}
+
+TEST_F(VirtualSocketServerTest, CanSendDatagramFromMappedIPv6ToIPv4Any) {
+  CrossFamilyDatagramTest(SocketAddress("::ffff:127.0.0.1", 0),
+                          SocketAddress("0.0.0.0", 5000),
+                          true);
+}
+
+TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToIPv4Any) {
+  CrossFamilyDatagramTest(SocketAddress("::2", 0),
+                          SocketAddress("0.0.0.0", 5000),
+                          false);
+}
+
+TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToMappedIPv6) {
+  CrossFamilyDatagramTest(SocketAddress("::2", 0),
+                          SocketAddress("::ffff:127.0.0.1", 5000),
+                          false);
+}
+
+TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToIPv6Any) {
+  CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
+                          SocketAddress("::", 5000),
+                          true);
+}
+
+TEST_F(VirtualSocketServerTest, CantSendDatagramFromIPv4ToUnMappedIPv6) {
+  CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
+                          SocketAddress("::1", 5000),
+                          false);
+}
+
+TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToMappedIPv6) {
+  CrossFamilyDatagramTest(SocketAddress("127.0.0.1", 0),
+                          SocketAddress("::ffff:127.0.0.2", 5000),
+                          true);
+}
+
+TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
+  CrossFamilyDatagramTest(SocketAddress("::", 0),
+                          SocketAddress("0.0.0.0", 5000),
+                          true);
+}
+
+TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) {
+  const uint32 kTestMean[] = { 10, 100, 333, 1000 };
+  const double kTestDev[] = { 0.25, 0.1, 0.01 };
+  // TODO: The current code only works for 1000 data points or more.
+  const uint32 kTestSamples[] = { /*10, 100,*/ 1000 };
+  for (size_t midx = 0; midx < ARRAY_SIZE(kTestMean); ++midx) {
+    for (size_t didx = 0; didx < ARRAY_SIZE(kTestDev); ++didx) {
+      for (size_t sidx = 0; sidx < ARRAY_SIZE(kTestSamples); ++sidx) {
+        ASSERT_LT(0u, kTestSamples[sidx]);
+        const uint32 kStdDev =
+            static_cast<uint32>(kTestDev[didx] * kTestMean[midx]);
+        VirtualSocketServer::Function* f =
+            VirtualSocketServer::CreateDistribution(kTestMean[midx],
+                                                    kStdDev,
+                                                    kTestSamples[sidx]);
+        ASSERT_TRUE(NULL != f);
+        ASSERT_EQ(kTestSamples[sidx], f->size());
+        double sum = 0;
+        for (uint32 i = 0; i < f->size(); ++i) {
+          sum += (*f)[i].second;
+        }
+        const double mean = sum / f->size();
+        double sum_sq_dev = 0;
+        for (uint32 i = 0; i < f->size(); ++i) {
+          double dev = (*f)[i].second - mean;
+          sum_sq_dev += dev * dev;
+        }
+        const double stddev = std::sqrt(sum_sq_dev / f->size());
+        EXPECT_NEAR(kTestMean[midx], mean, 0.1 * kTestMean[midx])
+          << "M=" << kTestMean[midx]
+          << " SD=" << kStdDev
+          << " N=" << kTestSamples[sidx];
+        EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
+          << "M=" << kTestMean[midx]
+          << " SD=" << kStdDev
+          << " N=" << kTestSamples[sidx];
+        delete f;
+      }
+    }
+  }
 }
diff --git a/talk/base/virtualsocketserver.cc b/talk/base/virtualsocketserver.cc
index c9c9f0b..c18ffb6 100644
--- a/talk/base/virtualsocketserver.cc
+++ b/talk/base/virtualsocketserver.cc
@@ -42,6 +42,16 @@
 #include "talk/base/timeutils.h"
 
 namespace talk_base {
+#ifdef WIN32
+const in_addr kInitialNextIPv4 = { {0x01, 0, 0, 0} };
+#else
+// This value is entirely arbitrary, hence the lack of concern about endianness.
+const in_addr kInitialNextIPv4 = { 0x01000000 };
+#endif
+// Starts at ::2 so as to not cause confusion with ::1.
+const in6_addr kInitialNextIPv6 = { { {
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2
+    } } };
 
 const uint16 kFirstEphemeralPort = 49152;
 const uint16 kLastEphemeralPort = 65535;
@@ -105,7 +115,7 @@
   VirtualSocket(VirtualSocketServer* server, int type, bool async)
       : server_(server), type_(type), async_(async), state_(CS_CLOSED),
         listen_queue_(NULL), write_enabled_(false), network_size_(0),
-        recv_buffer_size_(0), bound_(false) {
+        recv_buffer_size_(0), bound_(false), was_any_(false) {
     ASSERT((type_ == SOCK_DGRAM) || (type_ == SOCK_STREAM));
     ASSERT(async_ || (type_ != SOCK_STREAM));  // We only support async streams
   }
@@ -144,6 +154,7 @@
       error_ = EADDRINUSE;
     } else {
       bound_ = true;
+      was_any_ = addr.IsAnyIP();
     }
     return result;
   }
@@ -317,6 +328,8 @@
 
       // Set the new local address to the same as this server socket.
       socket->SetLocalAddress(local_addr_);
+      // Sockets made from a socket that 'was Any' need to inherit that.
+      socket->set_was_any(was_any_);
       SocketAddress remote_addr(listen_queue_->front());
       int result = socket->InitiateConnect(remote_addr, false);
       listen_queue_->pop_front();
@@ -408,6 +421,9 @@
     }
   }
 
+  bool was_any() { return was_any_; }
+  void set_was_any(bool was_any) { was_any_ = was_any; }
+
  private:
   struct NetworkEntry {
     uint32 size;
@@ -426,7 +442,13 @@
       return -1;
     }
     if (local_addr_.IsAny()) {
-      int result = Bind(SocketAddress());
+      // If there's no local address set, grab a random one in the correct AF.
+      int result = 0;
+      if (addr.ipaddr().family() == AF_INET) {
+        result = Bind(SocketAddress("0.0.0.0", 0));
+      } else if (addr.ipaddr().family() == AF_INET6) {
+        result = Bind(SocketAddress("::", 0));
+      }
       if (result != 0) {
         return result;
       }
@@ -514,6 +536,12 @@
   // Is this socket bound?
   bool bound_;
 
+  // When we bind a socket to Any, VSS's Bind gives it another address. For
+  // dual-stack sockets, we want to distinguish between sockets that were
+  // explicitly given a particular address and sockets that had one picked
+  // for them by VSS.
+  bool was_any_;
+
   // Store the options that are set
   OptionsMap options_map_;
 
@@ -522,7 +550,8 @@
 
 VirtualSocketServer::VirtualSocketServer(SocketServer* ss)
     : server_(ss), server_owned_(false), msg_queue_(NULL), stop_on_idle_(false),
-      network_delay_(Time()), next_ip_(1), next_port_(kFirstEphemeralPort),
+      network_delay_(Time()), next_ipv4_(kInitialNextIPv4),
+      next_ipv6_(kInitialNextIPv6), next_port_(kFirstEphemeralPort),
       bindings_(new AddressMap()), connections_(new ConnectionMap()),
       bandwidth_(0), network_capacity_(kDefaultNetworkCapacity),
       send_buffer_capacity_(kDefaultTcpBufferSize),
@@ -545,8 +574,18 @@
   }
 }
 
-uint32 VirtualSocketServer::GetNextIP() {
-  return next_ip_++;
+IPAddress VirtualSocketServer::GetNextIP(int family) {
+  if (family == AF_INET) {
+    IPAddress next_ip(next_ipv4_);
+    next_ipv4_.s_addr = htonl(ntohl(next_ipv4_.s_addr) + 1);
+    return next_ip;
+  } else if (family == AF_INET6) {
+    IPAddress next_ip(next_ipv6_);
+    uint32* as_ints = reinterpret_cast<uint32*>(&next_ipv6_.s6_addr);
+    as_ints[3] += 1;
+    return next_ip;
+  }
+  return IPAddress();
 }
 
 uint16 VirtualSocketServer::GetNextPort() {
@@ -611,7 +650,10 @@
   ASSERT(!IPIsAny(addr.ipaddr()));
   ASSERT(addr.port() != 0);
 
-  AddressMap::value_type entry(addr, socket);
+  // Normalize the address (turns v6-mapped addresses into v4-addresses).
+  SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+
+  AddressMap::value_type entry(normalized, socket);
   return bindings_->insert(entry).second ? 0 : -1;
 }
 
@@ -619,8 +661,9 @@
   ASSERT(NULL != socket);
 
   if (IPIsAny(addr->ipaddr())) {
-    // TODO: An IPv6-ish version of this?
-    addr->SetIP(IPAddress(GetNextIP()));
+    addr->SetIP(GetNextIP(addr->ipaddr().family()));
+  } else {
+    addr->SetIP(addr->ipaddr().Normalized());
   }
 
   if (addr->port() == 0) {
@@ -636,14 +679,18 @@
 }
 
 VirtualSocket* VirtualSocketServer::LookupBinding(const SocketAddress& addr) {
-  AddressMap::iterator it = bindings_->find(addr);
+  SocketAddress normalized(addr.ipaddr().Normalized(),
+                           addr.port());
+  AddressMap::iterator it = bindings_->find(normalized);
   return (bindings_->end() != it) ? it->second : NULL;
 }
 
 int VirtualSocketServer::Unbind(const SocketAddress& addr,
                                 VirtualSocket* socket) {
-  ASSERT((*bindings_)[addr] == socket);
-  bindings_->erase(bindings_->find(addr));
+  SocketAddress normalized(addr.ipaddr().Normalized(),
+                           addr.port());
+  ASSERT((*bindings_)[normalized] == socket);
+  bindings_->erase(bindings_->find(normalized));
   return 0;
 }
 
@@ -652,7 +699,11 @@
                                         VirtualSocket* remote_socket) {
   // Add this socket pair to our routing table. This will allow
   // multiple clients to connect to the same server address.
-  SocketAddressPair address_pair(local, remote);
+  SocketAddress local_normalized(local.ipaddr().Normalized(),
+                                 local.port());
+  SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+                                  remote.port());
+  SocketAddressPair address_pair(local_normalized, remote_normalized);
   connections_->insert(std::pair<SocketAddressPair,
                        VirtualSocket*>(address_pair, remote_socket));
 }
@@ -660,14 +711,22 @@
 VirtualSocket* VirtualSocketServer::LookupConnection(
     const SocketAddress& local,
     const SocketAddress& remote) {
-  SocketAddressPair address_pair(local, remote);
+  SocketAddress local_normalized(local.ipaddr().Normalized(),
+                                 local.port());
+  SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+                                  remote.port());
+  SocketAddressPair address_pair(local_normalized, remote_normalized);
   ConnectionMap::iterator it = connections_->find(address_pair);
   return (connections_->end() != it) ? it->second : NULL;
 }
 
 void VirtualSocketServer::RemoveConnection(const SocketAddress& local,
                                            const SocketAddress& remote) {
-  SocketAddressPair address_pair(local, remote);
+  SocketAddress local_normalized(local.ipaddr().Normalized(),
+                                local.port());
+  SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+                                 remote.port());
+  SocketAddressPair address_pair(local_normalized, remote_normalized);
   connections_->erase(address_pair);
 }
 
@@ -679,7 +738,13 @@
                                  const SocketAddress& remote_addr,
                                  bool use_delay) {
   uint32 delay = use_delay ? GetRandomTransitDelay() : 0;
-  if (VirtualSocket* remote = LookupBinding(remote_addr)) {
+  VirtualSocket* remote = LookupBinding(remote_addr);
+  if (!CanInteractWith(socket, remote)) {
+    LOG(LS_INFO) << "Address family mismatch between "
+                 << socket->GetLocalAddress() << " and " << remote_addr;
+    return -1;
+  }
+  if (remote != NULL) {
     SocketAddress addr = socket->GetLocalAddress();
     msg_queue_->PostDelayed(delay, remote, MSG_ID_CONNECT,
                             new MessageAddress(addr));
@@ -710,10 +775,24 @@
 
   VirtualSocket* recipient = LookupBinding(remote_addr);
   if (!recipient) {
+    // Make a fake recipient for address family checking.
+    scoped_ptr<VirtualSocket> dummy_socket(CreateSocketInternal(SOCK_DGRAM));
+    dummy_socket->SetLocalAddress(remote_addr);
+    if (!CanInteractWith(socket, dummy_socket.get())) {
+      LOG(LS_VERBOSE) << "Incompatible address families: "
+                      << socket->GetLocalAddress() << " and " << remote_addr;
+      return -1;
+    }
     LOG(LS_VERBOSE) << "No one listening at " << remote_addr;
     return static_cast<int>(data_size);
   }
 
+  if (!CanInteractWith(socket, recipient)) {
+    LOG(LS_VERBOSE) << "Incompatible address families: "
+                    << socket->GetLocalAddress() << " and " << remote_addr;
+    return -1;
+  }
+
   CritScope cs(&socket->crit_);
 
   uint32 cur_time = Time();
@@ -979,4 +1058,45 @@
   }
 }
 
+bool VirtualSocketServer::CanInteractWith(VirtualSocket* local,
+                                          VirtualSocket* remote) {
+  if (!local || !remote) {
+    return false;
+  }
+  IPAddress local_ip = local->GetLocalAddress().ipaddr();
+  IPAddress remote_ip = remote->GetLocalAddress().ipaddr();
+  IPAddress local_normalized = local_ip.Normalized();
+  IPAddress remote_normalized = remote_ip.Normalized();
+  // Check if the addresses are the same family after Normalization (turns
+  // mapped IPv6 address into IPv4 addresses).
+  // This will stop unmapped V6 addresses from talking to mapped V6 addresses.
+  if (local_normalized.family() == remote_normalized.family()) {
+    return true;
+  }
+
+  // If ip1 is IPv4 and ip2 is :: and ip2 is not IPV6_V6ONLY.
+  int remote_v6_only = 0;
+  remote->GetOption(Socket::OPT_IPV6_V6ONLY, &remote_v6_only);
+  if (local_ip.family() == AF_INET && !remote_v6_only && IPIsAny(remote_ip)) {
+    return true;
+  }
+  // Same check, backwards.
+  int local_v6_only = 0;
+  local->GetOption(Socket::OPT_IPV6_V6ONLY, &local_v6_only);
+  if (remote_ip.family() == AF_INET && !local_v6_only && IPIsAny(local_ip)) {
+    return true;
+  }
+
+  // Check to see if either socket was explicitly bound to IPv6-any.
+  // These sockets can talk with anyone.
+  if (local_ip.family() == AF_INET6 && local->was_any()) {
+    return true;
+  }
+  if (remote_ip.family() == AF_INET6 && remote->was_any()) {
+    return true;
+  }
+
+  return false;
+}
+
 }  // namespace talk_base
diff --git a/talk/base/virtualsocketserver.h b/talk/base/virtualsocketserver.h
index 239ea9b..d35d586 100644
--- a/talk/base/virtualsocketserver.h
+++ b/talk/base/virtualsocketserver.h
@@ -42,7 +42,8 @@
 
 // Simulates a network in the same manner as a loopback interface.  The
 // interface can create as many addresses as you want.  All of the sockets
-// created by this network will be able to communicate with one another.
+// created by this network will be able to communicate with one another, unless
+// they are bound to addresses from incompatible families.
 class VirtualSocketServer : public SocketServer, public sigslot::has_slots<> {
  public:
   // TODO: Add "owned" parameter.
@@ -124,7 +125,7 @@
 
  protected:
   // Returns a new IP not used before in this network.
-  uint32 GetNextIP();
+  IPAddress GetNextIP(int family);
   uint16 GetNextPort();
 
   VirtualSocket* CreateSocketInternal(int type);
@@ -192,6 +193,24 @@
   // try to send Close messages for all connected sockets when we shutdown.
   void OnMessageQueueDestroyed() { msg_queue_ = NULL; }
 
+  // Determine if two sockets should be able to communicate.
+  // We don't (currently) specify an address family for sockets; instead,
+  // the currently bound address is used to infer the address family.
+  // Any socket that is not explicitly bound to an IPv4 address is assumed to be
+  // dual-stack capable.
+  // This function tests if two addresses can communicate, as well as the
+  // sockets to which they may be bound (the addresses may or may not yet be
+  // bound to the sockets).
+  // First the addresses are tested (after normalization):
+  // If both have the same family, then communication is OK.
+  // If only one is IPv4 then false, unless the other is bound to ::.
+  // This applies even if the IPv4 address is 0.0.0.0.
+  // The socket arguments are optional; the sockets are checked to see if they
+  // were explicitly bound to IPv6-any ('::'), and if so communication is
+  // permitted.
+  // NB: This scheme doesn't permit non-dualstack IPv6 sockets.
+  static bool CanInteractWith(VirtualSocket* local, VirtualSocket* remote);
+
  private:
   friend class VirtualSocket;
 
@@ -203,7 +222,8 @@
   MessageQueue* msg_queue_;
   bool stop_on_idle_;
   uint32 network_delay_;
-  uint32 next_ip_;
+  in_addr next_ipv4_;
+  in6_addr next_ipv6_;
   uint16 next_port_;
   AddressMap* bindings_;
   ConnectionMap* connections_;
diff --git a/talk/examples/call/callclient.cc b/talk/examples/call/callclient.cc
index 9b8fb1a..89f964b 100644
--- a/talk/examples/call/callclient.cc
+++ b/talk/examples/call/callclient.cc
@@ -1116,22 +1116,24 @@
                                       cricket::Session* session,
                                       const cricket::MediaStreams& added,
                                       const cricket::MediaStreams& removed) {
-  for (std::vector<cricket::StreamParams>::const_iterator
-       it = removed.video().begin(); it != removed.video().end(); ++it) {
-    RemoveStaticRenderedView(it->first_ssrc());
-  }
-
-  if (render_) {
+  if (call->video()) {
     for (std::vector<cricket::StreamParams>::const_iterator
-         it = added.video().begin(); it != added.video().end(); ++it) {
-      // TODO: Make dimensions and positions more configurable.
-      int offset = (50 * static_views_accumulated_count_) % 300;
-      AddStaticRenderedView(session, it->first_ssrc(), 640, 400, 30,
-                            offset, offset);
+         it = removed.video().begin(); it != removed.video().end(); ++it) {
+      RemoveStaticRenderedView(it->first_ssrc());
     }
-  }
 
-  SendViewRequest(session);
+    if (render_) {
+      for (std::vector<cricket::StreamParams>::const_iterator
+           it = added.video().begin(); it != added.video().end(); ++it) {
+        // TODO: Make dimensions and positions more configurable.
+        int offset = (50 * static_views_accumulated_count_) % 300;
+        AddStaticRenderedView(session, it->first_ssrc(), 640, 400, 30,
+                              offset, offset);
+      }
+    }
+
+    SendViewRequest(session);
+  }
 }
 
 // TODO: Would these methods to add and remove views make
diff --git a/talk/examples/peerconnection/client/main.cc b/talk/examples/peerconnection/client/main.cc
index 4ae0da0..8d2bdc9 100644
--- a/talk/examples/peerconnection/client/main.cc
+++ b/talk/examples/peerconnection/client/main.cc
@@ -25,12 +25,9 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <windows.h>
-
 #include "talk/examples/peerconnection/client/conductor.h"
 #include "talk/examples/peerconnection/client/main_wnd.h"
 #include "talk/examples/peerconnection/client/peer_connection_client.h"
-#include "system_wrappers/source/trace_impl.h"
 #include "talk/base/win32socketinit.h"
 
 
@@ -38,10 +35,6 @@
                     wchar_t* cmd_line, int cmd_show) {
   talk_base::EnsureWinsockInit();
 
-  webrtc::Trace::CreateTrace();
-  webrtc::Trace::SetTraceFile("peerconnection_client.log");
-  webrtc::Trace::SetLevelFilter(webrtc::kTraceWarning);
-
   MainWnd wnd;
   if (!wnd.Create()) {
     ASSERT(false);
@@ -54,7 +47,7 @@
   // Main loop.
   MSG msg;
   BOOL gm;
-  while ((gm = ::GetMessage(&msg, NULL, 0, 0)) && gm != -1) {
+  while ((gm = ::GetMessage(&msg, NULL, 0, 0)) != 0 && gm != -1) {
     if (!wnd.PreTranslateMessage(&msg)) {
       ::TranslateMessage(&msg);
       ::DispatchMessage(&msg);
@@ -63,7 +56,7 @@
 
   if (conductor.connection_active() || client.is_connected()) {
     while ((conductor.connection_active() || client.is_connected()) &&
-           (gm = ::GetMessage(&msg, NULL, 0, 0)) && gm != -1) {
+           (gm = ::GetMessage(&msg, NULL, 0, 0)) != 0 && gm != -1) {
       if (!wnd.PreTranslateMessage(&msg)) {
         ::TranslateMessage(&msg);
         ::DispatchMessage(&msg);
diff --git a/talk/examples/peerconnection/client/main_wnd.cc b/talk/examples/peerconnection/client/main_wnd.cc
index e4e0539..367922e 100644
--- a/talk/examples/peerconnection/client/main_wnd.cc
+++ b/talk/examples/peerconnection/client/main_wnd.cc
@@ -31,6 +31,7 @@
 
 #include "talk/base/common.h"
 #include "talk/base/logging.h"
+#include "talk/examples/peerconnection/client/defaults.h"
 
 ATOM MainWnd::wnd_class_ = 0;
 const wchar_t MainWnd::kClassName[] = L"WebRTC_MainWnd";
@@ -160,8 +161,9 @@
 }
 
 void MainWnd::SwitchToPeerList(const Peers& peers) {
-  remote_video_.reset();
-  local_video_.reset();
+  // Clean up buffers from a potential previous session.
+  local_renderer_wrapper_ = NULL;
+  remote_renderer_wrapper_ = NULL;
 
   LayoutConnectUI(false);
 
@@ -191,16 +193,18 @@
   ::MessageBoxA(handle(), text, caption, flags);
 }
 
-cricket::VideoRenderer* MainWnd::local_renderer() {
-  if (!local_video_.get())
-    local_video_.reset(new VideoRenderer(handle(), 1, 1));
-  return local_video_.get();
+webrtc::VideoRendererWrapperInterface* MainWnd::local_renderer() {
+  if (!local_renderer_wrapper_.get())
+    local_renderer_wrapper_  =
+        webrtc::CreateVideoRenderer(new VideoRenderer(handle(), 1, 1));
+  return local_renderer_wrapper_.get();
 }
 
-cricket::VideoRenderer* MainWnd::remote_renderer() {
-  if (!remote_video_.get())
-    remote_video_.reset(new VideoRenderer(handle(), 1, 1));
-  return remote_video_.get();
+webrtc::VideoRendererWrapperInterface* MainWnd::remote_renderer() {
+  if (!remote_renderer_wrapper_.get())
+    remote_renderer_wrapper_ =
+        webrtc::CreateVideoRenderer(new VideoRenderer(handle(), 1, 1));
+  return remote_renderer_wrapper_.get();
 }
 
 void MainWnd::QueueUIThreadCallback(int msg_id, void* data) {
@@ -215,15 +219,21 @@
   RECT rc;
   ::GetClientRect(handle(), &rc);
 
-  if (ui_ == STREAMING && remote_video_.get() && local_video_.get()) {
-    AutoLock<VideoRenderer> local_lock(local_video_.get());
-    AutoLock<VideoRenderer> remote_lock(remote_video_.get());
+  webrtc::VideoRendererWrapperInterface* renderer_wrapper = local_renderer();
+  VideoRenderer* local_renderer = renderer_wrapper ?
+      static_cast<VideoRenderer*>(renderer_wrapper->renderer()) : NULL;
+  renderer_wrapper = remote_renderer();
+  VideoRenderer* remote_renderer = renderer_wrapper ?
+      static_cast<VideoRenderer*>(renderer_wrapper->renderer()) : NULL;
+  if (ui_ == STREAMING && remote_renderer && local_renderer) {
+    AutoLock<VideoRenderer> local_lock(local_renderer);
+    AutoLock<VideoRenderer> remote_lock(remote_renderer);
 
-    const BITMAPINFO& bmi = remote_video_->bmi();
+    const BITMAPINFO& bmi = remote_renderer->bmi();
     int height = abs(bmi.bmiHeader.biHeight);
     int width = bmi.bmiHeader.biWidth;
 
-    const uint8* image = remote_video_->image();
+    const uint8* image = remote_renderer->image();
     if (image != NULL) {
       HDC dc_mem = ::CreateCompatibleDC(ps.hdc);
       ::SetStretchBltMode(dc_mem, HALFTONE);
@@ -247,7 +257,7 @@
       ::FillRect(dc_mem, &logical_rect, brush);
       ::DeleteObject(brush);
 
-      int max_unit = std::max(width, height);
+      int max_unit = (std::max)(width, height);
       int x = (logical_area.x / 2) - (width / 2);
       int y = (logical_area.y / 2) - (height / 2);
 
@@ -255,8 +265,8 @@
                     0, 0, width, height, image, &bmi, DIB_RGB_COLORS, SRCCOPY);
 
       if ((rc.right - rc.left) > 200 && (rc.bottom - rc.top) > 200) {
-        const BITMAPINFO& bmi = local_video_->bmi();
-        image = local_video_->image();
+        const BITMAPINFO& bmi = local_renderer->bmi();
+        image = local_renderer->image();
         int thumb_width = bmi.bmiHeader.biWidth / 4;
         int thumb_height = abs(bmi.bmiHeader.biHeight) / 4;
         StretchDIBits(dc_mem,
@@ -285,7 +295,7 @@
       ::SetBkMode(ps.hdc, TRANSPARENT);
 
       std::string text(kConnecting);
-      if (!local_video_->image()) {
+      if (!local_renderer->image()) {
         text += kNoVideoStreams;
       } else {
         text += kNoIncomingStream;
diff --git a/talk/examples/peerconnection/client/main_wnd.h b/talk/examples/peerconnection/client/main_wnd.h
index 1807f4e..17243b3 100644
--- a/talk/examples/peerconnection/client/main_wnd.h
+++ b/talk/examples/peerconnection/client/main_wnd.h
@@ -107,8 +107,8 @@
                           bool is_error);
   virtual UI current_ui() { return ui_; }
 
-  virtual cricket::VideoRenderer* local_renderer();
-  virtual cricket::VideoRenderer* remote_renderer();
+  virtual webrtc::VideoRendererWrapperInterface* local_renderer();
+  virtual webrtc::VideoRendererWrapperInterface* remote_renderer();
 
   virtual void QueueUIThreadCallback(int msg_id, void* data);
 
@@ -187,8 +187,10 @@
   void HandleTabbing();
 
  private:
-  talk_base::scoped_ptr<VideoRenderer> remote_video_;
-  talk_base::scoped_ptr<VideoRenderer> local_video_;
+  talk_base::scoped_refptr<webrtc::VideoRendererWrapperInterface>
+      local_renderer_wrapper_;
+  talk_base::scoped_refptr<webrtc::VideoRendererWrapperInterface>
+      remote_renderer_wrapper_;
   UI ui_;
   HWND wnd_;
   DWORD ui_thread_id_;
diff --git a/talk/examples/peerconnection/server/server_test.html b/talk/examples/peerconnection/server/server_test.html
index be702d8..d7c2266 100644
--- a/talk/examples/peerconnection/server/server_test.html
+++ b/talk/examples/peerconnection/server/server_test.html
@@ -35,6 +35,26 @@
     if (data.search("OFFER") != -1) {
       // In loopback mode, replace the ROAP OFFER with ROAP ANSWER.
       data = data.replace("OFFER", "ANSWER");
+      // Keep only the first crypto line for each m line in the answer.
+      var mlineBegin = data.indexOf("m=", 0);
+      while (mlineBegin != -1) {
+        var cryptoBegin = data.indexOf("a=crypto:", mlineBegin);
+        if (cryptoBegin == -1) {
+          // No more crypto lines.
+          break;
+        }
+        // Skip the first crypto line.
+        cryptoBegin = data.indexOf("a=crypto:", cryptoBegin + 1);
+        // Update the mlineBegin to the the next m line.
+        mlineBegin = data.indexOf("m=", mlineBegin + 1);
+        while (cryptoBegin != -1 && cryptoBegin < mlineBegin) {
+          var cryptoEnd = data.indexOf("\\n", cryptoBegin);
+          var crypto = data.substring(cryptoBegin, cryptoEnd + 2);
+          data = data.replace(crypto, "");
+          // Search for the the next crypto line.
+          cryptoBegin = data.indexOf("a=crypto:", cryptoBegin + 1);
+        }
+      }
       var lines = data.split("\n");
       for (var i = 1; i < lines.length; ++i) {
         // Look for the offererSessionId and use it as answererSessionId
diff --git a/talk/main.scons b/talk/main.scons
index a58e115..15cbc63 100644
--- a/talk/main.scons
+++ b/talk/main.scons
@@ -100,6 +100,8 @@
     'no', 'or', 'pl', 'pt-BR', 'pt-PT', 'ro', 'ru', 'sk', 'sl', 'sr', 'sv',
     'ta', 'te', 'th', 'tl', 'tr', 'uk', 'ur', 'vi', 'zh-CN', 'zh-TW'])
 
+AddTargetGroup('all_breakpads', 'breakpad files can be built')
+
 #-------------------------------------------------------------------------------
 # W I N D O W S
 #
diff --git a/talk/p2p/base/session.cc b/talk/p2p/base/session.cc
index 2439682..aba5ac4 100644
--- a/talk/p2p/base/session.cc
+++ b/talk/p2p/base/session.cc
@@ -960,14 +960,18 @@
   }
 
   ContentInfos updated_contents = description_info.ClearContents();
-  ContentInfos::iterator it;
 
+  // TODO: Currently, reflector sends back
+  // video stream updates even for an audio-only call, which causes
+  // this to fail.  Put this back once reflector is fixed.
+  //
+  // ContentInfos::iterator it;
   // First, ensure all updates are valid before modifying remote_description_.
-  for (it = updated_contents.begin(); it != updated_contents.end(); ++it) {
-    if (remote_description()->GetContentByName(it->name) == NULL) {
-      return false;
-    }
-  }
+  // for (it = updated_contents.begin(); it != updated_contents.end(); ++it) {
+  //   if (remote_description()->GetContentByName(it->name) == NULL) {
+  //     return false;
+  //   }
+  // }
 
   // TODO: We used to replace contents from an update, but
   // that no longer works with partial updates.  We need to figure out
diff --git a/talk/session/phone/call.cc b/talk/session/phone/call.cc
index 1157519..0273353 100644
--- a/talk/session/phone/call.cc
+++ b/talk/session/phone/call.cc
@@ -607,53 +607,15 @@
     return;
   }
 
-  if (!SetSendResolutions(session, view_request)) {
-    LOG(LS_WARNING) << "Failed to set send resolutions.";
-  }
-}
-
-bool Call::SetSendResolutions(
-    Session *session, const ViewRequest& view_request) {
-  // TODO: Change resolution depending on ssrc.  For now,
-  // assume we have the same resolution for all, and change by setting
-  // the remote content to change the codecs, which changes the
-  // resolution.
-  //
-  // Eventually it should look something like this:
-  // VideoChannel *video_channel = GetVideoChannel(session);
-  // for (StaticVideoViews::const_iterator view =
-  //          view_request.static_video_views.begin();
-  //      view != view_request.static_video_views.end(); ++view) {
-  //   if (!video_channel->SetResolution(
-  //           view->ssrc, view->width, view->height, view->framerate)) {
-  //     LOG(LS_WARNING) <<
-  //         "Failed to set view request resolution of ssrc " << view->ssrc;
-  //   }
-  // }
-
   VideoChannel *video_channel = GetVideoChannel(session);
   if (video_channel == NULL) {
-    return false;
+    LOG(LS_WARNING) << "Ignore view request since we have no video channel.";
+    return;
   }
 
-  // If there are no views, set resolution to 0x0x0.
-  StaticVideoView target_view(0U, 0, 0, 0);
-  if (!view_request.static_video_views.empty()) {
-    target_view = view_request.static_video_views[0];
+  if (!video_channel->ApplyViewRequest(view_request)) {
+    LOG(LS_WARNING) << "Failed to ApplyViewRequest.";
   }
-  VideoContentDescription* target_video = new VideoContentDescription();
-  const VideoContentDescription* current_video =
-      GetFirstVideoContentDescription(session->remote_description());
-  for (VideoCodecs::const_iterator current_codec =
-           current_video->codecs().begin();
-       current_codec != current_video->codecs().end(); ++current_codec) {
-    VideoCodec target_codec = *current_codec;
-    target_codec.width = target_view.width;
-    target_codec.height = target_view.height;
-    target_codec.framerate = target_view.framerate;
-    target_video->AddCodec(target_codec);
-  }
-  return video_channel->SetRemoteContent(target_video, CA_UPDATE);
 }
 
 void FindStreamChanges(const std::vector<StreamParams>& streams,
@@ -668,7 +630,13 @@
         removed_streams->push_back(stream);
       }
     } else {
-      added_streams->push_back(*update);
+      // There's a bug on reflector that will send <stream>s even
+      // though there is not ssrc (which means there isn't really a
+      // stream).  To work around it, we simply ignore new <stream>s
+      // that don't have any ssrcs.
+      if (update->has_ssrcs()) {
+        added_streams->push_back(*update);
+      }
     }
   }
 }
diff --git a/talk/session/phone/call.h b/talk/session/phone/call.h
index 69d2941..e081c55 100644
--- a/talk/session/phone/call.h
+++ b/talk/session/phone/call.h
@@ -147,7 +147,6 @@
   void OnMediaMonitor(VideoChannel *channel, const VideoMediaInfo& info);
   VoiceChannel* GetVoiceChannel(Session *session);
   VideoChannel* GetVideoChannel(Session *session);
-  bool SetSendResolutions(Session *session, const ViewRequest& view_request);
   bool UpdateVoiceChannelRemoteContent(Session *session,
                                        const AudioContentDescription* audio);
   bool UpdateVideoChannelRemoteContent(Session *session,
diff --git a/talk/session/phone/channel.cc b/talk/session/phone/channel.cc
index 9e39088..1481887 100644
--- a/talk/session/phone/channel.cc
+++ b/talk/session/phone/channel.cc
@@ -33,16 +33,143 @@
 #include "talk/base/logging.h"
 #include "talk/p2p/base/transportchannel.h"
 #include "talk/session/phone/channelmanager.h"
+#include "talk/session/phone/mediamessages.h"
 #include "talk/session/phone/mediasessionclient.h"
 #include "talk/session/phone/rtcpmuxfilter.h"
 #include "talk/session/phone/rtputils.h"
 
 namespace cricket {
 
+enum {
+  MSG_ENABLE = 1,
+  MSG_DISABLE = 2,
+  MSG_MUTE = 3,
+  MSG_UNMUTE = 4,
+  MSG_SETREMOTECONTENT = 5,
+  MSG_SETLOCALCONTENT = 6,
+  MSG_EARLYMEDIATIMEOUT = 8,
+  MSG_PRESSDTMF = 9,
+  MSG_SETRENDERER = 10,
+  MSG_ADDRECVSTREAM = 11,
+  MSG_REMOVERECVSTREAM = 12,
+  MSG_SETRINGBACKTONE = 13,
+  MSG_PLAYRINGBACKTONE = 14,
+  MSG_SETMAXSENDBANDWIDTH = 15,
+  MSG_ADDSCREENCAST = 16,
+  MSG_REMOVESCREENCAST = 17,
+  // Removed MSG_SETRTCPCNAME = 18. It is no longer used.
+  MSG_SENDINTRAFRAME = 19,
+  MSG_REQUESTINTRAFRAME = 20,
+  MSG_SCREENCASTWINDOWEVENT = 21,
+  MSG_RTPPACKET = 22,
+  MSG_RTCPPACKET = 23,
+  MSG_CHANNEL_ERROR = 24,
+  MSG_ENABLECPUADAPTATION = 25,
+  MSG_DISABLECPUADAPTATION = 26,
+  MSG_SCALEVOLUME = 27,
+  MSG_HANDLEVIEWREQUEST = 28
+};
+
+struct SetContentData : public talk_base::MessageData {
+  SetContentData(const MediaContentDescription* content, ContentAction action)
+      : content(content),
+        action(action),
+        result(false) {
+  }
+  const MediaContentDescription* content;
+  ContentAction action;
+  bool result;
+};
+
+struct SetBandwidthData : public talk_base::MessageData {
+  explicit SetBandwidthData(int value) : value(value), result(false) {}
+  int value;
+  bool result;
+};
+
+struct SetRingbackToneMessageData : public talk_base::MessageData {
+  SetRingbackToneMessageData(const void* b, int l)
+      : buf(b),
+        len(l),
+        result(false) {
+  }
+  const void* buf;
+  int len;
+  bool result;
+};
+
+struct PlayRingbackToneMessageData : public talk_base::MessageData {
+  PlayRingbackToneMessageData(uint32 s, bool p, bool l)
+      : ssrc(s),
+        play(p),
+        loop(l),
+        result(false) {
+  }
+  uint32 ssrc;
+  bool play;
+  bool loop;
+  bool result;
+};
+struct DtmfMessageData : public talk_base::MessageData {
+  DtmfMessageData(int d, bool p)
+      : digit(d),
+        playout(p),
+        result(false) {
+  }
+  int digit;
+  bool playout;
+  bool result;
+};
+struct ScaleVolumeMessageData : public talk_base::MessageData {
+  ScaleVolumeMessageData(uint32 s, double l, double r)
+      : ssrc(s),
+        left(l),
+        right(r),
+        result(false) {
+  }
+  uint32 ssrc;
+  double left;
+  double right;
+  bool result;
+};
+
 struct PacketMessageData : public talk_base::MessageData {
   talk_base::Buffer packet;
 };
 
+struct RenderMessageData : public talk_base::MessageData {
+  RenderMessageData(uint32 s, VideoRenderer* r) : ssrc(s), renderer(r) {}
+  uint32 ssrc;
+  VideoRenderer* renderer;
+};
+
+struct ScreencastMessageData : public talk_base::MessageData {
+  ScreencastMessageData(uint32 s, const ScreencastId& id)
+      : ssrc(s),
+        window_id(id) {
+  }
+  uint32 ssrc;
+  ScreencastId window_id;
+};
+
+struct ScreencastEventData : public talk_base::MessageData {
+  ScreencastEventData(uint32 s, talk_base::WindowEvent we)
+      : ssrc(s),
+        event(we) {
+  }
+  uint32 ssrc;
+  talk_base::WindowEvent event;
+};
+
+struct ViewRequestMessageData : public talk_base::MessageData {
+  explicit ViewRequestMessageData(const ViewRequest& r)
+      : request(r),
+        result(false) {
+  }
+  ViewRequest request;
+  bool result;
+};
+
 struct VoiceChannelErrorMessageData : public talk_base::MessageData {
   VoiceChannelErrorMessageData(uint32 in_ssrc,
                                VoiceMediaChannel::Error in_error)
@@ -589,7 +716,7 @@
                        << it->first_ssrc();
           return false;
         }
-      } else if (stream_exist) {
+      } else if (stream_exist && !it->has_ssrcs()) {
         if (!media_channel()->RemoveSendStream(existing_stream.first_ssrc())) {
             LOG(LS_ERROR) << "Failed to remove send stream with ssrc "
                           << it->first_ssrc() << ".";
@@ -597,8 +724,7 @@
         }
         RemoveStreamBySsrc(&local_streams_, existing_stream.first_ssrc());
       } else {
-        LOG(LS_ERROR) << "Unknown send stream update.";
-        return false;
+        LOG(LS_WARNING) << "Ignore unsupported stream update";
       }
     }
     return true;
@@ -652,7 +778,7 @@
                        << it->first_ssrc();
           return false;
         }
-      } else if (stream_exists) {
+      } else if (stream_exists && !it->has_ssrcs()) {
         if (!RemoveRecvStream_w(existing_stream.first_ssrc())) {
             LOG(LS_ERROR) << "Failed to remove remote stream with ssrc "
                           << it->first_ssrc() << ".";
@@ -660,8 +786,7 @@
         }
         RemoveStreamBySsrc(&remote_streams_, existing_stream.first_ssrc());
       } else {
-        LOG(LS_ERROR) << "Unknown remote stream update.";
-        return false;
+        LOG(LS_WARNING) << "Ignore unsupported stream update";
       }
     }
     return true;
@@ -1212,6 +1337,12 @@
   return true;
 }
 
+bool VideoChannel::ApplyViewRequest(const ViewRequest& request) {
+  ViewRequestMessageData data(request);
+  Send(MSG_HANDLEVIEWREQUEST, &data);
+  return data.result;
+}
+
 bool VideoChannel::AddScreencast(uint32 ssrc, const ScreencastId& id) {
   ScreencastMessageData data(ssrc, id);
   Send(MSG_ADDSCREENCAST, &data);
@@ -1352,6 +1483,43 @@
   return ret;
 }
 
+bool VideoChannel::ApplyViewRequest_w(const ViewRequest& request) {
+  bool ret = true;
+  // Set the send format for each of the local streams. If the view request
+  // does not contain a local stream, set its send format to 0x0, which will
+  // drop all frames.
+  for (std::vector<StreamParams>::const_iterator it = local_streams().begin();
+      it != local_streams().end(); ++it) {
+    VideoFormat format(0, 0, 0, cricket::FOURCC_I420);
+    StaticVideoViews::const_iterator view;
+    for (view = request.static_video_views.begin();
+        view != request.static_video_views.end(); ++view) {
+      // Sender view request from Reflector has SSRC 0 (b/5977302). Here we hack
+      // the client to apply the view request with SSRC 0. TODO: Remove
+      // 0 == view->SSRC once Reflector uses the correct SSRC in view request.
+      if (it->has_ssrc(view->ssrc) || 0 == view->ssrc) {
+        format.width = view->width;
+        format.height = view->height;
+        format.interval = cricket::VideoFormat::FpsToInterval(view->framerate);
+        break;
+      }
+    }
+
+    ret &= media_channel()->SetSendStreamFormat(it->first_ssrc(), format);
+  }
+
+  // Check if the view request has invalid streams.
+  for (StaticVideoViews::const_iterator it = request.static_video_views.begin();
+      it != request.static_video_views.end(); ++it) {
+    if (!GetStreamBySsrc(local_streams(), it->ssrc, NULL)) {
+      LOG(LS_WARNING) << "View request's SSRC " << it->ssrc
+                      << " is not in the local streams.";
+    }
+  }
+
+  return ret;
+}
+
 void VideoChannel::SetRenderer_w(uint32 ssrc, VideoRenderer* renderer) {
   media_channel()->SetRenderer(ssrc, renderer);
 }
@@ -1415,6 +1583,12 @@
       delete data;
       break;
     }
+    case MSG_HANDLEVIEWREQUEST: {
+      ViewRequestMessageData* data =
+          static_cast<ViewRequestMessageData*>(pmsg->pdata);
+      data->result = ApplyViewRequest_w(data->request);
+      break;
+    }
     default:
       BaseChannel::OnMessage(pmsg);
       break;
diff --git a/talk/session/phone/channel.h b/talk/session/phone/channel.h
index 42f3969..df0124f 100644
--- a/talk/session/phone/channel.h
+++ b/talk/session/phone/channel.h
@@ -52,35 +52,7 @@
 
 class MediaContentDescription;
 struct CryptoParams;
-
-enum {
-  MSG_ENABLE = 1,
-  MSG_DISABLE = 2,
-  MSG_MUTE = 3,
-  MSG_UNMUTE = 4,
-  MSG_SETREMOTECONTENT = 5,
-  MSG_SETLOCALCONTENT = 6,
-  MSG_EARLYMEDIATIMEOUT = 8,
-  MSG_PRESSDTMF = 9,
-  MSG_SETRENDERER = 10,
-  MSG_ADDRECVSTREAM = 11,
-  MSG_REMOVERECVSTREAM = 12,
-  MSG_SETRINGBACKTONE = 13,
-  MSG_PLAYRINGBACKTONE = 14,
-  MSG_SETMAXSENDBANDWIDTH = 15,
-  MSG_ADDSCREENCAST = 16,
-  MSG_REMOVESCREENCAST = 17,
-  // Removed MSG_SETRTCPCNAME = 18. It is no longer used.
-  MSG_SENDINTRAFRAME = 19,
-  MSG_REQUESTINTRAFRAME = 20,
-  MSG_SCREENCASTWINDOWEVENT = 21,
-  MSG_RTPPACKET = 22,
-  MSG_RTCPPACKET = 23,
-  MSG_CHANNEL_ERROR = 24,
-  MSG_ENABLECPUADAPTATION = 25,
-  MSG_DISABLECPUADAPTATION = 26,
-  MSG_SCALEVOLUME = 27
-};
+struct ViewRequest;
 
 // BaseChannel contains logic common to voice and video, including
 // enable/mute, marshaling calls to a worker thread, and
@@ -226,14 +198,6 @@
   bool RemoveRecvStream_w(uint32 ssrc);
 
   virtual void ChangeState() = 0;
-  struct SetContentData : public talk_base::MessageData {
-    SetContentData(const MediaContentDescription* content,
-                   ContentAction action)
-        : content(content), action(action), result(false) {}
-    const MediaContentDescription* content;
-    ContentAction action;
-    bool result;
-  };
 
   // Gets the content appropriate to the channel (audio or video).
   virtual const MediaContentDescription* GetFirstContent(
@@ -255,11 +219,6 @@
                  ContentSource src);
   bool SetRtcpMux_w(bool enable, ContentAction action, ContentSource src);
 
-  struct SetBandwidthData : public talk_base::MessageData {
-    explicit SetBandwidthData(int value) : value(value), result(false) {}
-    int value;
-    bool result;
-  };
   bool SetMaxSendBandwidth_w(int max_bandwidth);
 
   // From MessageHandler
@@ -353,51 +312,6 @@
   static const int kTypingBlackoutPeriod = 1500;
 
  private:
-  struct SetRingbackToneMessageData : public talk_base::MessageData {
-    SetRingbackToneMessageData(const void* b, int l)
-        : buf(b),
-          len(l),
-          result(false) {
-    }
-    const void* buf;
-    int len;
-    bool result;
-  };
-  struct PlayRingbackToneMessageData : public talk_base::MessageData {
-    PlayRingbackToneMessageData(uint32 s, bool p, bool l)
-        : ssrc(s),
-          play(p),
-          loop(l),
-          result(false) {
-    }
-    uint32 ssrc;
-    bool play;
-    bool loop;
-    bool result;
-  };
-  struct DtmfMessageData : public talk_base::MessageData {
-    DtmfMessageData(int d, bool p)
-        : digit(d),
-          playout(p),
-          result(false) {
-    }
-    int digit;
-    bool playout;
-    bool result;
-  };
-  struct ScaleVolumeMessageData : public talk_base::MessageData {
-    ScaleVolumeMessageData(uint32 s, double l, double r)
-        : ssrc(s),
-          left(l),
-          right(r),
-          result(false) {
-    }
-    uint32 ssrc;
-    double left;
-    double right;
-    bool result;
-  };
-
   // overrides from BaseChannel
   virtual void OnChannelRead(TransportChannel* channel,
                              const char *data, size_t len);
@@ -449,6 +363,7 @@
   }
 
   bool SetRenderer(uint32 ssrc, VideoRenderer* renderer);
+  bool ApplyViewRequest(const ViewRequest& request);
 
   bool AddScreencast(uint32 ssrc, const ScreencastId& id);
   bool RemoveScreencast(uint32 ssrc);
@@ -491,26 +406,7 @@
     media_channel()->SetOptions(enable ? OPT_CPU_ADAPTATION : 0);
   }
 
-  struct RenderMessageData : public talk_base::MessageData {
-    RenderMessageData(uint32 s, VideoRenderer* r) : ssrc(s), renderer(r) {}
-    uint32 ssrc;
-    VideoRenderer* renderer;
-  };
-
-  struct ScreencastMessageData : public talk_base::MessageData {
-    ScreencastMessageData(uint32 s, const ScreencastId& id)
-        : ssrc(s), window_id(id) {}
-    uint32 ssrc;
-    ScreencastId window_id;
-  };
-
-  struct ScreencastEventData : public talk_base::MessageData {
-    ScreencastEventData(uint32 s, talk_base::WindowEvent we)
-        : ssrc(s), event(we) {}
-    uint32 ssrc;
-    talk_base::WindowEvent event;
-  };
-
+  bool ApplyViewRequest_w(const ViewRequest& request);
   void SetRenderer_w(uint32 ssrc, VideoRenderer* renderer);
 
   void AddScreencast_w(uint32 ssrc, const ScreencastId&);
diff --git a/talk/session/phone/channel_unittest.cc b/talk/session/phone/channel_unittest.cc
index a134f45..fa6c938 100644
--- a/talk/session/phone/channel_unittest.cc
+++ b/talk/session/phone/channel_unittest.cc
@@ -33,6 +33,7 @@
 #include "talk/session/phone/channel.h"
 #include "talk/session/phone/fakemediaengine.h"
 #include "talk/session/phone/fakertp.h"
+#include "talk/session/phone/mediamessages.h"
 #include "talk/session/phone/mediasessionclient.h"
 #include "talk/session/phone/mediarecorder.h"
 #include "talk/session/phone/rtpdump.h"
@@ -540,6 +541,16 @@
     ASSERT_EQ(2u, media_channel1_->send_streams().size());
     EXPECT_EQ(stream2, media_channel1_->send_streams()[0]);
     EXPECT_EQ(stream3, media_channel1_->send_streams()[1]);
+
+    // Update the local streams with a stream that does not change.
+    // THe update is ignored.
+    typename T::Content content4;
+    content4.AddStream(stream2);
+    content4.set_partial(true);
+    EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_UPDATE));
+    ASSERT_EQ(2u, media_channel1_->send_streams().size());
+    EXPECT_EQ(stream2, media_channel1_->send_streams()[0]);
+    EXPECT_EQ(stream3, media_channel1_->send_streams()[1]);
   }
 
   // Test that SetRemoteContent properly handles adding and removing
@@ -598,6 +609,16 @@
     ASSERT_EQ(2u, media_channel1_->recv_streams().size());
     EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
     EXPECT_EQ(stream3, media_channel1_->recv_streams()[1]);
+
+    // Update the remote streams with a stream that does not change.
+    // The update is ignored.
+    typename T::Content content4;
+    content4.AddStream(stream2);
+    content4.set_partial(true);
+    EXPECT_TRUE(channel1_->SetRemoteContent(&content4, CA_UPDATE));
+    ASSERT_EQ(2u, media_channel1_->recv_streams().size());
+    EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
+    EXPECT_EQ(stream3, media_channel1_->recv_streams()[1]);
   }
 
   // Test that SetLocalContent and SetRemoteContent properly
@@ -1855,3 +1876,41 @@
 TEST_F(VideoChannelTest, TestSrtpError) {
   Base::TestSrtpError();
 }
+
+TEST_F(VideoChannelTest, TestApplyViewRequest) {
+  CreateChannels(0, 0);
+  EXPECT_TRUE(SendInitiate());
+  EXPECT_TRUE(SendAccept());
+
+  cricket::VideoFormat send_format;
+  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
+  EXPECT_EQ(640, send_format.width);
+  EXPECT_EQ(400, send_format.height);
+  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), send_format.interval);
+
+  cricket::ViewRequest request;
+  request.static_video_views.push_back(
+      cricket::StaticVideoView(kSsrc1, 320, 200, 15));
+  EXPECT_TRUE(channel1_->ApplyViewRequest(request));
+  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
+  EXPECT_EQ(320, send_format.width);
+  EXPECT_EQ(200, send_format.height);
+  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(15), send_format.interval);
+
+  // Short term hack for view request with SSRC 0. TODO: Remove this
+  // once Reflector uses the correct SSRC in view request (b/5977302).
+  request.static_video_views.clear();
+  request.static_video_views.push_back(
+      cricket::StaticVideoView(0, 160, 100, 8));
+  EXPECT_TRUE(channel1_->ApplyViewRequest(request));
+  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
+  EXPECT_EQ(160, send_format.width);
+  EXPECT_EQ(100, send_format.height);
+  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(8), send_format.interval);
+
+  request.static_video_views.clear();
+  EXPECT_TRUE(channel1_->ApplyViewRequest(request));
+  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
+  EXPECT_EQ(0, send_format.width);
+  EXPECT_EQ(0, send_format.height);
+}
diff --git a/talk/session/phone/fakemediaengine.h b/talk/session/phone/fakemediaengine.h
index 4f83549..b772c9c 100644
--- a/talk/session/phone/fakemediaengine.h
+++ b/talk/session/phone/fakemediaengine.h
@@ -474,8 +474,6 @@
   void set_requested_intra_frame(bool v) { requested_intra_frame_ = v; }
   bool requested_intra_frame() const { return requested_intra_frame_; }
   bool screen_casting() const { return screen_casting_; }
-  // TODO: remove this with FMS CL
-  bool IsScreencasting() const { return screen_casting_; }
 
  private:
   // Be default, each send stream uses the first send codec format.
diff --git a/talk/session/phone/fakenetworkinterface.h b/talk/session/phone/fakenetworkinterface.h
index 09c3bf7..58b24a2 100644
--- a/talk/session/phone/fakenetworkinterface.h
+++ b/talk/session/phone/fakenetworkinterface.h
@@ -76,9 +76,13 @@
     return rtp_packets_.size();
   }
 
+  // Note: callers are responsible for deleting the returned buffer.
   const talk_base::Buffer* GetRtpPacket(int index) {
     talk_base::CritScope cs(&crit_);
-    return (index < NumRtpPackets()) ? &rtp_packets_[index] : NULL;
+    if (index >= NumRtpPackets()) {
+      return NULL;
+    }
+    return new talk_base::Buffer(rtp_packets_[index]);
   }
 
   int NumRtcpPackets() {
@@ -86,9 +90,13 @@
     return rtcp_packets_.size();
   }
 
+  // Note: callers are responsible for deleting the returned buffer.
   const talk_base::Buffer* GetRtcpPacket(int index) {
     talk_base::CritScope cs(&crit_);
-    return (index < NumRtcpPackets()) ? &rtcp_packets_[index] : NULL;
+    if (index >= NumRtcpPackets()) {
+      return NULL;
+    }
+    return new talk_base::Buffer(rtcp_packets_[index]);
   }
 
   int sendbuf_size() const { return sendbuf_size_; }
diff --git a/talk/session/phone/mediasession.cc b/talk/session/phone/mediasession.cc
index 67ac082..ed4eaa7 100644
--- a/talk/session/phone/mediasession.cc
+++ b/talk/session/phone/mediasession.cc
@@ -254,12 +254,14 @@
 }
 
 MediaSessionDescriptionFactory::MediaSessionDescriptionFactory()
-    : secure_(SEC_DISABLED) {
+    : secure_(SEC_DISABLED),
+      add_legacy_(true) {
 }
 
 MediaSessionDescriptionFactory::MediaSessionDescriptionFactory(
     ChannelManager* channel_manager)
-    : secure_(SEC_DISABLED) {
+    : secure_(SEC_DISABLED),
+      add_legacy_(true) {
   channel_manager->GetSupportedAudioCodecs(&audio_codecs_);
   channel_manager->GetSupportedVideoCodecs(&video_codecs_);
 }
@@ -284,7 +286,7 @@
       return NULL;  // Abort, something went seriously wrong.
     }
 
-    if (options.streams.empty()) {
+    if (options.streams.empty() && add_legacy_) {
       // TODO: Remove this legacy stream when all apps use StreamParams.
       audio->AddLegacyStream(talk_base::CreateRandomNonZeroId());
     }
@@ -337,7 +339,7 @@
       return NULL;  // Abort, something went seriously wrong.
     }
 
-    if (options.streams.empty()) {
+    if (options.streams.empty() && add_legacy_) {
       // TODO: Remove this legacy stream when all apps use StreamParams.
       video->AddLegacyStream(talk_base::CreateRandomNonZeroId());
     }
@@ -410,7 +412,7 @@
       return NULL;  // Abort, something went seriously wrong.
     }
 
-    if (options.streams.empty()) {
+    if (options.streams.empty() && add_legacy_) {
       // TODO: Remove this legacy stream when all apps use StreamParams.
       audio_accept->AddLegacyStream(talk_base::CreateRandomNonZeroId());
     }
@@ -475,7 +477,7 @@
       return NULL;  // Abort, something went seriously wrong.
     }
 
-    if (options.streams.empty()) {
+    if (options.streams.empty() && add_legacy_) {
       // TODO: Remove this legacy stream when all apps use StreamParams.
       video_accept->AddLegacyStream(talk_base::CreateRandomNonZeroId());
     }
diff --git a/talk/session/phone/mediasession.h b/talk/session/phone/mediasession.h
index c2798c0..718f013 100644
--- a/talk/session/phone/mediasession.h
+++ b/talk/session/phone/mediasession.h
@@ -285,6 +285,11 @@
   void set_video_codecs(const VideoCodecs& codecs) { video_codecs_ = codecs; }
   SecureMediaPolicy secure() const { return secure_; }
   void set_secure(SecureMediaPolicy s) { secure_ = s; }
+  // Decides if a StreamParams shall be added to the audio and video media
+  // content in SessionDescription when CreateOffer and CreateAnswer is called
+  // even if |options| don't include a Stream. This is needed to support legacy
+  // applications. |add_legacy_| is true per default.
+  void set_add_legacy_streams(bool add_legacy) { add_legacy_ = add_legacy; }
 
   SessionDescription* CreateOffer(
       const MediaSessionOptions& options,
@@ -299,6 +304,7 @@
   AudioCodecs audio_codecs_;
   VideoCodecs video_codecs_;
   SecureMediaPolicy secure_;
+  bool add_legacy_;
   std::string lang_;
 };
 
diff --git a/talk/session/phone/mediasession_unittest.cc b/talk/session/phone/mediasession_unittest.cc
index 9bb2db2..974531e 100644
--- a/talk/session/phone/mediasession_unittest.cc
+++ b/talk/session/phone/mediasession_unittest.cc
@@ -221,6 +221,28 @@
   ASSERT_CRYPTO(vcd, false, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 }
 
+// Create an audio, video offer without legacy StreamParams.
+TEST_F(MediaSessionDescriptionFactoryTest,
+       TestCreateOfferWithoutLegacyStreams) {
+  MediaSessionOptions opts;
+  opts.has_video = true;
+  f1_.set_add_legacy_streams(false);
+  talk_base::scoped_ptr<SessionDescription>
+      offer(f1_.CreateOffer(opts, NULL));
+  ASSERT_TRUE(offer.get() != NULL);
+  const ContentInfo* ac = offer->GetContentByName("audio");
+  const ContentInfo* vc = offer->GetContentByName("video");
+  ASSERT_TRUE(ac != NULL);
+  ASSERT_TRUE(vc != NULL);
+  const AudioContentDescription* acd =
+      static_cast<const AudioContentDescription*>(ac->description);
+  const VideoContentDescription* vcd =
+      static_cast<const VideoContentDescription*>(vc->description);
+
+  EXPECT_FALSE(vcd->has_ssrcs());             // No StreamParams.
+  EXPECT_FALSE(acd->has_ssrcs());             // No StreamParams.
+}
+
 // Create a typical audio answer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswer) {
   f1_.set_secure(SEC_ENABLED);
@@ -278,6 +300,30 @@
   ASSERT_CRYPTO(vcd, false, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 }
 
+// Create an audio, video answer without legacy StreamParams.
+TEST_F(MediaSessionDescriptionFactoryTest,
+       TestCreateAnswerWithoutLegacyStreams) {
+  MediaSessionOptions opts;
+  opts.has_video = true;
+  f1_.set_add_legacy_streams(false);
+  f2_.set_add_legacy_streams(false);
+  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  ASSERT_TRUE(offer.get() != NULL);
+  talk_base::scoped_ptr<SessionDescription> answer(
+      f2_.CreateAnswer(offer.get(), opts, NULL));
+  const ContentInfo* ac = answer->GetContentByName("audio");
+  const ContentInfo* vc = answer->GetContentByName("video");
+  ASSERT_TRUE(ac != NULL);
+  ASSERT_TRUE(vc != NULL);
+  const AudioContentDescription* acd =
+      static_cast<const AudioContentDescription*>(ac->description);
+  const VideoContentDescription* vcd =
+      static_cast<const VideoContentDescription*>(vc->description);
+
+  EXPECT_FALSE(acd->has_ssrcs());  // No StreamParams.
+  EXPECT_FALSE(vcd->has_ssrcs());  // No StreamParams.
+}
+
 TEST_F(MediaSessionDescriptionFactoryTest, TestPartial) {
   MediaSessionOptions opts;
   opts.has_video = true;
diff --git a/talk/session/phone/mediasessionclient_unittest.cc b/talk/session/phone/mediasessionclient_unittest.cc
index c698e78..8232d3d 100644
--- a/talk/session/phone/mediasessionclient_unittest.cc
+++ b/talk/session/phone/mediasessionclient_unittest.cc
@@ -883,6 +883,38 @@
       "</iq>";
 }
 
+std::string JingleStreamAddWithoutSsrc(const std::string& content_name,
+                                       const std::string& nick,
+                                       const std::string& name) {
+  return \
+      "<iq"
+      "  xmlns='jabber:client'"
+      "  from='me@mydomain.com'"
+      "  to='user@domain.com/resource'"
+      "  type='set'"
+      "  id='150'>"
+      "  <jingle"
+      "    xmlns='urn:xmpp:jingle:1'"
+      "    action='description-info'>"
+      "    <content"
+      "      xmlns='urn:xmpp:jingle:1'"
+      "      name='" + content_name + "'>"
+      "      <description"
+      "        xmlns='urn:xmpp:jingle:apps:rtp:1'"
+      "        media='" + content_name + "'>"
+      "        <streams"
+      "          xmlns='google:jingle'>"
+      "          <stream"
+      "            nick='" + nick + "'"
+      "            name='" + name + "'>"
+       "          </stream>"
+      "        </streams>"
+      "      </description>"
+      "    </content>"
+      "  </jingle>"
+      "</iq>";
+}
+
 std::string JingleStreamRemove(const std::string& content_name,
                                const std::string& nick,
                                const std::string& name) {
@@ -2126,6 +2158,20 @@
     ASSERT_EQ(1U, last_streams_added_.audio()[0].ssrcs.size());
     ASSERT_EQ(1234U, last_streams_added_.audio()[0].first_ssrc());
 
+    // Ignores adds without ssrcs.
+    streams_stanza.reset(buzz::XmlElement::ForStr(
+        JingleStreamAddWithoutSsrc("audio", "Bob", "audioX")));
+    SetJingleSid(streams_stanza.get());
+    client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+    ASSERT_EQ(1U, last_streams_added_.audio().size());
+    ASSERT_EQ(1234U, last_streams_added_.audio()[0].first_ssrc());
+
+    // Ignores stream updates with unknown content names. (Don't terminate).
+    streams_stanza.reset(buzz::XmlElement::ForStr(
+        JingleStreamAddWithoutSsrc("foo", "Bob", "foo")));
+    SetJingleSid(streams_stanza.get());
+    client_->session_manager()->OnIncomingMessage(streams_stanza.get());
+
     streams_stanza.reset(buzz::XmlElement::ForStr(
         JingleStreamAdd("audio", "Joe", "audio1", "2468")));
     SetJingleSid(streams_stanza.get());
diff --git a/talk/session/phone/videoadapter.cc b/talk/session/phone/videoadapter.cc
index 1cb1cc4..4313fc7 100644
--- a/talk/session/phone/videoadapter.cc
+++ b/talk/session/phone/videoadapter.cc
@@ -118,7 +118,8 @@
 ///////////////////////////////////////////////////////////////////////
 // Implementation of VideoAdapter
 VideoAdapter::VideoAdapter()
-    : black_output_(false),
+    : output_num_pixels_(0),
+      black_output_(false),
       is_black_(false),
       drop_frame_count_(0) {
 }
diff --git a/talk/session/phone/videocapturer.cc b/talk/session/phone/videocapturer.cc
index ac544eb..7f86293 100644
--- a/talk/session/phone/videocapturer.cc
+++ b/talk/session/phone/videocapturer.cc
@@ -105,6 +105,7 @@
     }
   }
   if (supported_formats_->end() == best) {
+    LOG(LS_ERROR) << " No acceptable camera format found";
     return false;
   }
 
@@ -207,10 +208,11 @@
   if (delta_fps < 0) {
     // For same resolution, prefer higher framerate but accept lower.
     // Otherwise prefer higher resolution.
-    distance |= static_cast<int64>(1) << 15;
     delta_fps = -delta_fps;
-    if (supported_fps <  kMinDesirableFps) {
-      distance |= kMaxDistance;
+    if (supported_fps < kMinDesirableFps) {
+      distance |= static_cast<int64>(1) << 62;
+    } else {
+      distance |= static_cast<int64>(1) << 15;
     }
   }
 
diff --git a/talk/session/phone/videocapturer_unittest.cc b/talk/session/phone/videocapturer_unittest.cc
index 1b73b15..5bd2419 100644
--- a/talk/session/phone/videocapturer_unittest.cc
+++ b/talk/session/phone/videocapturer_unittest.cc
@@ -248,6 +248,54 @@
   }
 }
 
+// Some cameras only have very low fps. Verify we choose something sensible.
+TEST(VideoCapturerTest, TestPoorFpsFormats) {
+  FakeVideoCapturer capturer;
+  // all formats are low framerate
+  std::vector<cricket::VideoFormat> supported_formats;
+  supported_formats.push_back(cricket::VideoFormat(320, 240,
+      cricket::VideoFormat::FpsToInterval(10), cricket::FOURCC_I420));
+  supported_formats.push_back(cricket::VideoFormat(640, 480,
+      cricket::VideoFormat::FpsToInterval(7), cricket::FOURCC_I420));
+  supported_formats.push_back(cricket::VideoFormat(1280, 720,
+      cricket::VideoFormat::FpsToInterval(2), cricket::FOURCC_I420));
+  capturer.ResetSupportedFormats(supported_formats);
+
+  std::vector<cricket::VideoFormat> required_formats;
+  required_formats.push_back(cricket::VideoFormat(320, 240,
+      cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+  required_formats.push_back(cricket::VideoFormat(640, 480,
+      cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
+  cricket::VideoFormat best;
+  for (size_t i = 0; i < required_formats.size(); ++i) {
+    EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[i], &best));
+#ifdef OSX
+    EXPECT_EQ(640, best.width);
+    EXPECT_EQ(480, best.height);
+#else
+    EXPECT_EQ(required_formats[i].width, best.width);
+    EXPECT_EQ(required_formats[i].height, best.height);
+#endif
+  }
+
+  // Increase framerate of 320x240.  Expect low fps VGA avoided.
+  // Except on Mac, where QVGA is avoid due to aspect ratio.
+  supported_formats.clear();
+  supported_formats.push_back(cricket::VideoFormat(320, 240,
+      cricket::VideoFormat::FpsToInterval(15), cricket::FOURCC_I420));
+  supported_formats.push_back(cricket::VideoFormat(640, 480,
+      cricket::VideoFormat::FpsToInterval(7), cricket::FOURCC_I420));
+  supported_formats.push_back(cricket::VideoFormat(1280, 720,
+      cricket::VideoFormat::FpsToInterval(2), cricket::FOURCC_I420));
+  capturer.ResetSupportedFormats(supported_formats);
+
+  for (size_t i = 0; i < required_formats.size(); ++i) {
+    EXPECT_TRUE(capturer.GetBestCaptureFormat(required_formats[i], &best));
+    EXPECT_EQ(320, best.width);
+    EXPECT_EQ(240, best.height);
+  }
+}
+
 // Some cameras support same size with different frame rates. Verify we choose
 // the frame rate properly.
 TEST(VideoCapturerTest, TestSameSizeDifferentFpsFormats) {
diff --git a/talk/session/phone/webrtcvideoengine.cc b/talk/session/phone/webrtcvideoengine.cc
index 88c8a94..07ab5e6 100644
--- a/talk/session/phone/webrtcvideoengine.cc
+++ b/talk/session/phone/webrtcvideoengine.cc
@@ -108,8 +108,11 @@
       return 0;
     }
     WebRtcVideoFrame video_frame;
+    // Convert 90K timestamp to ns timestamp.
+    int64 time_stamp_in_ns = (time_stamp / 90) *
+       talk_base::kNumNanosecsPerMillisec;
     video_frame.Attach(buffer, buffer_size, width_, height_,
-                       1, 1, 0, time_stamp, 0);
+                       1, 1, 0, time_stamp_in_ns, 0);
 
 
     // Sanity check on decoded frame size.
@@ -249,20 +252,20 @@
  public:
   explicit WebRtcVideoChannelInfo(int channel_id)
       : channel_id_(channel_id),
-        renderer_(NULL),
+        render_adapter_(NULL),
         decoder_observer_(channel_id) {
   }
   int channel_id() { return channel_id_; }
   void SetRenderer(VideoRenderer* renderer) {
-    renderer_.SetRenderer(renderer);
+    render_adapter_.SetRenderer(renderer);
   }
-  WebRtcRenderAdapter* render_adapter() { return &renderer_; }
+  WebRtcRenderAdapter* render_adapter() { return &render_adapter_; }
   WebRtcDecoderObserver* decoder_observer() { return &decoder_observer_; }
 
  private:
   int channel_id_;  // Webrtc video channel number.
   // Renderer for this channel.
-  WebRtcRenderAdapter renderer_;
+  WebRtcRenderAdapter render_adapter_;
   WebRtcDecoderObserver decoder_observer_;
 };
 
@@ -1019,6 +1022,7 @@
       render_started_(false),
       muted_(false),
       local_ssrc_(0),
+      first_receive_ssrc_(0),
       send_min_bitrate_(kMinVideoBitrate),
       send_start_bitrate_(kStartVideoBitrate),
       send_max_bitrate_(kMaxVideoBitrate),
@@ -1276,7 +1280,7 @@
     }
   }
   sending_ = send;
-
+  
   return true;
 }
 
@@ -1337,6 +1341,17 @@
 }
 
 bool WebRtcVideoMediaChannel::AddRecvStream(const StreamParams& sp) {
+  // TODO Remove this once BWE works properly across different send
+  // and receive channels.
+  // Reuse default channel for recv stream in 1:1 call.
+  if ((channel_options_ & OPT_CONFERENCE) == 0 && first_receive_ssrc_ == 0) {
+    LOG(LS_INFO) << "Recv stream " << sp.first_ssrc()
+                 << " reuse default channel #"
+                 << vie_channel_;
+    first_receive_ssrc_ = sp.first_ssrc();
+    return true;
+  }
+
   if (mux_channels_.find(sp.first_ssrc()) != mux_channels_.end()) {
     LOG(LS_ERROR) << "Stream already exists";
     return false;
@@ -1358,12 +1373,28 @@
     LOG_RTCERR1(CreateChannel, channel_id);
     return false;
   }
-  if (!ConfigureChannel(channel_id) || !ConfigureReceiving(channel_id,
-                                                           sp.first_ssrc())) {
+
+  // Get the default renderer.
+  VideoRenderer* default_renderer = NULL;
+  if ((channel_options_ & OPT_CONFERENCE) != 0) {
+    if (mux_channels_.size() == 1 &&
+        mux_channels_.find(0) != mux_channels_.end()) {
+      GetRenderer(0, &default_renderer);
+    }
+  }
+
+  if (!ConfigureChannel(channel_id) ||
+      !ConfigureReceiving(channel_id, sp.first_ssrc())) {
     engine_->vie()->base()->DeleteChannel(channel_id);
     return false;
   }
 
+  // The first recv stream reuses the default renderer (if a default renderer
+  // has been set).
+  if (default_renderer) {
+    SetRenderer(sp.first_ssrc(), default_renderer);
+  }
+
   LOG(LS_INFO) << "New video stream " << sp.first_ssrc()
                << " registered to VideoEngine channel #"
                << channel_id;
@@ -1375,6 +1406,13 @@
   ChannelMap::iterator it = mux_channels_.find(ssrc);
 
   if (it == mux_channels_.end()) {
+    // TODO: Remove this once BWE works properly across different send
+    // and receive channels.
+    // The default channel is reused for recv stream in 1:1 call.
+    if (first_receive_ssrc_ == ssrc) {
+      first_receive_ssrc_ = 0;
+      return true;
+    }
     return false;
   }
   WebRtcVideoChannelInfo* info = it->second;
@@ -1413,6 +1451,11 @@
     LOG_RTCERR1(StartSend, vie_channel_);
     return false;
   }
+
+  // TODO Change this once REMB supporting multiple sending channels.
+  // Send remb (2nd param) and use remb for BWE (3rd param).
+  engine_->vie()->rtp()->SetRembStatus(vie_channel_, true, true);
+
   return true;
 }
 
@@ -1421,13 +1464,30 @@
     LOG_RTCERR1(StopSend, vie_channel_);
     return false;
   }
+
+  // TODO Change this once REMB supporting multiple sending channels.
+  // Don't send remb (2nd param) but use remb for BWE (3rd param).
+  engine_->vie()->rtp()->SetRembStatus(vie_channel_, false, true);
+
   return true;
 }
 
 bool WebRtcVideoMediaChannel::SetRenderer(uint32 ssrc,
                                           VideoRenderer* renderer) {
-  if (mux_channels_.find(ssrc) == mux_channels_.end())
+  if (mux_channels_.find(ssrc) == mux_channels_.end()) {
+    // TODO: Remove this once BWE works properly across different send
+    // and receive channels.
+    // The default channel is reused for recv stream in 1:1 call.
+    if (first_receive_ssrc_ == ssrc &&
+        mux_channels_.find(0) != mux_channels_.end()) {
+      LOG(LS_INFO) << "SetRenderer " << ssrc
+                   << " reuse default channel #"
+                   << vie_channel_;
+      mux_channels_[0]->SetRenderer(renderer);
+      return true;
+    }
     return false;
+  }
 
   mux_channels_[ssrc]->SetRenderer(renderer);
   return true;
@@ -1705,8 +1765,18 @@
 bool WebRtcVideoMediaChannel::GetRenderer(uint32 ssrc,
                                           VideoRenderer** renderer) {
   ChannelMap::const_iterator it = mux_channels_.find(ssrc);
-  if (it == mux_channels_.end())
+  if (it == mux_channels_.end()) {
+    if (first_receive_ssrc_ == ssrc &&
+        mux_channels_.find(0) != mux_channels_.end()) {
+      LOG(LS_INFO) << " GetRenderer " << ssrc
+                   << " reuse default renderer #"
+                   << vie_channel_;
+      *renderer = mux_channels_[0]->render_adapter()->renderer();
+      return true;
+    }
     return false;
+  }
+
   *renderer = it->second->render_adapter()->renderer();
   return true;
 }
@@ -1802,9 +1872,11 @@
       // Not a fatal error.
     }
   }
-  // Install a render adapter.
+
   talk_base::scoped_ptr<WebRtcVideoChannelInfo> channel_info(
       new WebRtcVideoChannelInfo(channel_id));
+
+  // Install a render adapter.
   if (engine_->vie()->render()->AddRenderer(channel_id,
       webrtc::kVideoI420, channel_info->render_adapter()) != 0) {
     LOG_RTCERR3(AddRenderer, channel_id, webrtc::kVideoI420,
@@ -1812,15 +1884,11 @@
     return false;
   }
 
-  // Turn on REMB-based BWE reporting.
-  // First parameter is channel id, second is if this channel should send REMB
-  // packets, last parameter is if it should report BWE using REMB.
-  // TODO: |send_remb| should be channel id so we can have several
-  // REMB groups.
-  bool send_remb = (remote_ssrc == 0);  // SSRC 0 is our default channel.
-  // TODO - Add return value check for SetRembStatus once webrtc
-  // revisions are synced in Chrome and Plugin.
-  engine_->vie()->rtp()->SetRembStatus(channel_id, send_remb, true);
+  // TODO Change this once REMB supporting multiple sending channels.
+  // Turn off remb sending (2nd param) and turn on remb reporting (3rd param)
+  // here.
+  // For sending channel, remb sending will be turned on after StartSending.
+  engine_->vie()->rtp()->SetRembStatus(channel_id, false, true);
 
   if (remote_ssrc != 0) {
     // Use the same SSRC as our default channel
diff --git a/talk/session/phone/webrtcvideoengine.h b/talk/session/phone/webrtcvideoengine.h
index 7085dbe..8eb56da 100644
--- a/talk/session/phone/webrtcvideoengine.h
+++ b/talk/session/phone/webrtcvideoengine.h
@@ -298,6 +298,7 @@
   bool muted_;  // Flag to tell if we need to mute video.
   // Our local SSRC. Currently only one send stream is supported.
   uint32 local_ssrc_;
+  uint32 first_receive_ssrc_;
   int send_min_bitrate_;
   int send_start_bitrate_;
   int send_max_bitrate_;
diff --git a/talk/session/phone/webrtcvideoengine_unittest.cc b/talk/session/phone/webrtcvideoengine_unittest.cc
index a051989..b0bf813 100644
--- a/talk/session/phone/webrtcvideoengine_unittest.cc
+++ b/talk/session/phone/webrtcvideoengine_unittest.cc
@@ -354,6 +354,12 @@
 TEST_F(WebRtcVideoEngineTestFake, RembEnabled) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = vie_.GetLastChannel();
+  EXPECT_TRUE(channel_->AddSendStream(
+      cricket::StreamParams::CreateLegacy(1)));
+  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+  EXPECT_FALSE(vie_.GetRembStatusSend(channel_num));
+  EXPECT_TRUE(channel_->SetSend(true));
   EXPECT_TRUE(vie_.GetRembStatus(channel_num));
   EXPECT_TRUE(vie_.GetRembStatusSend(channel_num));
 }
@@ -362,8 +368,66 @@
 // channel for sending remb packets.
 TEST_F(WebRtcVideoEngineTestFake, RembEnabledOnReceiveChannels) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   int channel_num = vie_.GetLastChannel();
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+  EXPECT_TRUE(channel_->AddSendStream(
+      cricket::StreamParams::CreateLegacy(1)));
+  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+  EXPECT_FALSE(vie_.GetRembStatusSend(channel_num));
+  EXPECT_TRUE(channel_->SetSend(true));
+  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+  int new_channel_num = vie_.GetLastChannel();
+  EXPECT_NE(channel_num, new_channel_num);
+
+  EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+  EXPECT_TRUE(vie_.GetRembStatusSend(channel_num));
+  EXPECT_TRUE(vie_.GetRembStatus(new_channel_num));
+  EXPECT_FALSE(vie_.GetRembStatusSend(new_channel_num));
+}
+
+// Test that AddRecvStream doesn't create new channel for 1:1 call.
+TEST_F(WebRtcVideoEngineTestFake, AddRecvStream1On1) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = vie_.GetLastChannel();
+  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+  EXPECT_EQ(channel_num, vie_.GetLastChannel());
+}
+
+// Test that AddRecvStream doesn't change remb for 1:1 call.
+TEST_F(WebRtcVideoEngineTestFake, NoRembChangeAfterAddRecvStream) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = vie_.GetLastChannel();
+  EXPECT_TRUE(channel_->AddSendStream(
+      cricket::StreamParams::CreateLegacy(1)));
+  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+  EXPECT_FALSE(vie_.GetRembStatusSend(channel_num));
+  EXPECT_TRUE(channel_->SetSend(true));
+  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+  EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+  EXPECT_TRUE(vie_.GetRembStatusSend(channel_num));
+}
+
+// Test remb sending is on after StartSending and off after StopSending.
+TEST_F(WebRtcVideoEngineTestFake, RembOnOff) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = vie_.GetLastChannel();
+
+  // Verify remb sending is off before StartSending.
+  EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+  EXPECT_FALSE(vie_.GetRembStatusSend(channel_num));
+
+  // Verify remb sending is on after StartSending.
+  EXPECT_TRUE(channel_->AddSendStream(
+      cricket::StreamParams::CreateLegacy(1)));
+  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  EXPECT_TRUE(channel_->SetSend(true));
+  EXPECT_TRUE(vie_.GetRembStatus(channel_num));
+  EXPECT_TRUE(vie_.GetRembStatusSend(channel_num));
+
+  // Verify remb sending is off after StopSending.
+  EXPECT_TRUE(channel_->SetSend(false));
   EXPECT_TRUE(vie_.GetRembStatus(channel_num));
   EXPECT_FALSE(vie_.GetRembStatusSend(channel_num));
 }
@@ -829,6 +893,10 @@
   Base::AddRemoveRecvStreams();
 }
 
+TEST_F(WebRtcVideoMediaChannelTest, AddRemoveRecvStreamsNoConference) {
+  Base::AddRemoveRecvStreamsNoConference();
+}
+
 TEST_F(WebRtcVideoMediaChannelTest, AddRemoveSendStreams) {
   Base::AddRemoveSendStreams();
 }
@@ -880,4 +948,4 @@
 // TODO: Understand why we receive a not-quite-black frame.
 TEST_F(WebRtcVideoMediaChannelTest, DISABLED_Mute) {
   Base::Mute();
-}
\ No newline at end of file
+}
diff --git a/talk/session/phone/webrtcvoiceengine.cc b/talk/session/phone/webrtcvoiceengine.cc
index 7f4326b..98a1b85 100644
--- a/talk/session/phone/webrtcvoiceengine.cc
+++ b/talk/session/phone/webrtcvoiceengine.cc
@@ -856,7 +856,7 @@
     "GetRTPStatistics() failed to measure RTT since no RTP packets have been received yet",  // NOLINT
     "GetRTPStatistics() failed to read RTP statistics from the RTP/RTCP module",
     "GetRTPStatistics() failed to retrieve RTT from the RTP/RTCP module",
-    "SenderInfoReceived No received SR",
+    "webrtc::RTCPReceiver::SenderInfoReceived No received SR",
     "StatisticsRTP() no statisitics availble",
     NULL
   };
@@ -1639,6 +1639,13 @@
 bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
   talk_base::CritScope lock(&mux_channels_cs_);
 
+  // Reuse default channel for recv stream in 1:1 call.
+  if ((channel_options_ & OPT_CONFERENCE) == 0) {
+    LOG(LS_INFO) << "Recv stream " << sp.first_ssrc()
+                 << " reuse default channel";
+    return true;
+  }
+
   if (!VERIFY(sp.ssrcs.size() == 1))
     return false;
   uint32 ssrc = sp.first_ssrc();
diff --git a/talk/session/phone/webrtcvoiceengine_unittest.cc b/talk/session/phone/webrtcvoiceengine_unittest.cc
index 4da2812..f971106 100644
--- a/talk/session/phone/webrtcvoiceengine_unittest.cc
+++ b/talk/session/phone/webrtcvoiceengine_unittest.cc
@@ -253,6 +253,7 @@
 // Test that changes to recv codecs are applied to all streams.
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) {
   EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   std::vector<cricket::AudioCodec> codecs;
   codecs.push_back(kIsacCodec);
   codecs.push_back(kPcmuCodec);
@@ -279,6 +280,7 @@
 
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) {
   EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   std::vector<cricket::AudioCodec> codecs;
   codecs.push_back(kIsacCodec);
   codecs[0].id = 106;  // collide with existing telephone-event
@@ -643,6 +645,7 @@
   int channel_num1 = voe_.GetLastChannel();
 
   // Start playout on the default channel.
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   EXPECT_TRUE(channel_->SetPlayout(true));
   EXPECT_TRUE(voe_.GetPlayout(channel_num1));
 
@@ -872,6 +875,7 @@
 // SSRC is set in SetupEngine by calling AddSendStream.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) {
   EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   int channel_num1 = voe_.GetLastChannel();
   unsigned int send_ssrc;
   EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num1, send_ssrc));
@@ -888,6 +892,7 @@
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
   EXPECT_TRUE(engine_.Init());
   channel_ = engine_.CreateChannel();
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
 
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   int receive_channel_num = voe_.GetLastChannel();
@@ -915,6 +920,7 @@
 // Test that we can properly receive packets on multiple streams.
 TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
   EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   int channel_num1 = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
@@ -958,13 +964,27 @@
 TEST_F(WebRtcVoiceEngineTestFake, AddStreamFail) {
   EXPECT_TRUE(SetupEngine());
   voe_.set_fail_create_channel(true);
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
+
+  // In 1:1 call, we should not try to create a new channel.
+  EXPECT_TRUE(channel_->SetOptions(0));
+  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
+}
+
+// Test that AddRecvStream doesn't create new channel for 1:1 call.
+TEST_F(WebRtcVoiceEngineTestFake, AddRecvStream1On1) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
+  EXPECT_EQ(channel_num, voe_.GetLastChannel());
 }
 
 // Test that we properly clean up any streams that were added, even if
 // not explicitly removed.
 TEST_F(WebRtcVoiceEngineTestFake, StreamCleanup) {
   EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   EXPECT_EQ(3, voe_.GetNumChannels());  // default channel + 2 added
@@ -1012,6 +1032,7 @@
 // Test that we can play a ringback tone properly in a multi-stream call.
 TEST_F(WebRtcVoiceEngineTestFake, PlayRingbackWithMultipleStreams) {
   EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   int channel_num = voe_.GetLastChannel();
@@ -1070,6 +1091,7 @@
   unsigned int ssrc = 0;
 
   EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
 
   media_channel = reinterpret_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
@@ -1109,6 +1131,7 @@
 
 TEST_F(WebRtcVoiceEngineTestFake, TestSetPlayoutError) {
   EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   std::vector<cricket::AudioCodec> codecs;
   codecs.push_back(kPcmuCodec);
   EXPECT_TRUE(channel_->SetSendCodecs(codecs));
@@ -1125,6 +1148,7 @@
 // webrtcvoiceengine works as expected
 TEST_F(WebRtcVoiceEngineTestFake, RegisterVoiceProcessor) {
   EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   uint32 ssrc = 0;