diff --git a/CHANGELOG b/CHANGELOG
index 81b3f09..96ab6f4 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -2,6 +2,7 @@
 
 0.5.9 - Aug 31, 2011
   - Add app/webrtc
+  - Add webrtcvoiceengine/webrtcvideoengine
   - Update STUN support some more (RFC 5389)
   - Add video output scaling
   - Refactoring and bug fixes
diff --git a/README b/README
index ccf22ea..f40d4ea 100644
--- a/README
+++ b/README
@@ -56,6 +56,13 @@
     set PATH_TO_SWTOOLKIT=c:\src\swtoolkit
     set PATH=%PATH_TO_SWTOOLKIT%;%PATH%
 
+  * Finally, download and install the unit test framework from
+    http://code.google.com/p/googletest/downloads/list
+    To install it, just unzip the package and put the file folder under
+    /talk/third_party/ directory and rename it from "gtest-x.x.x" to "gtest",
+    so that your folder structure looks like:
+    /talk/third_party/gtest/...
+
 2.2 libjingle
 
 Libjingle needs to be downloaded and patched
diff --git a/talk/app/webrtc/webrtc.scons b/talk/app/webrtc/webrtc.scons
index 66f73af..2394e69 100644
--- a/talk/app/webrtc/webrtc.scons
+++ b/talk/app/webrtc/webrtc.scons
@@ -21,6 +21,8 @@
   env,
   name = 'webrtc',
   srcs = [
+    'peerconnection_unittest.cc',
+    'unittest_utilities.cc',
     'webrtcsession_unittest.cc',
   ],
   libs = [
diff --git a/talk/app/webrtc/webrtcsession_unittest.cc b/talk/app/webrtc/webrtcsession_unittest.cc
index 72610b9..648a5d6 100644
--- a/talk/app/webrtc/webrtcsession_unittest.cc
+++ b/talk/app/webrtc/webrtcsession_unittest.cc
@@ -31,6 +31,7 @@
 
 #include "base/gunit.h"
 #include "base/helpers.h"
+#include "talk/app/webrtc/unittest_utilities.h"
 #include "talk/app/webrtc/webrtcsession.h"
 #include "talk/base/fakenetwork.h"
 #include "talk/base/scoped_ptr.h"
@@ -41,131 +42,6 @@
 #include "talk/session/phone/fakesession.h"
 #include "talk/session/phone/mediasessionclient.h"
 
-namespace {
-cricket::VideoContentDescription* CopyVideoContentDescription(
-    const cricket::VideoContentDescription* video_description) {
-  cricket::VideoContentDescription* new_video_description =
-      new cricket::VideoContentDescription();
-  cricket::VideoCodecs::const_iterator iter =
-      video_description->codecs().begin();
-  for (; iter != video_description->codecs().end(); iter++) {
-    new_video_description->AddCodec(*iter);
-  }
-  new_video_description->SortCodecs();
-  return new_video_description;
-}
-
-cricket::AudioContentDescription* CopyAudioContentDescription(
-    const cricket::AudioContentDescription* audio_description) {
-  cricket::AudioContentDescription* new_audio_description =
-      new cricket::AudioContentDescription();
-  cricket::AudioCodecs::const_iterator iter =
-      audio_description->codecs().begin();
-  for (; iter != audio_description->codecs().end(); iter++) {
-    new_audio_description->AddCodec(*iter);
-  }
-  new_audio_description->SortCodecs();
-  return new_audio_description;
-}
-
-const cricket::ContentDescription* CopyContentDescription(
-    const cricket::ContentDescription* original) {
-  const cricket::MediaContentDescription* media =
-      static_cast<const cricket::MediaContentDescription*>(original);
-  const cricket::ContentDescription* new_content_description = NULL;
-  if (media->type() == cricket::MEDIA_TYPE_VIDEO) {
-    const cricket::VideoContentDescription* video_description =
-        static_cast<const cricket::VideoContentDescription*>(original);
-    new_content_description = static_cast<const cricket::ContentDescription*>
-        (CopyVideoContentDescription(video_description));
-  } else if (media->type() == cricket::MEDIA_TYPE_AUDIO) {
-    const cricket::AudioContentDescription* audio_description =
-        static_cast<const cricket::AudioContentDescription*>(original);
-    new_content_description = static_cast<const cricket::ContentDescription*>
-        (CopyAudioContentDescription(audio_description));
-  } else {
-    return NULL;
-  }
-  return new_content_description;
-}
-
-cricket::ContentInfos CopyContentInfos(const cricket::ContentInfos& original) {
-  cricket::ContentInfos new_content_infos;
-  for (cricket::ContentInfos::const_iterator iter = original.begin();
-       iter != original.end(); iter++) {
-    cricket::ContentInfo info;
-    info.name = (*iter).name;
-    info.type = (*iter).type;
-    info.description = CopyContentDescription((*iter).description);
-    new_content_infos.push_back(info);
-  }
-  return new_content_infos;
-}
-
-cricket::SessionDescription* CopySessionDescription(
-    const cricket::SessionDescription* original) {
-  const cricket::ContentInfos& content_infos = original->contents();
-  cricket::ContentInfos new_content_infos = CopyContentInfos(content_infos);
-  return new cricket::SessionDescription(new_content_infos);
-}
-
-cricket::SessionDescription* GenerateFakeSessionDescription(bool video) {
-  cricket::SessionDescription* fake_description =
-      new cricket::SessionDescription();
-  const std::string name = video ? std::string(cricket::CN_VIDEO) :
-                                   std::string(cricket::CN_AUDIO);
-  cricket::ContentDescription* description = NULL;
-  if (video) {
-    cricket::VideoContentDescription* video_dsc =
-        new cricket::VideoContentDescription;
-    video_dsc->SortCodecs();
-    description = static_cast<cricket::ContentDescription*>(video_dsc);
-  } else {
-    cricket::AudioContentDescription* audio_dsc =
-        new cricket::AudioContentDescription();
-    audio_dsc->SortCodecs();
-    description = static_cast<cricket::ContentDescription*>(audio_dsc);
-  }
-
-  // Cannot fail.
-  fake_description->AddContent(name, cricket::NS_JINGLE_RTP, description);
-  return fake_description;
-}
-
-void GenerateFakeCandidate(std::vector<cricket::Candidate>* candidates,
-                           bool video) {
-  // Next add a candidate.
-  // int port_index = 0;
-  std::string port_index_as_string("0");
-
-  cricket::Candidate candidate;
-  candidate.set_name("rtp");
-  candidate.set_protocol("udp");
-  talk_base::SocketAddress address("127.0.0.1", 1234);
-  candidate.set_address(address);
-  candidate.set_preference(1);
-  candidate.set_username("username" + port_index_as_string);
-  candidate.set_password(port_index_as_string);
-  candidate.set_type("local");
-  candidate.set_network_name("network");
-  candidate.set_generation(0);
-
-  candidates->push_back(candidate);
-}
-
-cricket::SessionDescription* GenerateFakeSession(
-    std::vector<cricket::Candidate>* candidates,
-    bool video) {
-  cricket::SessionDescription* fake_description =
-      GenerateFakeSessionDescription(video);
-  if (fake_description == NULL) {
-    return NULL;
-  }
-  GenerateFakeCandidate(candidates, video);
-  return fake_description;
-}
-}  // namespace
-
 class WebRtcSessionTest
     : public sigslot::has_slots<>,
       public testing::Test {
@@ -219,9 +95,7 @@
       const std::vector<cricket::Candidate>& candidates) {
     callback_ids_.push_back(kOnLocalDescription);
     last_description_ptr_.reset(CopySessionDescription(desc));
-    last_candidates_.clear();
-    last_candidates_.insert(last_candidates_.end(), candidates.begin(),
-                            candidates.end());
+    CopyCandidates(candidates, &last_candidates_);
   }
   cricket::SessionDescription* GetLocalDescription(
       std::vector<cricket::Candidate>* candidates) {
@@ -231,8 +105,7 @@
     if (!last_description_ptr_.get()) {
       return NULL;
     }
-    candidates->insert(candidates->end(), last_candidates_.begin(),
-                       last_candidates_.end());
+    CopyCandidates(last_candidates_, candidates);
     return CopySessionDescription(last_description_ptr_.get());
   }
 
@@ -315,7 +188,6 @@
     session_->SignalLocalDescription.connect(this,
         &WebRtcSessionTest::OnLocalDescription);
     session_->SignalFailedCall.connect(this, &WebRtcSessionTest::OnFailedCall);
-
     return true;
   }
 
@@ -512,14 +384,14 @@
 
   std::vector<cricket::Candidate> candidates;
   cricket::SessionDescription* local_session =
-      GenerateFakeSession(&candidates, video);
+      GenerateFakeSession(video, &candidates);
   ASSERT_FALSE(candidates.empty());
   ASSERT_FALSE(local_session == NULL);
-  // TODO: Figure out why the TransportChannel is not created.
-  // if (!CallOnInitiateMessage(local_session, candidates)) {
-  //    delete local_session;
-  //    FAIL();
-  // }
+  ASSERT_TRUE(CallInitiate());
+  if (!CallOnInitiateMessage(local_session, candidates)) {
+    delete local_session;
+    FAIL();
+  }
   ASSERT_TRUE(CallConnect());
   ASSERT_FALSE(CallbackReceived(this, 1000));
 
@@ -535,14 +407,14 @@
 
   std::vector<cricket::Candidate> candidates;
   cricket::SessionDescription* local_session =
-      GenerateFakeSession(&candidates, video);
+      GenerateFakeSession(video, &candidates);
   ASSERT_FALSE(candidates.empty());
   ASSERT_FALSE(local_session == NULL);
-  // TODO: Figure out why the TransportChannel is not created.
-  // if (!CallOnInitiateMessage(local_session, candidates)) {
-  //     delete local_session;
-  //     FAIL();
-  // }
+  ASSERT_TRUE(CallInitiate());
+  if (!CallOnInitiateMessage(local_session, candidates)) {
+    delete local_session;
+    FAIL();
+  }
   ASSERT_TRUE(CallConnect());
   ASSERT_FALSE(CallbackReceived(this, 1000));
   ASSERT_TRUE(!CallHasAudioChannel() &&
diff --git a/talk/base/gunit.h b/talk/base/gunit.h
new file mode 100644
index 0000000..9d04595
--- /dev/null
+++ b/talk/base/gunit.h
@@ -0,0 +1,129 @@
+/*
+ * libjingle
+ * Copyright 2004--2008, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_BASE_GUNIT_H_
+#define TALK_BASE_GUNIT_H_
+
+#include "talk/base/logging.h"
+#include "talk/base/thread.h"
+#ifdef ANDROID
+#include <gtest/gtest.h>
+#elif LIBJINGLE_UNITTEST
+#include "third_party/gtest/include/gtest/gtest.h"
+#else
+#include "testing/base/public/gunit.h"
+#endif
+
+// forward declarations
+namespace talk_base {
+class Pathname;
+}
+
+// Wait until "ex" is true, or "timeout" expires.
+#define WAIT(ex, timeout) \
+  for (uint32 start = talk_base::Time(); \
+      !(ex) && talk_base::Time() < start + timeout;) \
+    talk_base::Thread::Current()->ProcessMessages(1);
+
+// This returns the result of the test in res, so that we don't re-evaluate
+// the expression in the XXXX_WAIT macros below, since that causes problems
+// when the expression is only true the first time you check it.
+#define WAIT_(ex, timeout, res) \
+  do { \
+    uint32 start = talk_base::Time(); \
+    res = (ex); \
+    while (!res && talk_base::Time() < start + timeout) { \
+      talk_base::Thread::Current()->ProcessMessages(1); \
+      res = (ex); \
+    } \
+  } while (0);
+
+// The typical EXPECT_XXXX and ASSERT_XXXXs, but done until true or a timeout.
+#define EXPECT_TRUE_WAIT(ex, timeout) \
+  do { \
+    bool res; \
+    WAIT_(ex, timeout, res); \
+    if (!res) EXPECT_TRUE(ex); \
+  } while (0);
+
+#define EXPECT_EQ_WAIT(v1, v2, timeout) \
+  do { \
+    bool res; \
+    WAIT_(v1 == v2, timeout, res); \
+    if (!res) EXPECT_EQ(v1, v2); \
+  } while (0);
+
+#define ASSERT_TRUE_WAIT(ex, timeout) \
+  do { \
+    bool res; \
+    WAIT_(ex, timeout, res); \
+    if (!res) ASSERT_TRUE(ex); \
+  } while (0);
+
+#define ASSERT_EQ_WAIT(v1, v2, timeout) \
+  do { \
+    bool res; \
+    WAIT_(v1 == v2, timeout, res); \
+    if (!res) ASSERT_EQ(v1, v2); \
+  } while (0);
+
+// Version with a "soft" timeout and a margin. This logs if the timeout is
+// exceeded, but it only fails if the expression still isn't true after the
+// margin time passes.
+#define EXPECT_TRUE_WAIT_MARGIN(ex, timeout, margin) \
+  do { \
+    bool res; \
+    WAIT_(ex, timeout, res); \
+    if (res) { \
+      break; \
+    } \
+    LOG(LS_WARNING) << "Expression " << #ex << " still not true after " << \
+        timeout << "ms; waiting an additional " << margin << "ms"; \
+    WAIT_(ex, margin, res); \
+    if (!res) { \
+      EXPECT_TRUE(ex); \
+    } \
+  } while (0);
+
+#ifdef __LP64__
+// When compiling in 64-bit mode we redefine the TEST and TEST_F macros to
+// append _64bit to all testsuite names to distinguish the test results from
+// those for the 32-bit cross-built binaries.
+#undef TEST
+#undef TEST_F
+// Copied and adjusted from google3/third_party/gtest/include/gtest/gtest.h
+#define TEST(test_case_name, test_name)\
+  GTEST_TEST_(test_case_name##_64bit, test_name, \
+              ::testing::Test, ::testing::internal::GetTestTypeId())
+#define TEST_F(test_fixture, test_name)\
+  GTEST_TEST_(test_fixture##_64bit, test_name, test_fixture, \
+              ::testing::internal::GetTypeId<test_fixture>())
+#endif
+
+talk_base::Pathname GetTalkDirectory();
+
+#endif  // TALK_BASE_GUNIT_H_
diff --git a/talk/base/network_unittest.cc b/talk/base/network_unittest.cc
new file mode 100644
index 0000000..6a9919d
--- /dev/null
+++ b/talk/base/network_unittest.cc
@@ -0,0 +1,144 @@
+// Copyright 2009 Google Inc.
+// All Rights Reserved.
+//
+
+
+#include <vector>
+#include "talk/base/gunit.h"
+#include "talk/base/network.h"
+
+namespace talk_base {
+
+// A network that should not be ignored.
+static const Network kNetwork1("test1", "Test Network Adapter 1",
+                               0x12345678, 0x12345601);
+// A network that should be ignored (IP is 0.1.0.4).
+static const Network kNetwork2("test2", "Test Network Adapter 2",
+                               0x00010004, 0x01000000);
+// A network that should not be ignored (IP is valid, but gateway is 0.0.0.1).
+// Previously, we attempted to ignore networks with no default gateway,
+// but if an explicit route is set, no default gateway is needed.
+static const Network kNetwork3("test3", "Test Network Adapter 3",
+                               0x55667788, 0x01000000);
+
+class NetworkTest : public testing::Test, public sigslot::has_slots<>  {
+ public:
+  NetworkTest()
+      : callback_called_(false) {
+  }
+
+  void OnNetworksChanged() {
+    callback_called_ = true;
+  }
+
+  void MergeNetworkList(BasicNetworkManager& network_manager,
+                        const NetworkManager::NetworkList& list,
+                        bool force_notification) {
+    network_manager.MergeNetworkList(list, force_notification);
+  }
+
+  bool IsIgnoredNetwork(const Network& network) {
+    return BasicNetworkManager::IsIgnoredNetwork(network);
+  }
+
+ protected:
+  bool callback_called_;
+};
+
+// Test that the Network ctor works properly.
+TEST_F(NetworkTest, TestNetworkConstruct) {
+  EXPECT_EQ("test1", kNetwork1.name());
+  EXPECT_EQ("Test Network Adapter 1", kNetwork1.description());
+  EXPECT_EQ(0x12345678U, kNetwork1.ip());
+  EXPECT_EQ(0x12345601U, kNetwork1.gateway_ip());
+  EXPECT_FALSE(kNetwork1.ignored());
+}
+
+// Tests that our ignore function works properly.
+TEST_F(NetworkTest, TestNetworkIgnore) {
+  EXPECT_FALSE(IsIgnoredNetwork(kNetwork1));
+  EXPECT_TRUE(IsIgnoredNetwork(kNetwork2));
+  EXPECT_FALSE(IsIgnoredNetwork(kNetwork3));
+}
+
+// Test that UpdateNetworks succeeds.
+TEST_F(NetworkTest, TestUpdateNetworks) {
+  BasicNetworkManager manager;
+  manager.SignalNetworksChanged.connect(
+      static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
+  manager.StartUpdating();
+  Thread::Current()->ProcessMessages(0);
+  EXPECT_TRUE(callback_called_);
+}
+
+// Verify that MergeNetworkList() merges network lists properly.
+TEST_F(NetworkTest, TestMergeNetworkList) {
+  BasicNetworkManager manager;
+  manager.SignalNetworksChanged.connect(
+      static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
+
+  // Add kNetwork1 to the list of networks.
+  NetworkManager::NetworkList list;
+  list.push_back(new Network(kNetwork1));
+  callback_called_ = false;
+  MergeNetworkList(manager, list, false);
+  EXPECT_TRUE(callback_called_);
+  list.clear();
+
+  manager.GetNetworks(&list);
+  EXPECT_EQ(1U, list.size());
+  EXPECT_EQ(kNetwork1.ToString(), list[0]->ToString());
+  Network* net1 = list[0];
+  list.clear();
+
+  // Replace kNetwork1 with kNetwork2.
+  list.push_back(new Network(kNetwork2));
+  callback_called_ = false;
+  MergeNetworkList(manager, list, false);
+  EXPECT_TRUE(callback_called_);
+  list.clear();
+
+  manager.GetNetworks(&list);
+  EXPECT_EQ(1U, list.size());
+  EXPECT_EQ(kNetwork2.ToString(), list[0]->ToString());
+  Network* net2 = list[0];
+  list.clear();
+
+  // Add Network2 back.
+  list.push_back(new Network(kNetwork1));
+  list.push_back(new Network(kNetwork2));
+  callback_called_ = false;
+  MergeNetworkList(manager, list, false);
+  EXPECT_TRUE(callback_called_);
+  list.clear();
+
+  // Verify that we get previous instances of Network objects.
+  manager.GetNetworks(&list);
+  EXPECT_EQ(2U, list.size());
+  EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
+              (net1 == list[1] && net2 == list[0]));
+  list.clear();
+
+  // Call MergeNetworkList() again and verify that we don't get update
+  // notification.
+  list.push_back(new Network(kNetwork2));
+  list.push_back(new Network(kNetwork1));
+  callback_called_ = false;
+  MergeNetworkList(manager, list, false);
+  EXPECT_FALSE(callback_called_);
+  list.clear();
+
+  // Verify that we get previous instances of Network objects.
+  manager.GetNetworks(&list);
+  EXPECT_EQ(2U, list.size());
+  EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
+              (net1 == list[1] && net2 == list[0]));
+  list.clear();
+}
+
+// Test that DumpNetworks works.
+TEST_F(NetworkTest, TestDumpNetworks) {
+  BasicNetworkManager::DumpNetworks(true);
+}
+
+}  // namespace talk_base
diff --git a/talk/base/unittest_main.cc b/talk/base/unittest_main.cc
new file mode 100644
index 0000000..56fbc54
--- /dev/null
+++ b/talk/base/unittest_main.cc
@@ -0,0 +1,119 @@
+// Copyright 2007 Google Inc. All Rights Reserved.
+
+//         juberti@google.com (Justin Uberti)
+//
+// A reuseable entry point for gunit tests.
+
+#ifdef WIN32
+#include <crtdbg.h>
+#endif
+
+#include "talk/base/flags.h"
+#include "talk/base/fileutils.h"
+#include "talk/base/gunit.h"
+#include "talk/base/logging.h"
+#include "talk/base/pathutils.h"
+
+DEFINE_bool(help, false, "prints this message");
+DEFINE_string(log, "", "logging options to use");
+#ifdef WIN32
+DEFINE_int(crt_break_alloc, -1, "memory allocation to break on");
+DEFINE_bool(default_error_handlers, false,
+            "leave the default exception/dbg handler functions in place");
+
+void TestInvalidParameterHandler(const wchar_t* expression,
+                                 const wchar_t* function,
+                                 const wchar_t* file,
+                                 unsigned int line,
+                                 uintptr_t pReserved) {
+  LOG(LS_ERROR) << "InvalidParameter Handler called.  Exiting.";
+  LOG(LS_ERROR) << expression << std::endl << function << std::endl << file
+                << std::endl << line;
+  exit(1);
+}
+void TestPureCallHandler() {
+  LOG(LS_ERROR) << "Purecall Handler called.  Exiting.";
+  exit(1);
+}
+int TestCrtReportHandler(int report_type, char* msg, int* retval) {
+    LOG(LS_ERROR) << "CrtReport Handler called...";
+    LOG(LS_ERROR) << msg;
+  if (report_type == _CRT_ASSERT) {
+    exit(1);
+  } else {
+    *retval = 0;
+    return TRUE;
+  }
+}
+#endif  // WIN32
+
+talk_base::Pathname GetTalkDirectory() {
+  // Locate talk directory.
+  talk_base::Pathname path = talk_base::Filesystem::GetCurrentDirectory();
+  std::string talk_folder_name("talk");
+  talk_folder_name += path.folder_delimiter();
+  while (path.folder_name() != talk_folder_name && !path.empty()) {
+    path.SetFolder(path.parent_folder());
+  }
+
+  // If not running inside "talk" folder, then assume running in its parent
+  // folder.
+  if (path.empty()) {
+    path = talk_base::Filesystem::GetCurrentDirectory();
+    path.AppendFolder("talk");
+    // Make sure the folder exist.
+    if (!talk_base::Filesystem::IsFolder(path)) {
+      path.clear();
+    }
+  }
+  return path;
+}
+
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  FlagList::SetFlagsFromCommandLine(&argc, argv, false);
+  if (FLAG_help) {
+    FlagList::Print(NULL, false);
+    return 0;
+  }
+
+#ifdef WIN32
+  if (!FLAG_default_error_handlers) {
+    // Make sure any errors don't throw dialogs hanging the test run.
+    _set_invalid_parameter_handler(TestInvalidParameterHandler);
+    _set_purecall_handler(TestPureCallHandler);
+    _CrtSetReportHook2(_CRT_RPTHOOK_INSTALL, TestCrtReportHandler);
+  }
+
+#ifdef _DEBUG  // Turn on memory leak checking on Windows.
+  _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF |_CRTDBG_LEAK_CHECK_DF);
+  if (FLAG_crt_break_alloc >= 0) {
+    _crtBreakAlloc = FLAG_crt_break_alloc;
+  }
+#endif  // _DEBUG
+#endif  // WIN32
+
+  talk_base::Filesystem::SetOrganizationName("google");
+  talk_base::Filesystem::SetApplicationName("unittest");
+
+  // By default, log timestamps. Allow overrides by used of a --log flag.
+  talk_base::LogMessage::LogTimestamps();
+  if (*FLAG_log != '\0') {
+    talk_base::LogMessage::ConfigureLogging(FLAG_log, "unittest.log");
+  }
+
+  int res = RUN_ALL_TESTS();
+
+  // clean up logging so we don't appear to leak memory.
+  talk_base::LogMessage::ConfigureLogging("", "");
+
+#ifdef WIN32
+  // Unhook crt function so that we don't ever log after statics have been
+  // uninitialized.
+  if (!FLAG_default_error_handlers)
+    _CrtSetReportHook2(_CRT_RPTHOOK_REMOVE, TestCrtReportHandler);
+#endif
+
+  return res;
+}
diff --git a/talk/examples/call/callclient.cc b/talk/examples/call/callclient.cc
index 8b9a834..fca401e 100644
--- a/talk/examples/call/callclient.cc
+++ b/talk/examples/call/callclient.cc
@@ -54,6 +54,7 @@
 #include "talk/session/phone/mediasessionclient.h"
 #include "talk/session/phone/videorendererfactory.h"
 #include "talk/xmpp/constants.h"
+#include "talk/xmpp/mucroomconfigtask.h"
 #include "talk/xmpp/mucroomlookuptask.h"
 
 namespace {
@@ -696,7 +697,8 @@
   }
 
   buzz::MucRoomLookupTask* lookup_query_task =
-      new buzz::MucRoomLookupTask(xmpp_client_, room, domain);
+      new buzz::MucRoomLookupTask(
+          xmpp_client_, buzz::JID_GOOGLE_MUC_LOOKUP, room, domain);
   lookup_query_task->SignalResult.connect(this,
       &CallClient::OnRoomLookupResponse);
   lookup_query_task->SignalError.connect(this,
@@ -739,11 +741,35 @@
   presence_out_->SendDirected(muc->local_jid(), my_status_);
 }
 
-void CallClient::OnRoomLookupResponse(const buzz::MucRoomInfo& room_info) {
-  JoinMuc(room_info.room_jid);
+void CallClient::OnRoomLookupResponse(buzz::MucRoomLookupTask* task,
+                                      const buzz::MucRoomInfo& room) {
+  // The server requires the room be "configured" before being used.
+  // We only need to configure it if we create it, but rooms are
+  // auto-created at lookup, so there's currently no way to know if we
+  // created it.  So, we configure it every time, just in case.
+  // Luckily, it appears to be safe to configure a room that's already
+  // configured.  Our current flow is:
+  // 1. Lookup/auto-create
+  // 2. Configure
+  // 3. Join
+  // TODO: In the future, once the server supports it, we
+  // should:
+  // 1. Lookup
+  // 2. Create and Configure if necessary
+  // 3. Join
+  std::vector<std::string> room_features;
+  room_features.push_back(buzz::STR_MUC_ROOM_FEATURE_ENTERPRISE);
+  buzz::MucRoomConfigTask* room_config_task = new buzz::MucRoomConfigTask(
+      xmpp_client_, room.jid, room.full_name(), room_features);
+  room_config_task->SignalResult.connect(this,
+      &CallClient::OnRoomConfigResult);
+  room_config_task->SignalError.connect(this,
+      &CallClient::OnRoomConfigError);
+  room_config_task->Start();
 }
 
-void CallClient::OnRoomLookupError(const buzz::XmlElement* stanza) {
+void CallClient::OnRoomLookupError(buzz::IqTask* task,
+                                   const buzz::XmlElement* stanza) {
   if (stanza == NULL) {
     console_->PrintLine("Room lookup failed.");
   } else {
@@ -751,6 +777,19 @@
   }
 }
 
+void CallClient::OnRoomConfigResult(buzz::MucRoomConfigTask* task) {
+  JoinMuc(task->room_jid());
+}
+
+void CallClient::OnRoomConfigError(buzz::IqTask* task,
+                                   const buzz::XmlElement* stanza) {
+  if (stanza == NULL) {
+    console_->PrintLine("Room config failed.");
+  } else {
+    console_->PrintLine("Room config error: ", stanza->Str().c_str());
+  }
+}
+
 void CallClient::OnMucInviteReceived(const buzz::Jid& inviter,
     const buzz::Jid& room,
     const std::vector<buzz::AvailableMediaEntry>& avail) {
diff --git a/talk/examples/call/callclient.h b/talk/examples/call/callclient.h
index fb7878e..18296be 100644
--- a/talk/examples/call/callclient.h
+++ b/talk/examples/call/callclient.h
@@ -50,6 +50,8 @@
 class DiscoInfoQueryTask;
 class Muc;
 class Status;
+class IqTask;
+class MucRoomConfigTask;
 class MucRoomLookupTask;
 class MucStatus;
 class XmlElement;
@@ -174,8 +176,13 @@
   void OnSpeakerChanged(cricket::Call* call,
                         cricket::Session* session,
                         const cricket::NamedSource& speaker_source);
-  void OnRoomLookupResponse(const buzz::MucRoomInfo& room_info);
-  void OnRoomLookupError(const buzz::XmlElement* stanza);
+  void OnRoomLookupResponse(buzz::MucRoomLookupTask* task,
+                            const buzz::MucRoomInfo& room_info);
+  void OnRoomLookupError(buzz::IqTask* task,
+                         const buzz::XmlElement* stanza);
+  void OnRoomConfigResult(buzz::MucRoomConfigTask* task);
+  void OnRoomConfigError(buzz::IqTask* task,
+                         const buzz::XmlElement* stanza);
   buzz::Jid GenerateRandomMucJid();
 
   void AddStaticRenderedView(
diff --git a/talk/libjingle.scons b/talk/libjingle.scons
index 03239d4..e053a8f 100644
--- a/talk/libjingle.scons
+++ b/talk/libjingle.scons
@@ -20,6 +20,18 @@
                "HAVE_EXPAT_CONFIG_H",
              ],
 )
+talk.Library(env, name = "gunit",
+             srcs = [
+               "third_party/gtest/src/gtest-all.cc",
+             ],
+             includedirs = [
+               "third_party/gtest/include",
+               "third_party/gtest",
+             ],
+             cppdefines = [
+               "LIBJINGLE_UNITTEST",
+             ],
+)
 talk.Library(env, name = "srtp",
              srcs = [
                "third_party/srtp/crypto/cipher/aes.c",
@@ -63,6 +75,8 @@
                "sound/alsasoundsystem.cc",
                "sound/alsasymboltable.cc",
                "sound/linuxsoundsystem.cc",
+               "sound/nullsoundsystem.cc",
+               "sound/nullsoundsystemfactory.cc",
                "sound/pulseaudiosoundsystem.cc",
                "sound/pulseaudiosymboltable.cc",
                "sound/platformsoundsystem.cc",
@@ -212,6 +226,7 @@
                "xmpp/constants.cc",
                "xmpp/iqtask.cc",
                "xmpp/jid.cc",
+               "xmpp/mucroomconfigtask.cc",
                "xmpp/mucroomlookuptask.cc",
                "xmpp/ratelimitmanager.cc",
                "xmpp/saslmechanism.cc",
@@ -262,6 +277,21 @@
                "gtk+-2.0",
              ],
 )
+talk.Library(env, name = "unittest_main",
+             libs = [
+               "gunit",
+             ],
+             srcs = [
+               "base/unittest_main.cc",
+             ],
+             includedirs = [
+               "third_party/gtest/include",
+               "third_party/gtest",
+             ],
+             cppdefines = [
+               "LIBJINGLE_UNITTEST",
+             ],
+)
 talk.App(env, name = "login",
          libs = [
            "jingle",
@@ -343,3 +373,18 @@
            "p2p/base/stunserver_main.cc",
          ],
 )
+talk.Unittest(env, name = "network",
+              libs = [
+                "jingle",
+              ],
+              srcs = [
+                "base/network_unittest.cc",
+              ],
+              includedirs = [
+                "third_party/gtest/include",
+                "third_party/gtest",
+              ],
+              cppdefines = [
+                "LIBJINGLE_UNITTEST",
+              ],
+)
diff --git a/talk/session/phone/channelmanager.cc b/talk/session/phone/channelmanager.cc
index 0d11b53..97419cb 100644
--- a/talk/session/phone/channelmanager.cc
+++ b/talk/session/phone/channelmanager.cc
@@ -654,6 +654,8 @@
 
 void ChannelManager::OnVideoCaptureResult(VideoCapturer* capturer,
                                           CaptureResult result) {
+  // TODO: Check capturer and signal failure only for camera video, not
+  // screencast.
   capturing_ = result == CR_SUCCESS;
   main_thread_->Post(this, MSG_CAMERASTARTED,
                      new talk_base::TypedMessageData<CaptureResult>(result));
diff --git a/talk/session/phone/mediacommon.h b/talk/session/phone/mediacommon.h
new file mode 100644
index 0000000..7a606e3
--- /dev/null
+++ b/talk/session/phone/mediacommon.h
@@ -0,0 +1,42 @@
+/*
+ * libjingle
+ * Copyright 2004--2007, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_SESSION_PHONE_MEDIACOMMON_H_
+#define TALK_SESSION_PHONE_MEDIACOMMON_H_
+
+namespace cricket {
+
+enum MediaCapabilities {
+  AUDIO_RECV = 1 << 0,
+  AUDIO_SEND = 1 << 1,
+  VIDEO_RECV = 1 << 2,
+  VIDEO_SEND = 1 << 3,
+};
+
+}  // namespace cricket
+
+#endif  // TALK_SESSION_PHONE_MEDIACOMMON_H_
diff --git a/talk/session/phone/webrtccommon.h b/talk/session/phone/webrtccommon.h
new file mode 100644
index 0000000..60fee27
--- /dev/null
+++ b/talk/session/phone/webrtccommon.h
@@ -0,0 +1,84 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef TALK_SESSION_PHONE_WEBRTCCOMMON_H_
+#define TALK_SESSION_PHONE_WEBRTCCOMMON_H_
+
+#ifdef WEBRTC_RELATIVE_PATH
+#include "common_types.h"
+#include "video_engine/main/interface/vie_base.h"
+#include "voice_engine/main/interface/voe_base.h"
+#else
+#include "third_party/webrtc/files/include/common_types.h"
+#include "third_party/webrtc/files/include/voe_base.h"
+#include "third_party/webrtc/files/include/vie_base.h"
+#endif  // WEBRTC_RELATIVE_PATH
+
+namespace cricket {
+
+// Tracing helpers, for easy logging when WebRTC calls fail.
+// Example: "LOG_RTCERR1(StartSend, channel);" produces the trace
+//          "StartSend(1) failed, err=XXXX"
+// The method GetLastEngineError must be defined in the calling scope.
+#define LOG_RTCERR0(func) \
+    LOG_RTCERR0_EX(func, GetLastEngineError())
+#define LOG_RTCERR1(func, a1) \
+    LOG_RTCERR1_EX(func, a1, GetLastEngineError())
+#define LOG_RTCERR2(func, a1, a2) \
+    LOG_RTCERR2_EX(func, a1, a2, GetLastEngineError())
+#define LOG_RTCERR3(func, a1, a2, a3) \
+    LOG_RTCERR3_EX(func, a1, a2, a3, GetLastEngineError())
+#define LOG_RTCERR4(func, a1, a2, a3, a4) \
+    LOG_RTCERR4_EX(func, a1, a2, a3, a4, GetLastEngineError())
+#define LOG_RTCERR5(func, a1, a2, a3, a4, a5) \
+    LOG_RTCERR5_EX(func, a1, a2, a3, a4, a5, GetLastEngineError())
+#define LOG_RTCERR6(func, a1, a2, a3, a4, a5, a6) \
+    LOG_RTCERR6_EX(func, a1, a2, a3, a4, a5, a6, GetLastEngineError())
+#define LOG_RTCERR0_EX(func, err) LOG(LS_WARNING) \
+    << "" << #func << "() failed, err=" << err
+#define LOG_RTCERR1_EX(func, a1, err) LOG(LS_WARNING) \
+    << "" << #func << "(" << a1 << ") failed, err=" << err
+#define LOG_RTCERR2_EX(func, a1, a2, err) LOG(LS_WARNING) \
+    << "" << #func << "(" << a1 << ", " << a2 << ") failed, err=" \
+    << err
+#define LOG_RTCERR3_EX(func, a1, a2, a3, err) LOG(LS_WARNING) \
+    << "" << #func << "(" << a1 << ", " << a2 << ", " << a3 \
+    << ") failed, err=" << err
+#define LOG_RTCERR4_EX(func, a1, a2, a3, a4, err) LOG(LS_WARNING) \
+    << "" << #func << "(" << a1 << ", " << a2 << ", " << a3 \
+    << ", " << a4 << ") failed, err=" << err
+#define LOG_RTCERR5_EX(func, a1, a2, a3, a4, a5, err) LOG(LS_WARNING) \
+    << "" << #func << "(" << a1 << ", " << a2 << ", " << a3 \
+    << ", " << a4 << ", " << a5 << ") failed, err=" << err
+#define LOG_RTCERR6_EX(func, a1, a2, a3, a4, a5, a6, err) LOG(LS_WARNING) \
+    << "" << #func << "(" << a1 << ", " << a2 << ", " << a3 \
+    << ", " << a4 << ", " << a5 << ", " << a6 << ") failed, err=" << err
+
+}  // namespace cricket
+
+#endif  // TALK_SESSION_PHONE_WEBRTCCOMMON_H_
diff --git a/talk/session/phone/webrtcpassthroughrender.cc b/talk/session/phone/webrtcpassthroughrender.cc
new file mode 100644
index 0000000..cecaa42
--- /dev/null
+++ b/talk/session/phone/webrtcpassthroughrender.cc
@@ -0,0 +1,135 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "talk/session/phone/webrtcpassthroughrender.h"
+
+#include "talk/base/common.h"
+#include "talk/base/logging.h"
+
+namespace cricket {
+
+class PassthroughStream: public webrtc::VideoRenderCallback {
+ public:
+  explicit PassthroughStream(const WebRtc_UWord32 stream_id)
+      : stream_id_(stream_id) {
+  }
+  virtual ~PassthroughStream() {
+  }
+  virtual WebRtc_Word32 RenderFrame(const WebRtc_UWord32 stream_id,
+                                    webrtc::VideoFrame& videoFrame) {
+    talk_base::CritScope cs(&stream_critical_);
+    // Send frame for rendering directly
+    if (renderer_) {
+      renderer_->RenderFrame(stream_id, videoFrame);
+    }
+    return 0;
+  }
+  WebRtc_Word32 SetRenderer(VideoRenderCallback* renderer) {
+    talk_base::CritScope cs(&stream_critical_);
+    renderer_ = renderer;
+    return 0;
+  }
+
+ private:
+  WebRtc_UWord32 stream_id_;
+  VideoRenderCallback* renderer_;
+  talk_base::CriticalSection stream_critical_;
+};
+
+WebRtcPassthroughRender::WebRtcPassthroughRender()
+    : window_(NULL) {
+}
+
+WebRtcPassthroughRender::~WebRtcPassthroughRender() {
+  while (!stream_render_map_.empty()) {
+    PassthroughStream* stream = stream_render_map_.begin()->second;
+    stream_render_map_.erase(stream_render_map_.begin());
+    delete stream;
+  }
+}
+
+webrtc::VideoRenderCallback* WebRtcPassthroughRender::AddIncomingRenderStream(
+    const WebRtc_UWord32 stream_id,
+    const WebRtc_UWord32 zOrder,
+    const float left, const float top,
+    const float right, const float bottom) {
+  talk_base::CritScope cs(&render_critical_);
+  StreamMap::iterator it;
+  it = stream_render_map_.find(stream_id);
+  if (it != stream_render_map_.end())
+    return NULL;
+
+  PassthroughStream* stream = new PassthroughStream(stream_id);
+  // Store the stream
+  stream_render_map_[stream_id] = stream;
+  return stream;
+}
+
+WebRtc_Word32 WebRtcPassthroughRender::DeleteIncomingRenderStream(
+    const WebRtc_UWord32 stream_id) {
+  talk_base::CritScope cs(&render_critical_);
+  StreamMap::iterator it;
+  it = stream_render_map_.find(stream_id);
+  if (it == stream_render_map_.end()) {
+    LOG(LS_WARNING) << "DeleteIncomingRenderStream failed to find stream_id: "
+                    << stream_id;
+    return -1;
+  }
+  PassthroughStream* stream = it->second;
+  delete stream;
+  stream_render_map_.erase(it);
+  return 0;
+}
+
+WebRtc_Word32 WebRtcPassthroughRender::AddExternalRenderCallback(
+    const WebRtc_UWord32 stream_id,
+    webrtc::VideoRenderCallback* render_object) {
+  talk_base::CritScope cs(&render_critical_);
+  StreamMap::iterator it;
+  it = stream_render_map_.find(stream_id);
+  if (it == stream_render_map_.end()) {
+    LOG(LS_WARNING) << "AddExternalRenderCallback failed to find stream_id: "
+                    << stream_id;
+    return -1;
+  }
+  PassthroughStream* stream = it->second;
+  ASSERT(stream != NULL);
+  return stream->SetRenderer(render_object);
+}
+
+bool WebRtcPassthroughRender::HasIncomingRenderStream(
+    const WebRtc_UWord32 stream_id) const {
+  StreamMap::const_iterator it;
+  it = stream_render_map_.find(stream_id);
+  return (it != stream_render_map_.end());
+}
+
+webrtc::RawVideoType WebRtcPassthroughRender::PreferredVideoType() const {
+  return webrtc::kVideoI420;
+}
+
+}  // namespace cricket
diff --git a/talk/session/phone/webrtcpassthroughrender.h b/talk/session/phone/webrtcpassthroughrender.h
new file mode 100644
index 0000000..8d2ae90
--- /dev/null
+++ b/talk/session/phone/webrtcpassthroughrender.h
@@ -0,0 +1,211 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_SESSION_PHONE_WEBRTCPASSTHROUGHRENDER_H_
+#define TALK_SESSION_PHONE_WEBRTCPASSTHROUGHRENDER_H_
+
+#include <map>
+
+#ifdef WEBRTC_RELATIVE_PATH
+#include "modules/video_render/main/interface/video_render.h"
+#else
+#include "third_party/webrtc/files/include/video_render.h"
+#endif
+#include "talk/base/criticalsection.h"
+
+namespace cricket {
+class PassthroughStream;
+
+class WebRtcPassthroughRender : public webrtc::VideoRender {
+ public:
+  WebRtcPassthroughRender();
+  virtual ~WebRtcPassthroughRender();
+
+  virtual WebRtc_Word32 Version(WebRtc_Word8* version,
+      WebRtc_UWord32& remainingBufferInBytes,
+      WebRtc_UWord32& position) const {
+    return 0;
+  }
+
+  virtual WebRtc_Word32 ChangeUniqueId(const WebRtc_Word32 id) {
+    return 0;
+  }
+
+  virtual WebRtc_Word32 TimeUntilNextProcess() { return 0; }
+
+  virtual WebRtc_Word32 Process() { return 0; }
+
+  virtual void* Window() {
+    talk_base::CritScope cs(&render_critical_);
+    return window_;
+  }
+
+  virtual WebRtc_Word32 ChangeWindow(void* window) {
+    talk_base::CritScope cs(&render_critical_);
+    window_ = window;
+    return 0;
+  }
+
+  virtual webrtc::VideoRenderCallback* AddIncomingRenderStream(
+      const WebRtc_UWord32 stream_id,
+      const WebRtc_UWord32 zOrder,
+      const float left, const float top,
+      const float right, const float bottom);
+
+  virtual WebRtc_Word32 DeleteIncomingRenderStream(
+      const WebRtc_UWord32 stream_id);
+
+  virtual WebRtc_Word32 AddExternalRenderCallback(
+      const WebRtc_UWord32 stream_id,
+      webrtc::VideoRenderCallback* render_object);
+
+  virtual WebRtc_Word32 GetIncomingRenderStreamProperties(
+      const WebRtc_UWord32 stream_id,
+      WebRtc_UWord32& zOrder,
+      float& left, float& top,
+      float& right, float& bottom) const {
+    return -1;
+  }
+
+  virtual WebRtc_UWord32 GetIncomingFrameRate(
+      const WebRtc_UWord32 stream_id) {
+    return 0;
+  }
+
+  virtual WebRtc_UWord32 GetNumIncomingRenderStreams() const {
+    return stream_render_map_.size();
+  }
+
+  virtual bool HasIncomingRenderStream(const WebRtc_UWord32 stream_id) const;
+
+  virtual WebRtc_Word32 RegisterRawFrameCallback(
+      const WebRtc_UWord32 stream_id,
+      webrtc::VideoRenderCallback* callback_obj) {
+    return -1;
+  }
+
+  virtual WebRtc_Word32 GetLastRenderedFrame(
+      const WebRtc_UWord32 stream_id,
+      webrtc::VideoFrame &frame) const {
+    return -1;
+  }
+
+  virtual WebRtc_Word32 StartRender(
+      const WebRtc_UWord32 stream_id) { return 0; }
+
+  virtual WebRtc_Word32 StopRender(
+      const WebRtc_UWord32 stream_id) { return 0; }
+
+  virtual WebRtc_Word32 ResetRender() { return 0; }
+
+  virtual webrtc::RawVideoType PreferredVideoType() const;
+
+  virtual bool IsFullScreen() { return false; }
+
+  virtual WebRtc_Word32 GetScreenResolution(
+      WebRtc_UWord32& screenWidth,
+      WebRtc_UWord32& screenHeight) const {
+    return -1;
+  }
+
+  virtual WebRtc_UWord32 RenderFrameRate(
+      const WebRtc_UWord32 stream_id) {
+    return 0;
+  }
+
+  virtual WebRtc_Word32 SetStreamCropping(
+      const WebRtc_UWord32 stream_id,
+      const float left, const float top,
+      const float right,
+      const float bottom) {
+    return -1;
+  }
+
+  virtual WebRtc_Word32 ConfigureRenderer(
+      const WebRtc_UWord32 stream_id,
+      const unsigned int zOrder,
+      const float left, const float top,
+      const float right,
+      const float bottom) {
+    return -1;
+  }
+
+  virtual WebRtc_Word32 SetTransparentBackground(const bool enable) {
+    return -1;
+  }
+
+  virtual WebRtc_Word32 FullScreenRender(void* window, const bool enable) {
+    return -1;
+  }
+
+  virtual WebRtc_Word32 SetBitmap(const void* bitMap,
+      const WebRtc_UWord8 pictureId, const void* colorKey,
+      const float left, const float top,
+      const float right, const float bottom) {
+    return -1;
+  }
+
+  virtual WebRtc_Word32 SetText(const WebRtc_UWord8 textId,
+      const WebRtc_UWord8* text,
+      const WebRtc_Word32 textLength,
+      const WebRtc_UWord32 textColorRef,
+      const WebRtc_UWord32 backgroundColorRef,
+      const float left, const float top,
+      const float right, const float bottom) {
+    return -1;
+  }
+
+  virtual WebRtc_Word32 SetStartImage(
+      const WebRtc_UWord32 stream_id,
+      const webrtc::VideoFrame& videoFrame) {
+    return -1;
+  }
+
+  virtual WebRtc_Word32 SetTimeoutImage(
+      const WebRtc_UWord32 stream_id,
+      const webrtc::VideoFrame& videoFrame,
+      const WebRtc_UWord32 timeout) {
+    return -1;
+  }
+
+  virtual WebRtc_Word32 MirrorRenderStream(const int renderId,
+                                           const bool enable,
+                                           const bool mirrorXAxis,
+                                           const bool mirrorYAxis) {
+    return -1;
+  }
+
+ private:
+  typedef std::map<WebRtc_UWord32, PassthroughStream*> StreamMap;
+
+  void* window_;
+  StreamMap stream_render_map_;
+  talk_base::CriticalSection render_critical_;
+};
+}  // namespace cricket
+
+#endif  // TALK_SESSION_PHONE_WEBRTCPASSTHROUGHRENDER_H_
diff --git a/talk/session/phone/webrtcpassthroughrender_unittest.cc b/talk/session/phone/webrtcpassthroughrender_unittest.cc
new file mode 100644
index 0000000..b33d38b
--- /dev/null
+++ b/talk/session/phone/webrtcpassthroughrender_unittest.cc
@@ -0,0 +1,117 @@
+// Copyright 2008 Google Inc. All Rights Reserved,
+//
+// Author: Ronghua Wu (ronghuawu@google.com)
+
+#include <string>
+
+#include "talk/base/gunit.h"
+#include "talk/session/phone/webrtcpassthroughrender.h"
+#include "talk/session/phone/testutils.h"
+
+class WebRtcPassthroughRenderTest : public testing::Test {
+ public:
+  class ExternalRenderer : public webrtc::VideoRenderCallback {
+   public:
+    ExternalRenderer() : frame_num_(0) {
+    }
+
+    virtual ~ExternalRenderer() {
+    }
+
+    virtual WebRtc_Word32 RenderFrame(
+        const WebRtc_UWord32 stream_id,
+        webrtc::VideoFrame& videoFrame) {
+      ++frame_num_;
+      LOG(INFO) << "RenderFrame stream_id: " << stream_id
+                << " frame_num: " << frame_num_;
+      return 0;
+    }
+
+    int frame_num() const {
+      return frame_num_;
+    }
+
+   private:
+    int frame_num_;
+  };
+
+  WebRtcPassthroughRenderTest()
+      : renderer_(new cricket::WebRtcPassthroughRender()) {
+  }
+
+  ~WebRtcPassthroughRenderTest() {
+  }
+
+  webrtc::VideoRenderCallback* AddIncomingRenderStream(int stream_id) {
+    return renderer_->AddIncomingRenderStream(stream_id, 0, 0, 0, 0, 0);
+  }
+
+  bool HasIncomingRenderStream(int stream_id) {
+    return renderer_->HasIncomingRenderStream(stream_id);
+  }
+
+  bool DeleteIncomingRenderStream(int stream_id) {
+    return (renderer_->DeleteIncomingRenderStream(stream_id) == 0);
+  }
+
+  bool AddExternalRenderCallback(int stream_id,
+                                 webrtc::VideoRenderCallback* renderer) {
+    return (renderer_->AddExternalRenderCallback(stream_id, renderer) == 0);
+  }
+
+ private:
+  talk_base::scoped_ptr<cricket::WebRtcPassthroughRender> renderer_;
+};
+
+TEST_F(WebRtcPassthroughRenderTest, Streams) {
+  const int stream_id1 = 1234;
+  const int stream_id2 = 5678;
+  webrtc::VideoRenderCallback* stream = NULL;
+  // Add a new stream
+  stream = AddIncomingRenderStream(stream_id1);
+  EXPECT_TRUE(stream != NULL);
+  EXPECT_TRUE(HasIncomingRenderStream(stream_id1));
+  // Tried to add a already existed stream should return null
+  stream =AddIncomingRenderStream(stream_id1);
+  EXPECT_TRUE(stream == NULL);
+  stream = AddIncomingRenderStream(stream_id2);
+  EXPECT_TRUE(stream != NULL);
+  EXPECT_TRUE(HasIncomingRenderStream(stream_id2));
+  // Remove the stream
+  EXPECT_TRUE(DeleteIncomingRenderStream(stream_id2));
+  EXPECT_TRUE(!HasIncomingRenderStream(stream_id2));
+  // Add back the removed stream
+  stream = AddIncomingRenderStream(stream_id2);
+  EXPECT_TRUE(stream != NULL);
+  EXPECT_TRUE(HasIncomingRenderStream(stream_id2));
+}
+
+TEST_F(WebRtcPassthroughRenderTest, Renderer) {
+  webrtc::VideoFrame frame;
+  const int stream_id1 = 1234;
+  const int stream_id2 = 5678;
+  webrtc::VideoRenderCallback* stream1 = NULL;
+  webrtc::VideoRenderCallback* stream2 = NULL;
+  // Add two new stream
+  stream1 = AddIncomingRenderStream(stream_id1);
+  EXPECT_TRUE(stream1 != NULL);
+  EXPECT_TRUE(HasIncomingRenderStream(stream_id1));
+  stream2 = AddIncomingRenderStream(stream_id2);
+  EXPECT_TRUE(stream2 != NULL);
+  EXPECT_TRUE(HasIncomingRenderStream(stream_id2));
+  // Register the external renderer
+  WebRtcPassthroughRenderTest::ExternalRenderer renderer1;
+  WebRtcPassthroughRenderTest::ExternalRenderer renderer2;
+  AddExternalRenderCallback(stream_id1, &renderer1);
+  AddExternalRenderCallback(stream_id2, &renderer2);
+  int test_frame_num = 10;
+  for (int i = 0; i < test_frame_num; ++i) {
+    stream1->RenderFrame(stream_id1, frame);
+  }
+  EXPECT_EQ(test_frame_num, renderer1.frame_num());
+  test_frame_num = 30;
+  for (int i = 0; i < test_frame_num; ++i) {
+    stream2->RenderFrame(stream_id2, frame);
+  }
+  EXPECT_EQ(test_frame_num, renderer2.frame_num());
+}
diff --git a/talk/session/phone/webrtcvideoengine.cc b/talk/session/phone/webrtcvideoengine.cc
new file mode 100644
index 0000000..6f9ff6a
--- /dev/null
+++ b/talk/session/phone/webrtcvideoengine.cc
@@ -0,0 +1,1003 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef HAVE_WEBRTC_VIDEO
+
+#include "talk/session/phone/webrtcvideoengine.h"
+
+#include "talk/base/common.h"
+#include "talk/base/buffer.h"
+#include "talk/base/byteorder.h"
+#include "talk/base/logging.h"
+#include "talk/base/stringutils.h"
+#include "talk/session/phone/videorenderer.h"
+#include "talk/session/phone/webrtcpassthroughrender.h"
+#include "talk/session/phone/webrtcvoiceengine.h"
+#include "talk/session/phone/webrtcvideoframe.h"
+#include "talk/session/phone/webrtcvie.h"
+#include "talk/session/phone/webrtcvoe.h"
+
+namespace cricket {
+
+static const int kDefaultLogSeverity = talk_base::LS_WARNING;
+static const int kStartVideoBitrate = 300;
+static const int kMaxVideoBitrate = 1000;
+
+class WebRtcRenderAdapter : public webrtc::ExternalRenderer {
+ public:
+  explicit WebRtcRenderAdapter(VideoRenderer* renderer)
+      : renderer_(renderer) {
+  }
+
+  virtual int FrameSizeChange(unsigned int width, unsigned int height,
+                              unsigned int /*number_of_streams*/) {
+    if (renderer_ == NULL)
+      return 0;
+    width_ = width;
+    height_ = height;
+    return renderer_->SetSize(width_, height_, 0) ? 0 : -1;
+  }
+
+  virtual int DeliverFrame(unsigned char* buffer, int buffer_size) {
+    if (renderer_ == NULL)
+      return 0;
+    WebRtcVideoFrame video_frame;
+    // TODO: Currently by the time DeliverFrame got called,
+    // ViE expects the frame will be rendered ASAP. However, the libjingle
+    // renderer may have its own internal delays. Can you disable the buffering
+    // inside ViE and surface the timing information to this callback?
+    video_frame.Attach(buffer, buffer_size, width_, height_, 0, 0);
+    int ret = renderer_->RenderFrame(&video_frame) ? 0 : -1;
+    uint8* buffer_temp;
+    size_t buffer_size_temp;
+    video_frame.Detach(&buffer_temp, &buffer_size_temp);
+    return ret;
+  }
+
+  virtual ~WebRtcRenderAdapter() {}
+
+ private:
+  VideoRenderer* renderer_;
+  unsigned int width_;
+  unsigned int height_;
+};
+
+const WebRtcVideoEngine::VideoCodecPref
+    WebRtcVideoEngine::kVideoCodecPrefs[] = {
+    {"VP8", 120, 0},
+};
+
+// The formats are sorted by the descending order of width. We use the order to
+// find the next format for CPU and bandwidth adaptation.
+const VideoFormat WebRtcVideoEngine::kVideoFormats[] = {
+  // TODO: Understand why we have problem with 16:9 formats.
+  VideoFormat(1280, 800, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+//VideoFormat(1280, 720, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+  VideoFormat(960, 600, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+//VideoFormat(960, 540, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+  VideoFormat(640, 400, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+//VideoFormat(640, 360, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+  VideoFormat(480, 300, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+//VideoFormat(480, 270, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+  VideoFormat(320, 200, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+//VideoFormat(320, 180, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+  VideoFormat(240, 150, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+//VideoFormat(240, 135, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+  VideoFormat(160, 100, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+//VideoFormat(160, 90, VideoFormat::FpsToInterval(30), FOURCC_ANY),
+};
+
+// TODO: Understand why 640x400 is not working.
+const VideoFormat WebRtcVideoEngine::kDefaultVideoFormat =
+    VideoFormat(320, 200, VideoFormat::FpsToInterval(30), FOURCC_ANY);
+
+WebRtcVideoEngine::WebRtcVideoEngine()
+    : vie_wrapper_(new ViEWrapper()),
+      capture_module_(NULL),
+      external_capture_(false),
+      render_module_(new WebRtcPassthroughRender()),
+      voice_engine_(NULL) {
+  Construct();
+}
+
+WebRtcVideoEngine::WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
+                                     webrtc::VideoCaptureModule* capture)
+    : vie_wrapper_(new ViEWrapper()),
+      capture_module_(capture),
+      external_capture_(true),
+      render_module_(webrtc::VideoRender::CreateVideoRender(0, NULL, false,
+          webrtc::kRenderExternal)),
+      voice_engine_(voice_engine) {
+  Construct();
+}
+
+WebRtcVideoEngine::WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
+                                     ViEWrapper* vie_wrapper)
+    : vie_wrapper_(vie_wrapper),
+      capture_module_(NULL),
+      external_capture_(false),
+      render_module_(new WebRtcPassthroughRender()),
+      voice_engine_(voice_engine) {
+  Construct();
+}
+
+void  WebRtcVideoEngine::Construct() {
+  capture_id_ = -1;
+  log_level_ = kDefaultLogSeverity;
+  capture_started_ = false;
+
+  ApplyLogging();
+  if (vie_wrapper_->engine()->SetTraceCallback(this) != 0) {
+    LOG_RTCERR1(SetTraceCallback, this);
+  }
+
+  // Set default quality levels for our supported codecs.  We override them here
+  // if we know your cpu performance is low, and they can be updated explicitly
+  // by calling SetDefaultCodec.  For example by a flute preference setting, or
+  // by the server with a jec in response to our reported system info.
+  VideoCodec max_codec(kVideoCodecPrefs[0].payload_type,
+                       kVideoCodecPrefs[0].name,
+                       kDefaultVideoFormat.width,
+                       kDefaultVideoFormat.height,
+                       kDefaultVideoFormat.framerate(), 0);
+  if (!SetDefaultCodec(max_codec)) {
+    LOG(LS_ERROR) << "Failed to initialize list of supported codec types";
+  }
+}
+
+WebRtcVideoEngine::~WebRtcVideoEngine() {
+  LOG(LS_INFO) << " WebRtcVideoEngine::~WebRtcVideoEngine";
+  vie_wrapper_->engine()->SetTraceCallback(NULL);
+  Terminate();
+  vie_wrapper_.reset();
+  if (capture_module_) {
+    webrtc::VideoCaptureModule::Destroy(capture_module_);
+  }
+}
+
+bool WebRtcVideoEngine::Init() {
+  LOG(LS_INFO) << "WebRtcVideoEngine::Init";
+  bool result = InitVideoEngine();
+  if (result) {
+    LOG(LS_INFO) << "VideoEngine Init done";
+  } else {
+    LOG(LS_ERROR) << "VideoEngine Init failed, releasing";
+    Terminate();
+  }
+  return result;
+}
+
+bool WebRtcVideoEngine::InitVideoEngine() {
+  LOG(LS_INFO) << "WebRtcVideoEngine::InitVideoEngine";
+
+  if (vie_wrapper_->base()->Init() != 0) {
+    LOG_RTCERR0(Init);
+    return false;
+  }
+
+  if (!voice_engine_) {
+    LOG(LS_WARNING) << "NULL voice engine";
+  } else if ((vie_wrapper_->base()->SetVoiceEngine(
+      voice_engine_->voe()->engine())) != 0) {
+    LOG_RTCERR0(SetVoiceEngine);
+    return false;
+  }
+
+  if ((vie_wrapper_->base()->RegisterObserver(*this)) != 0) {
+    LOG_RTCERR0(RegisterObserver);
+    return false;
+  }
+
+  if (vie_wrapper_->render()->RegisterVideoRenderModule(
+      *render_module_.get()) != 0) {
+    LOG_RTCERR0(RegisterVideoRenderModule);
+    return false;
+  }
+
+  std::sort(video_codecs_.begin(), video_codecs_.end(),
+            &VideoCodec::Preferable);
+  return true;
+}
+
+void WebRtcVideoEngine::PerformanceAlarm(const unsigned int cpu_load) {
+  LOG(LS_INFO) << "WebRtcVideoEngine::PerformanceAlarm";
+}
+
+// Ignore spammy trace messages, mostly from the stats API when we haven't
+// gotten RTCP info yet from the remote side.
+static bool ShouldIgnoreTrace(const std::string& trace) {
+  static const char* kTracesToIgnore[] = {
+    "\tfailed to GetReportBlockInformation",
+    NULL
+  };
+  for (const char* const* p = kTracesToIgnore; *p; ++p) {
+    if (trace.find(*p) == 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void WebRtcVideoEngine::Print(const webrtc::TraceLevel level,
+                              const char* trace, const int length) {
+  talk_base::LoggingSeverity sev = talk_base::LS_VERBOSE;
+  if (level == webrtc::kTraceError || level == webrtc::kTraceCritical)
+    sev = talk_base::LS_ERROR;
+  else if (level == webrtc::kTraceWarning)
+    sev = talk_base::LS_WARNING;
+  else if (level == webrtc::kTraceStateInfo || level == webrtc::kTraceInfo)
+    sev = talk_base::LS_INFO;
+
+  if (sev >= log_level_) {
+    // Skip past boilerplate prefix text
+    if (length < 72) {
+      std::string msg(trace, length);
+      LOG(LS_ERROR) << "Malformed webrtc log message: ";
+      LOG_V(sev) << msg;
+    } else {
+      std::string msg(trace + 71, length - 72);
+      if (!ShouldIgnoreTrace(msg)) {
+        LOG_V(sev) << "WebRtc ViE:" << msg;
+      }
+    }
+  }
+}
+
+void WebRtcVideoEngine::ApplyLogging() {
+  int filter = 0;
+  switch (log_level_) {
+    case talk_base::LS_VERBOSE: filter |= webrtc::kTraceAll;
+    case talk_base::LS_INFO: filter |= webrtc::kTraceStateInfo;
+    case talk_base::LS_WARNING: filter |= webrtc::kTraceWarning;
+    case talk_base::LS_ERROR: filter |=
+        webrtc::kTraceError | webrtc::kTraceCritical;
+  }
+}
+
+// Rebuilds the codec list to be only those that are less intensive
+// than the specified codec.
+bool WebRtcVideoEngine::RebuildCodecList(const VideoCodec& in_codec) {
+  if (!FindCodec(in_codec))
+    return false;
+
+  video_codecs_.clear();
+
+  bool found = false;
+  for (size_t i = 0; i < ARRAY_SIZE(kVideoCodecPrefs); ++i) {
+    const VideoCodecPref& pref(kVideoCodecPrefs[i]);
+    if (!found)
+      found = (in_codec.name == pref.name);
+    if (found) {
+      VideoCodec codec(pref.payload_type, pref.name,
+                       in_codec.width, in_codec.height, in_codec.framerate,
+                       ARRAY_SIZE(kVideoCodecPrefs) - i);
+      video_codecs_.push_back(codec);
+    }
+  }
+  ASSERT(found);
+  return true;
+}
+
+void WebRtcVideoEngine::Terminate() {
+  LOG(LS_INFO) << "WebRtcVideoEngine::Terminate";
+  SetCapture(false);
+  if (local_renderer_.get()) {
+    // If the renderer already set, stop it first
+    if (vie_wrapper_->render()->StopRender(capture_id_) != 0)
+      LOG_RTCERR1(StopRender, capture_id_);
+  }
+
+  if (vie_wrapper_->render()->DeRegisterVideoRenderModule(
+      *render_module_.get()) != 0)
+    LOG_RTCERR0(DeRegisterVideoRenderModule);
+
+  if ((vie_wrapper_->base()->DeregisterObserver()) != 0)
+    LOG_RTCERR0(DeregisterObserver);
+
+  if ((vie_wrapper_->base()->SetVoiceEngine(NULL)) != 0)
+    LOG_RTCERR0(SetVoiceEngine);
+
+  if (vie_wrapper_->engine()->SetTraceCallback(NULL) != 0)
+    LOG_RTCERR0(SetTraceCallback);
+}
+
+int WebRtcVideoEngine::GetCapabilities() {
+  return VIDEO_RECV | VIDEO_SEND;
+}
+
+bool WebRtcVideoEngine::SetOptions(int options) {
+  return true;
+}
+
+bool WebRtcVideoEngine::ReleaseCaptureDevice() {
+  if (capture_id_ != -1) {
+    // Stop capture
+    SetCapture(false);
+    // DisconnectCaptureDevice
+    WebRtcVideoMediaChannel* channel;
+    for (VideoChannels::const_iterator it = channels_.begin();
+        it != channels_.end(); ++it) {
+      ASSERT(*it != NULL);
+      channel = *it;
+      // Ignore the return value here as the channel may not have connected to
+      // the capturer yet.
+      vie_wrapper_->capture()->DisconnectCaptureDevice(
+          channel->video_channel());
+      channel->set_connected(false);
+    }
+    // ReleaseCaptureDevice
+    vie_wrapper_->capture()->ReleaseCaptureDevice(capture_id_);
+    capture_id_ = -1;
+  }
+
+  return true;
+}
+
+bool WebRtcVideoEngine::SetCaptureDevice(const Device* cam) {
+  ASSERT(cam != NULL);
+
+  ReleaseCaptureDevice();
+
+  webrtc::ViECapture* vie_capture = vie_wrapper_->capture();
+
+  // There's an external VCM
+  if (capture_module_) {
+    if (vie_capture->AllocateCaptureDevice(*capture_module_, capture_id_) != 0)
+      ASSERT(capture_id_ == -1);
+  } else if (!external_capture_) {
+    char device_name[256], device_id[256];
+    bool found = false;
+    for (int i = 0; i < vie_capture->NumberOfCaptureDevices(); ++i) {
+      if (vie_capture->GetCaptureDevice(i, device_name, sizeof(device_name),
+                                        device_id, sizeof(device_id)) == 0) {
+        // TODO: We should only compare the device_id here,
+        // however the devicemanager and webrtc use different format for th v4l2
+        // device id. So here we also compare the device_name for now.
+        // For example "usb-0000:00:1d.7-6" vs "/dev/video0".
+        if (cam->name.compare(device_name) == 0 ||
+            cam->id.compare(device_id) == 0) {
+          LOG(INFO) << "Found video capture device: " << device_name;
+          found = true;
+          break;
+        }
+      }
+    }
+    if (!found) {
+      return false;
+    }
+    if (vie_capture->AllocateCaptureDevice(device_id, strlen(device_id),
+                                           capture_id_) != 0) {
+      ASSERT(capture_id_ == -1);
+    }
+  }
+
+  if (capture_id_ != -1) {
+    // Connect to all the channels if there is any.
+    WebRtcVideoMediaChannel* channel;
+    for (VideoChannels::const_iterator it = channels_.begin();
+         it != channels_.end(); ++it) {
+      ASSERT(*it != NULL);
+      channel = *it;
+
+      // No channel should have been connected yet.
+      // In case of switching device, all channel connections should have been
+      // disconnected in ReleaseCaptureDevice() first.
+      ASSERT(!channel->connected());
+
+      if (vie_capture->ConnectCaptureDevice(capture_id_,
+                                            channel->video_channel()) == 0) {
+        channel->set_connected(true);
+      }
+    }
+    SetCapture(true);
+  }
+
+  return (capture_id_ != -1);
+}
+
+bool WebRtcVideoEngine::SetCaptureModule(webrtc::VideoCaptureModule* vcm) {
+  ReleaseCaptureDevice();
+  if (capture_module_) {
+    webrtc::VideoCaptureModule::Destroy(capture_module_);
+  }
+  capture_module_ = vcm;
+  external_capture_ = true;
+  return true;
+}
+
+bool WebRtcVideoEngine::SetLocalRenderer(VideoRenderer* renderer) {
+  if (local_renderer_.get()) {
+    // If the renderer already set, stop and remove it first
+    if (vie_wrapper_->render()->StopRender(capture_id_) != 0) {
+      LOG_RTCERR1(StopRender, capture_id_);
+    }
+    if (vie_wrapper_->render()->RemoveRenderer(capture_id_) != 0) {
+      LOG_RTCERR1(RemoveRenderer, capture_id_);
+    }
+  }
+  local_renderer_.reset(new WebRtcRenderAdapter(renderer));
+
+  int ret;
+  ret = vie_wrapper_->render()->AddRenderer(capture_id_,
+                                            webrtc::kVideoI420,
+                                            local_renderer_.get());
+  if (ret != 0)
+    return false;
+  ret = vie_wrapper_->render()->StartRender(capture_id_);
+  return (ret == 0);
+}
+
+CaptureResult WebRtcVideoEngine::SetCapture(bool capture) {
+  if ((capture_started_ != capture) && (capture_id_ != -1)) {
+    int ret;
+    if (capture)
+      ret = vie_wrapper_->capture()->StartCapture(capture_id_);
+    else
+      ret = vie_wrapper_->capture()->StopCapture(capture_id_);
+    if (ret != 0)
+      return CR_NO_DEVICE;
+    capture_started_ = capture;
+  }
+  return CR_SUCCESS;
+}
+
+const std::vector<VideoCodec>& WebRtcVideoEngine::codecs() const {
+  return video_codecs_;
+}
+
+void WebRtcVideoEngine::SetLogging(int min_sev, const char* filter) {
+  log_level_ = min_sev;
+  ApplyLogging();
+}
+
+int WebRtcVideoEngine::GetLastEngineError() {
+  return vie_wrapper_->error();
+}
+
+bool WebRtcVideoEngine::SetDefaultEncoderConfig(
+    const VideoEncoderConfig& config) {
+  default_encoder_config_ = config;
+  return true;
+}
+
+WebRtcVideoMediaChannel* WebRtcVideoEngine::CreateChannel(
+    VoiceMediaChannel* voice_channel) {
+  WebRtcVideoMediaChannel* channel =
+      new WebRtcVideoMediaChannel(this, voice_channel);
+  if (channel) {
+    if (!channel->Init()) {
+      delete channel;
+      channel = NULL;
+    }
+  }
+  return channel;
+}
+
+// Checks to see whether we comprehend and could receive a particular codec
+bool WebRtcVideoEngine::FindCodec(const VideoCodec& in) {
+  for (int i = 0; i < ARRAY_SIZE(kVideoFormats); ++i) {
+    const VideoFormat& fmt = kVideoFormats[i];
+    if (fmt.width == in.width && fmt.height == in.height) {
+      for (int j = 0; j < ARRAY_SIZE(kVideoCodecPrefs); ++j) {
+        VideoCodec codec(kVideoCodecPrefs[j].payload_type,
+                         kVideoCodecPrefs[j].name, 0, 0, 0, 0);
+        if (codec.Matches(in)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// SetDefaultCodec may be called while the capturer is running. For example, a
+// test call is started in a page with QVGA default codec, and then a real call
+// is started in another page with VGA default codec. This is the corner case
+// and happens only when a session is started. We ignore this case currently.
+bool WebRtcVideoEngine::SetDefaultCodec(const VideoCodec& codec) {
+  if (!RebuildCodecList(codec)) {
+    LOG(LS_WARNING) << "Failed to RebuildCodecList";
+    return false;
+  }
+  return true;
+}
+
+void WebRtcVideoEngine::ConvertToCricketVideoCodec(
+    const webrtc::VideoCodec& in_codec, VideoCodec& out_codec) {
+  out_codec.id = in_codec.plType;
+  out_codec.name = in_codec.plName;
+  out_codec.width = in_codec.width;
+  out_codec.height = in_codec.height;
+  out_codec.framerate = in_codec.maxFramerate;
+}
+
+bool WebRtcVideoEngine::ConvertFromCricketVideoCodec(
+    const VideoCodec& in_codec, webrtc::VideoCodec& out_codec) {
+  bool found = false;
+  int ncodecs = vie_wrapper_->codec()->NumberOfCodecs();
+  for (int i = 0; i < ncodecs; ++i) {
+    if ((vie_wrapper_->codec()->GetCodec(i, out_codec) == 0) &&
+        (strncmp(out_codec.plName,
+                 in_codec.name.c_str(),
+                 webrtc::kPayloadNameSize - 1) == 0)) {
+      found = true;
+      break;
+    }
+  }
+
+  if (!found) {
+    LOG(LS_ERROR) << "invalid codec type";
+    return false;
+  }
+
+  if (in_codec.id != 0)
+    out_codec.plType = in_codec.id;
+
+  if (in_codec.width != 0)
+    out_codec.width = in_codec.width;
+
+  if (in_codec.height != 0)
+    out_codec.height = in_codec.height;
+
+  if (in_codec.framerate != 0)
+    out_codec.maxFramerate = in_codec.framerate;
+
+  out_codec.maxBitrate = kMaxVideoBitrate;
+  out_codec.startBitrate = kStartVideoBitrate;
+  out_codec.minBitrate = kStartVideoBitrate;
+
+  return true;
+}
+
+int WebRtcVideoEngine::GetLastVideoEngineError() {
+  return vie_wrapper_->base()->LastError();
+}
+
+void WebRtcVideoEngine::RegisterChannel(WebRtcVideoMediaChannel *channel) {
+  channels_.push_back(channel);
+}
+
+void WebRtcVideoEngine::UnregisterChannel(WebRtcVideoMediaChannel *channel) {
+  VideoChannels::iterator i = std::find(channels_.begin(),
+                                      channels_.end(),
+                                      channel);
+  if (i != channels_.end()) {
+    channels_.erase(i);
+  }
+}
+
+// WebRtcVideoMediaChannel
+
+WebRtcVideoMediaChannel::WebRtcVideoMediaChannel(
+    WebRtcVideoEngine* engine, VoiceMediaChannel* channel)
+    : engine_(engine),
+      voice_channel_(channel),
+      vie_channel_(-1),
+      sending_(false),
+      connected_(false),
+      render_started_(false),
+      send_codec_(NULL) {
+  engine->RegisterChannel(this);
+}
+
+bool WebRtcVideoMediaChannel::Init() {
+  bool ret = true;
+  if (engine_->video_engine()->base()->CreateChannel(vie_channel_) != 0) {
+    LOG_RTCERR1(CreateChannel, vie_channel_);
+    return false;
+  }
+
+  LOG(LS_INFO) << "WebRtcVideoMediaChannel::Init "
+               << "video_channel " << vie_channel_ << " created";
+
+  // connect audio channel
+  if (voice_channel_) {
+    WebRtcVoiceMediaChannel* channel =
+        static_cast<WebRtcVoiceMediaChannel*> (voice_channel_);
+    if (engine_->video_engine()->base()->ConnectAudioChannel(
+        vie_channel_, channel->voe_channel()) != 0) {
+      LOG(LS_WARNING) << "ViE ConnectAudioChannel failed"
+                   << "A/V not synchronized";
+      // Don't set ret to false;
+    }
+  }
+
+  // Register external transport
+  if (engine_->video_engine()->network()->RegisterSendTransport(
+      vie_channel_, *this) != 0) {
+    ret = false;
+  } else {
+    EnableRtcp();
+    EnablePLI();
+  }
+  return ret;
+}
+
+WebRtcVideoMediaChannel::~WebRtcVideoMediaChannel() {
+  // Stop and remote renderer
+  SetRender(false);
+  if (engine()->video_engine()->render()->RemoveRenderer(vie_channel_)
+      == -1) {
+    LOG_RTCERR1(RemoveRenderer, vie_channel_);
+  }
+
+  // DeRegister external transport
+  if (engine()->video_engine()->network()->DeregisterSendTransport(
+      vie_channel_) == -1) {
+    LOG_RTCERR1(DeregisterSendTransport, vie_channel_);
+  }
+
+  // Unregister RtcChannel with the engine.
+  engine()->UnregisterChannel(this);
+
+  // Delete VideoChannel
+  if (engine()->video_engine()->base()->DeleteChannel(vie_channel_) == -1) {
+    LOG_RTCERR1(DeleteChannel, vie_channel_);
+  }
+}
+
+bool WebRtcVideoMediaChannel::SetRecvCodecs(
+    const std::vector<VideoCodec>& codecs) {
+  bool ret = true;
+  for (std::vector<VideoCodec>::const_iterator iter = codecs.begin();
+      iter != codecs.end(); ++iter) {
+    if (engine()->FindCodec(*iter)) {
+      webrtc::VideoCodec wcodec;
+      if (engine()->ConvertFromCricketVideoCodec(*iter, wcodec)) {
+        if (engine()->video_engine()->codec()->SetReceiveCodec(
+            vie_channel_,  wcodec) != 0) {
+          LOG_RTCERR2(SetReceiveCodec, vie_channel_, wcodec.plName);
+          ret = false;
+        }
+      }
+    } else {
+      LOG(LS_INFO) << "Unknown codec" << iter->name;
+      ret = false;
+    }
+  }
+
+  // make channel ready to receive packets
+  if (ret) {
+    if (engine()->video_engine()->base()->StartReceive(vie_channel_) != 0) {
+      LOG_RTCERR1(StartReceive, vie_channel_);
+      ret = false;
+    }
+  }
+  return ret;
+}
+
+bool WebRtcVideoMediaChannel::SetSendCodecs(
+    const std::vector<VideoCodec>& codecs) {
+  if (sending_) {
+    LOG(LS_ERROR) << "channel is alredy sending";
+    return false;
+  }
+
+  // match with local video codec list
+  std::vector<webrtc::VideoCodec> send_codecs;
+  for (std::vector<VideoCodec>::const_iterator iter = codecs.begin();
+      iter != codecs.end(); ++iter) {
+    if (engine()->FindCodec(*iter)) {
+      webrtc::VideoCodec wcodec;
+      if (engine()->ConvertFromCricketVideoCodec(*iter, wcodec))
+        send_codecs.push_back(wcodec);
+    }
+  }
+
+  // if none matches, return with set
+  if (send_codecs.empty()) {
+    LOG(LS_ERROR) << "No matching codecs avilable";
+    return false;
+  }
+
+  // select the first matched codec
+  const webrtc::VideoCodec& codec(send_codecs[0]);
+  send_codec_.reset(new webrtc::VideoCodec(codec));
+  if (engine()->video_engine()->codec()->SetSendCodec(
+      vie_channel_, codec) != 0) {
+    LOG_RTCERR2(SetSendCodec, vie_channel_, codec.plName);
+    return false;
+  }
+  return true;
+}
+
+bool WebRtcVideoMediaChannel::SetRender(bool render) {
+  if (render != render_started_) {
+    int ret;
+    if (render) {
+      ret = engine()->video_engine()->render()->StartRender(vie_channel_);
+    } else {
+      ret = engine()->video_engine()->render()->StopRender(vie_channel_);
+    }
+    if (ret != 0) {
+      return false;
+    }
+    render_started_ = render;
+  }
+  return true;
+}
+
+bool WebRtcVideoMediaChannel::SetSend(bool send) {
+  if (send == sending()) {
+    return true;  // no action required
+  }
+
+  bool ret = true;
+  if (send) {  // enable
+    if (engine()->video_engine()->base()->StartSend(vie_channel_) != 0) {
+      LOG_RTCERR1(StartSend, vie_channel_);
+      ret = false;
+    }
+
+    // If the channel has not been connected to the capturer yet,
+    // connect it now.
+    if (!connected()) {
+      if (engine()->video_engine()->capture()->ConnectCaptureDevice(
+          engine()->capture_id(), vie_channel_) != 0) {
+        LOG_RTCERR2(ConnectCaptureDevice, engine()->capture_id(), vie_channel_);
+        ret = false;
+      } else {
+        set_connected(true);
+      }
+    }
+  } else {  // disable
+    if (engine()->video_engine()->base()->StopSend(vie_channel_) != 0) {
+      LOG_RTCERR1(StopSend, vie_channel_);
+      ret = false;
+    }
+  }
+  if (ret) {
+    sending_ = send;
+  }
+
+  return ret;
+}
+
+bool WebRtcVideoMediaChannel::AddStream(uint32 ssrc, uint32 voice_ssrc) {
+  return false;
+}
+
+bool WebRtcVideoMediaChannel::RemoveStream(uint32 ssrc) {
+  return false;
+}
+
+bool WebRtcVideoMediaChannel::SetRenderer(
+    uint32 ssrc, VideoRenderer* renderer) {
+  ASSERT(vie_channel_ != -1);
+  if (ssrc != 0)
+    return false;
+  if (remote_renderer_.get()) {
+    // If the renderer already set, stop and remove it first
+    if (engine_->video_engine()->render()->StopRender(vie_channel_) != 0) {
+      LOG_RTCERR1(StopRender, vie_channel_);
+    }
+    if (engine_->video_engine()->render()->RemoveRenderer(vie_channel_) != 0) {
+      LOG_RTCERR1(RemoveRenderer, vie_channel_);
+    }
+  }
+  remote_renderer_.reset(new WebRtcRenderAdapter(renderer));
+
+  if (engine_->video_engine()->render()->AddRenderer(vie_channel_,
+      webrtc::kVideoI420, remote_renderer_.get()) != 0) {
+    LOG_RTCERR3(AddRenderer, vie_channel_, webrtc::kVideoI420,
+                remote_renderer_.get());
+    remote_renderer_.reset();
+    return false;
+  }
+
+  if (engine_->video_engine()->render()->StartRender(vie_channel_) != 0) {
+    LOG_RTCERR1(StartRender, vie_channel_);
+    return false;
+  }
+
+  return true;
+}
+
+bool WebRtcVideoMediaChannel::GetStats(VideoMediaInfo* info) {
+  VideoSenderInfo sinfo;
+  memset(&sinfo, 0, sizeof(sinfo));
+
+  unsigned int ssrc;
+  if (engine_->video_engine()->rtp()->GetLocalSSRC(vie_channel_,
+                                                   ssrc) != 0) {
+    LOG_RTCERR2(GetLocalSSRC, vie_channel_, ssrc);
+    return false;
+  }
+  sinfo.ssrc = ssrc;
+
+  unsigned int cumulative_lost, extended_max, jitter;
+  int rtt_ms;
+  uint16 fraction_lost;
+
+  if (engine_->video_engine()->rtp()->GetReceivedRTCPStatistics(vie_channel_,
+          fraction_lost, cumulative_lost, extended_max, jitter, rtt_ms) != 0) {
+    LOG_RTCERR6(GetReceivedRTCPStatistics, vie_channel_,
+        fraction_lost, cumulative_lost, extended_max, jitter, rtt_ms);
+    return false;
+  }
+
+  sinfo.fraction_lost = fraction_lost;
+  sinfo.packets_lost = cumulative_lost;
+  sinfo.rtt_ms = rtt_ms;
+
+  unsigned int bytes_sent, packets_sent, bytes_recv, packets_recv;
+  if (engine_->video_engine()->rtp()->GetRTPStatistics(vie_channel_,
+          bytes_sent, packets_sent, bytes_recv, packets_recv) != 0) {
+    LOG_RTCERR5(GetRTPStatistics, vie_channel_,
+        bytes_sent, packets_sent, bytes_recv, packets_recv);
+    return false;
+  }
+  sinfo.packets_sent = packets_sent;
+  sinfo.bytes_sent = bytes_sent;
+  sinfo.packets_lost = -1;
+  sinfo.packets_cached = -1;
+
+  info->senders.push_back(sinfo);
+
+  // build receiver info.
+  // reusing the above local variables
+  VideoReceiverInfo rinfo;
+  memset(&rinfo, 0, sizeof(rinfo));
+  if (engine_->video_engine()->rtp()->GetSentRTCPStatistics(vie_channel_,
+          fraction_lost, cumulative_lost, extended_max, jitter, rtt_ms) != 0) {
+    LOG_RTCERR6(GetSentRTCPStatistics, vie_channel_,
+        fraction_lost, cumulative_lost, extended_max, jitter, rtt_ms);
+    return false;
+  }
+  rinfo.bytes_rcvd = bytes_recv;
+  rinfo.packets_rcvd = packets_recv;
+  rinfo.fraction_lost = fraction_lost;
+  rinfo.packets_lost = cumulative_lost;
+
+  if (engine_->video_engine()->rtp()->GetRemoteSSRC(vie_channel_,
+                                                    ssrc) != 0) {
+    return false;
+  }
+  rinfo.ssrc = ssrc;
+
+  // Get codec for wxh
+  info->receivers.push_back(rinfo);
+  return true;
+}
+
+bool WebRtcVideoMediaChannel::SendIntraFrame() {
+  bool ret = true;
+  if (engine()->video_engine()->codec()->SendKeyFrame(vie_channel_) != 0) {
+    LOG_RTCERR1(SendKeyFrame, vie_channel_);
+    ret = false;
+  }
+
+  return ret;
+}
+
+bool WebRtcVideoMediaChannel::RequestIntraFrame() {
+  // There is no API exposed to application to request a key frame
+  // ViE does this internally when there are errors from decoder
+  return false;
+}
+
+void WebRtcVideoMediaChannel::OnPacketReceived(talk_base::Buffer* packet) {
+  engine()->video_engine()->network()->ReceivedRTPPacket(vie_channel_,
+                                                         packet->data(),
+                                                         packet->length());
+}
+
+void WebRtcVideoMediaChannel::OnRtcpReceived(talk_base::Buffer* packet) {
+  engine_->video_engine()->network()->ReceivedRTCPPacket(vie_channel_,
+                                                         packet->data(),
+                                                         packet->length());
+}
+
+void WebRtcVideoMediaChannel::SetSendSsrc(uint32 id) {
+  if (!sending_) {
+    if (engine()->video_engine()->rtp()->SetLocalSSRC(vie_channel_,
+                                                      id) != 0) {
+      LOG_RTCERR1(SetLocalSSRC, vie_channel_);
+    }
+  } else {
+    LOG(LS_ERROR) << "Channel already in send state";
+  }
+}
+
+bool WebRtcVideoMediaChannel::SetRtcpCName(const std::string& cname) {
+  if (engine()->video_engine()->rtp()->SetRTCPCName(vie_channel_,
+                                                    cname.c_str()) != 0) {
+    LOG_RTCERR2(SetRTCPCName, vie_channel_, cname.c_str());
+    return false;
+  }
+  return true;
+}
+
+bool WebRtcVideoMediaChannel::Mute(bool on) {
+  // stop send??
+  return false;
+}
+
+bool WebRtcVideoMediaChannel::SetSendBandwidth(bool autobw, int bps) {
+  LOG(LS_INFO) << "RtcVideoMediaChanne::SetSendBandwidth";
+
+  if (!send_codec_.get()) {
+    LOG(LS_INFO) << "The send codec has not been set up yet.";
+    return true;
+  }
+
+  if (!autobw) {
+    send_codec_->startBitrate = bps;
+    send_codec_->minBitrate = bps;
+  }
+  send_codec_->maxBitrate = bps;
+
+  if (engine()->video_engine()->codec()->SetSendCodec(vie_channel_,
+      *send_codec_.get()) != 0) {
+    LOG_RTCERR2(SetSendCodec, vie_channel_, send_codec_->plName);
+    return false;
+  }
+
+  return true;
+}
+
+bool WebRtcVideoMediaChannel::SetOptions(int options) {
+  return true;
+}
+
+void WebRtcVideoMediaChannel::EnableRtcp() {
+  engine()->video_engine()->rtp()->SetRTCPStatus(
+      vie_channel_, webrtc::kRtcpCompound_RFC4585);
+}
+
+void WebRtcVideoMediaChannel::EnablePLI() {
+  engine_->video_engine()->rtp()->SetKeyFrameRequestMethod(
+      vie_channel_, webrtc::kViEKeyFrameRequestPliRtcp);
+}
+
+void WebRtcVideoMediaChannel::EnableTMMBR() {
+  engine_->video_engine()->rtp()->SetTMMBRStatus(vie_channel_, true);
+}
+
+int WebRtcVideoMediaChannel::SendPacket(int channel, const void* data,
+                                        int len) {
+  if (!network_interface_) {
+    return -1;
+  }
+  talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+  return network_interface_->SendPacket(&packet) ? len : -1;
+}
+
+int WebRtcVideoMediaChannel::SendRTCPPacket(int channel,
+                                         const void* data,
+                                         int len) {
+  if (!network_interface_) {
+    return -1;
+  }
+  talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+  return network_interface_->SendRtcp(&packet) ? len : -1;
+}
+
+}  // namespace cricket
+
+#endif  // HAVE_WEBRTC_VIDEO
+
diff --git a/talk/session/phone/webrtcvideoengine.h b/talk/session/phone/webrtcvideoengine.h
new file mode 100644
index 0000000..8daa81c
--- /dev/null
+++ b/talk/session/phone/webrtcvideoengine.h
@@ -0,0 +1,207 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_SESSION_PHONE_WEBRTCVIDEOENGINE_H_
+#define TALK_SESSION_PHONE_WEBRTCVIDEOENGINE_H_
+
+#include <vector>
+
+#include "talk/base/scoped_ptr.h"
+#include "talk/session/phone/videocommon.h"
+#include "talk/session/phone/codec.h"
+#include "talk/session/phone/channel.h"
+#include "talk/session/phone/webrtccommon.h"
+
+namespace webrtc {
+class VideoCaptureModule;
+class VideoRender;
+}
+
+namespace cricket {
+struct Device;
+class VideoCapturer;
+class VideoRenderer;
+class ViEWrapper;
+class VoiceMediaChannel;
+class WebRtcRenderAdapter;
+class WebRtcVideoMediaChannel;
+class WebRtcVoiceEngine;
+
+class WebRtcVideoEngine : public webrtc::ViEBaseObserver,
+                          public webrtc::TraceCallback {
+ public:
+  // Creates the WebRtcVideoEngine with internal VideoCaptureModule.
+  WebRtcVideoEngine();
+  // Creates the WebRtcVideoEngine, and specifies the WebRtcVoiceEngine and
+  // external VideoCaptureModule to use.
+  WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
+                    webrtc::VideoCaptureModule* capture);
+  // For testing purposes. Allows the WebRtcVoiceEngine and
+  // ViEWrapper to be mocks.
+  WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine, ViEWrapper* vie_wrapper);
+  ~WebRtcVideoEngine();
+
+  bool Init();
+  void Terminate();
+
+  WebRtcVideoMediaChannel* CreateChannel(
+      VoiceMediaChannel* voice_channel);
+  bool FindCodec(const VideoCodec& in);
+  bool SetDefaultEncoderConfig(const VideoEncoderConfig& config);
+
+  void RegisterChannel(WebRtcVideoMediaChannel* channel);
+  void UnregisterChannel(WebRtcVideoMediaChannel* channel);
+
+  ViEWrapper* video_engine() { return vie_wrapper_.get(); }
+  int GetLastVideoEngineError();
+  int GetCapabilities();
+  bool SetOptions(int options);
+  bool SetCaptureDevice(const Device* device);
+  bool SetCaptureModule(webrtc::VideoCaptureModule* vcm);
+  int capture_id() const { return capture_id_; }
+  bool SetLocalRenderer(VideoRenderer* renderer);
+  CaptureResult SetCapture(bool capture);
+  const std::vector<VideoCodec>& codecs() const;
+  void SetLogging(int min_sev, const char* filter);
+
+  int GetLastEngineError();
+
+  VideoEncoderConfig& default_encoder_config() {
+    return default_encoder_config_;
+  }
+
+  void ConvertToCricketVideoCodec(const webrtc::VideoCodec& in_codec,
+                                  VideoCodec& out_codec);
+
+  bool ConvertFromCricketVideoCodec(const VideoCodec& in_codec,
+                                    webrtc::VideoCodec& out_codec);
+
+  sigslot::signal2<VideoCapturer*, CaptureResult> SignalCaptureResult;
+
+ private:
+  struct VideoCodecPref {
+    const char* name;
+    int payload_type;
+    int pref;
+  };
+
+  static const VideoCodecPref kVideoCodecPrefs[];
+  static const VideoFormat kVideoFormats[];
+  static const VideoFormat kDefaultVideoFormat;
+
+  void Construct();
+  bool SetDefaultCodec(const VideoCodec& codec);
+  bool RebuildCodecList(const VideoCodec& max_codec);
+
+  void ApplyLogging();
+  bool InitVideoEngine();
+  void PerformanceAlarm(const unsigned int cpu_load);
+  bool ReleaseCaptureDevice();
+  virtual void Print(const webrtc::TraceLevel level, const char* trace_string,
+                     const int length);
+
+  typedef std::vector<WebRtcVideoMediaChannel*> VideoChannels;
+
+  talk_base::scoped_ptr<ViEWrapper> vie_wrapper_;
+  webrtc::VideoCaptureModule* capture_module_;
+  bool external_capture_;
+  int capture_id_;
+  talk_base::scoped_ptr<webrtc::VideoRender> render_module_;
+  WebRtcVoiceEngine* voice_engine_;
+  std::vector<VideoCodec> video_codecs_;
+  VideoChannels channels_;
+  int log_level_;
+  VideoEncoderConfig default_encoder_config_;
+  bool capture_started_;
+  talk_base::scoped_ptr<WebRtcRenderAdapter> local_renderer_;
+};
+
+class WebRtcVideoMediaChannel : public VideoMediaChannel,
+                                public webrtc::Transport {
+ public:
+  WebRtcVideoMediaChannel(
+      WebRtcVideoEngine* engine, VoiceMediaChannel* voice_channel);
+  ~WebRtcVideoMediaChannel();
+
+  bool Init();
+  virtual bool SetRecvCodecs(const std::vector<VideoCodec> &codecs);
+  virtual bool SetSendCodecs(const std::vector<VideoCodec> &codecs);
+  virtual bool SetRender(bool render);
+  virtual bool SetSend(bool send);
+  virtual bool AddStream(uint32 ssrc, uint32 voice_ssrc);
+  virtual bool RemoveStream(uint32 ssrc);
+  virtual bool SetRenderer(uint32 ssrc, VideoRenderer* renderer);
+  virtual bool GetStats(VideoMediaInfo* info);
+  virtual bool SendIntraFrame();
+  virtual bool RequestIntraFrame();
+
+  virtual void OnPacketReceived(talk_base::Buffer* packet);
+  virtual void OnRtcpReceived(talk_base::Buffer* packet);
+  virtual void SetSendSsrc(uint32 id);
+  virtual bool SetRtcpCName(const std::string& cname);
+  virtual bool Mute(bool on);
+  virtual bool SetRecvRtpHeaderExtensions(
+      const std::vector<RtpHeaderExtension>& extensions) {
+    return false;
+  }
+  virtual bool SetSendRtpHeaderExtensions(
+      const std::vector<RtpHeaderExtension>& extensions) {
+    return false;
+  }
+  virtual bool SetSendBandwidth(bool autobw, int bps);
+  virtual bool SetOptions(int options);
+
+  WebRtcVideoEngine* engine() const { return engine_; }
+  VoiceMediaChannel* voice_channel() const { return voice_channel_; }
+  int video_channel() const { return vie_channel_; }
+  bool sending() const { return sending_; }
+  void set_connected(bool connected) { connected_ = connected; }
+  bool connected() const { return connected_; }
+
+ protected:
+  int GetLastEngineError() { return engine()->GetLastEngineError(); }
+  virtual int SendPacket(int channel, const void* data, int len);
+  virtual int SendRTCPPacket(int channel, const void* data, int len);
+
+ private:
+  void EnableRtcp();
+  void EnablePLI();
+  void EnableTMMBR();
+
+  WebRtcVideoEngine* engine_;
+  VoiceMediaChannel* voice_channel_;
+  int vie_channel_;
+  bool sending_;
+  // connected to the capture device or not.
+  bool connected_;
+  bool render_started_;
+  talk_base::scoped_ptr<webrtc::VideoCodec> send_codec_;
+  talk_base::scoped_ptr<WebRtcRenderAdapter> remote_renderer_;
+};
+}  // namespace cricket
+
+#endif  // TALK_SESSION_PHONE_WEBRTCVIDEOENGINE_H_
diff --git a/talk/session/phone/webrtcvideoengine_unittest.cc b/talk/session/phone/webrtcvideoengine_unittest.cc
new file mode 100644
index 0000000..8e985d7
--- /dev/null
+++ b/talk/session/phone/webrtcvideoengine_unittest.cc
@@ -0,0 +1,183 @@
+// Copyright 2008 Google Inc. All Rights Reserved.
+//
+// Author: Ronghua Wu (ronghuawu@google.com)
+//         Zhurun Zhang (zhurunz@google.com)
+
+#include "talk/base/byteorder.h"
+#include "talk/base/gunit.h"
+#include "talk/session/phone/channel.h"
+#include "talk/session/phone/fakemediaengine.h"
+#include "talk/session/phone/fakertp.h"
+#include "talk/session/phone/fakesession.h"
+#include "talk/session/phone/fakewebrtcvideoengine.h"
+#include "talk/session/phone/fakewebrtcvoiceengine.h"
+#include "talk/session/phone/webrtcvideoengine.h"
+#include "talk/session/phone/webrtcvoiceengine.h"
+
+// Tests for the WebRtcVideoEngine/VideoChannel code.
+
+static const cricket::VideoCodec kVP8Codec(104, "VP8", 320, 200, 30, 0);
+static const cricket::VideoCodec* const kVideoCodecs[] = {
+    &kVP8Codec,
+};
+
+class FakeViEWrapper : public cricket::ViEWrapper {
+ public:
+  explicit FakeViEWrapper(cricket::FakeWebRtcVideoEngine* engine)
+      : cricket::ViEWrapper(engine, engine, engine, engine,
+                            engine, engine, engine) {
+  }
+};
+
+class WebRtcVideoEngineTest : public testing::Test {
+ public:
+  class ChannelErrorListener : public sigslot::has_slots<> {
+   public:
+    explicit ChannelErrorListener(cricket::WebRtcVideoMediaChannel* channel)
+        : ssrc_(0), error_(cricket::WebRtcVideoMediaChannel::ERROR_NONE) {
+      ASSERT(channel != NULL);
+      channel->SignalMediaError.connect(
+          this, &ChannelErrorListener::OnVideoChannelError);
+    }
+    void OnVideoChannelError(uint32 ssrc,
+                             cricket::WebRtcVideoMediaChannel::Error error) {
+      ssrc_ = ssrc;
+      error_ = error;
+    }
+    void Reset() {
+      ssrc_ = 0;
+      error_ = cricket::WebRtcVideoMediaChannel::ERROR_NONE;
+    }
+    uint32 ssrc() const {
+      return ssrc_;
+    }
+    cricket::WebRtcVideoMediaChannel::Error error() const {
+      return error_;
+    }
+
+   private:
+    uint32 ssrc_;
+    cricket::WebRtcVideoMediaChannel::Error error_;
+  };
+
+  WebRtcVideoEngineTest()
+      : vie_(kVideoCodecs, ARRAY_SIZE(kVideoCodecs)),
+        engine_(NULL,  // cricket::WebRtcVoiceEngine
+                new FakeViEWrapper(&vie_)),
+        channel_(NULL),
+        voice_channel_(NULL) {
+  }
+  bool SetupEngine() {
+    bool result = engine_.Init();
+    if (result) {
+      channel_ = engine_.CreateChannel(voice_channel_);
+      result = (channel_ != NULL);
+    }
+    return result;
+  }
+  void DeliverPacket(const void* data, int len) {
+    talk_base::Buffer packet(data, len);
+    channel_->OnPacketReceived(&packet);
+  }
+  virtual void TearDown() {
+    delete channel_;
+    engine_.Terminate();
+  }
+
+ protected:
+  cricket::FakeWebRtcVideoEngine vie_;
+  cricket::WebRtcVideoEngine engine_;
+  cricket::WebRtcVideoMediaChannel* channel_;
+  cricket::WebRtcVoiceMediaChannel* voice_channel_;
+};
+
+// Tests that our stub library "works".
+TEST_F(WebRtcVideoEngineTest, StartupShutdown) {
+  EXPECT_FALSE(vie_.IsInited());
+  EXPECT_TRUE(engine_.Init());
+  EXPECT_TRUE(vie_.IsInited());
+  engine_.Terminate();
+  // TODO: what to expect after Terminate
+  // EXPECT_FALSE(vie_.IsInited());
+}
+
+// Tests that we can create and destroy a channel.
+TEST_F(WebRtcVideoEngineTest, CreateChannel) {
+  EXPECT_TRUE(engine_.Init());
+  channel_ = engine_.CreateChannel(voice_channel_);
+  EXPECT_TRUE(channel_ != NULL);
+}
+
+// Tests that we properly handle failures in CreateChannel.
+TEST_F(WebRtcVideoEngineTest, CreateChannelFail) {
+  vie_.set_fail_create_channel(true);
+  EXPECT_TRUE(engine_.Init());
+  channel_ = engine_.CreateChannel(voice_channel_);
+  EXPECT_TRUE(channel_ == NULL);
+}
+
+// Tests that we can find codecs by name or id
+TEST_F(WebRtcVideoEngineTest, FindCodec) {
+  // We should not need to init engine in order to get codecs.
+  const std::vector<cricket::VideoCodec>& c = engine_.codecs();
+  EXPECT_EQ(1U, c.size());
+
+  cricket::VideoCodec vp8(104, "VP8", 320, 200, 30, 0);
+  EXPECT_TRUE(engine_.FindCodec(vp8));
+
+  cricket::VideoCodec vp8_diff_fr_diff_pref(104, "VP8", 320, 200, 50, 50);
+  EXPECT_TRUE(engine_.FindCodec(vp8_diff_fr_diff_pref));
+
+  cricket::VideoCodec vp8_diff_id(95, "VP8", 320, 200, 30, 0);
+  EXPECT_FALSE(engine_.FindCodec(vp8_diff_id));
+  vp8_diff_id.id = 97;
+  EXPECT_TRUE(engine_.FindCodec(vp8_diff_id));
+
+  cricket::VideoCodec vp8_diff_res(104, "VP8", 320, 111, 30, 0);
+  EXPECT_FALSE(engine_.FindCodec(vp8_diff_res));
+}
+
+// Test that we set our inbound codecs properly
+TEST_F(WebRtcVideoEngineTest, SetRecvCodecs) {
+  EXPECT_TRUE(SetupEngine());
+  std::vector<cricket::VideoCodec> codecs;
+  codecs.push_back(kVP8Codec);
+  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+}
+
+// Test that we apply codecs properly.
+TEST_F(WebRtcVideoEngineTest, SetSendCodecs) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = vie_.GetLastChannel();
+  std::vector<cricket::VideoCodec> codecs;
+  codecs.push_back(kVP8Codec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::VideoCodec gcodec;
+  EXPECT_EQ(0, vie_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(kVP8Codec.id, gcodec.plType);
+  EXPECT_EQ(kVP8Codec.width, gcodec.width);
+  EXPECT_EQ(kVP8Codec.height, gcodec.height);
+  EXPECT_STREQ(kVP8Codec.name.c_str(), gcodec.plName);
+}
+
+// TODO: add tests for below interfaces
+// bool SetOptions(int options);
+// bool SetCaptureDevice(const Device* device);
+// bool SetLocalRenderer(VideoRenderer* renderer);
+// CaptureResult SetCapture(bool capture);
+// virtual bool SetRender(bool render);
+// virtual bool SetSend(bool send);
+// virtual bool AddStream(uint32 ssrc, uint32 voice_ssrc);
+// virtual bool RemoveStream(uint32 ssrc);
+// virtual bool SetRenderer(uint32 ssrc, VideoRenderer* renderer);
+// virtual bool GetStats(VideoMediaInfo* info);
+// virtual bool SendIntraFrame();
+// virtual bool RequestIntraFrame();
+// virtual void OnPacketReceived(talk_base::Buffer* packet);
+// virtual void OnRtcpReceived(talk_base::Buffer* packet);
+// virtual void SetSendSsrc(uint32 id);
+// virtual bool SetRtcpCName(const std::string& cname);
+// virtual bool Mute(bool on);
+// virtual bool SetSendBandwidth(bool autobw, int bps);
+// virtual bool SetOptions(int options);
+
diff --git a/talk/session/phone/webrtcvideoframe.cc b/talk/session/phone/webrtcvideoframe.cc
new file mode 100644
index 0000000..c2a3470
--- /dev/null
+++ b/talk/session/phone/webrtcvideoframe.cc
@@ -0,0 +1,244 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "talk/session/phone/webrtcvideoframe.h"
+
+#include "talk/base/logging.h"
+#include "talk/session/phone/videocommon.h"
+#ifdef WEBRTC_RELATIVE_PATH
+#include "common_video/vplib/main/interface/vplib.h"
+#else
+#include "third_party/webrtc/files/include/vplib.h"
+#endif
+
+namespace cricket {
+WebRtcVideoFrame::WebRtcVideoFrame() {
+}
+
+WebRtcVideoFrame::~WebRtcVideoFrame() {
+}
+
+void WebRtcVideoFrame::Attach(uint8* buffer, size_t buffer_size, size_t w,
+                              size_t h, int64 elapsed_time, int64 time_stamp) {
+  video_frame_.Free();
+  WebRtc_UWord8* new_memory = buffer;
+  WebRtc_UWord32 new_length = buffer_size;
+  WebRtc_UWord32 new_size = buffer_size;
+  video_frame_.Swap(new_memory, new_length, new_size);
+  video_frame_.SetWidth(w);
+  video_frame_.SetHeight(h);
+  elapsed_time_ = elapsed_time;
+  video_frame_.SetTimeStamp(static_cast<WebRtc_UWord32>(time_stamp));
+}
+
+void WebRtcVideoFrame::Detach(uint8** buffer, size_t* buffer_size) {
+  WebRtc_UWord8* new_memory = NULL;
+  WebRtc_UWord32 new_length = 0;
+  WebRtc_UWord32 new_size = 0;
+  video_frame_.Swap(new_memory, new_length, new_size);
+  *buffer = new_memory;
+  *buffer_size = new_size;
+}
+
+bool WebRtcVideoFrame::InitToBlack(size_t w, size_t h,
+                                   int64 elapsed_time, int64 time_stamp) {
+  size_t buffer_size = w * h * 3 / 2;
+  uint8* buffer = new uint8[buffer_size];
+  Attach(buffer, buffer_size, w, h, elapsed_time, time_stamp);
+  memset(GetYPlane(), 16, w * h);
+  memset(GetUPlane(), 128, w * h / 4);
+  memset(GetVPlane(), 128, w * h / 4);
+  return true;
+}
+
+size_t WebRtcVideoFrame::GetWidth() const {
+  return video_frame_.Width();
+}
+
+size_t WebRtcVideoFrame::GetHeight() const {
+  return video_frame_.Height();
+}
+
+const uint8* WebRtcVideoFrame::GetYPlane() const {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  return buffer;
+}
+
+const uint8* WebRtcVideoFrame::GetUPlane() const {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  if (buffer)
+    buffer += (video_frame_.Width() * video_frame_.Height());
+  return buffer;
+}
+
+const uint8* WebRtcVideoFrame::GetVPlane() const {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  if (buffer)
+    buffer += (video_frame_.Width() * video_frame_.Height() * 5 / 4);
+  return buffer;
+}
+
+uint8* WebRtcVideoFrame::GetYPlane() {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  return buffer;
+}
+
+uint8* WebRtcVideoFrame::GetUPlane() {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  if (buffer)
+    buffer += (video_frame_.Width() * video_frame_.Height());
+  return buffer;
+}
+
+uint8* WebRtcVideoFrame::GetVPlane() {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  if (buffer)
+    buffer += (video_frame_.Width() * video_frame_.Height() * 5 / 4);
+  return buffer;
+}
+
+VideoFrame* WebRtcVideoFrame::Copy() const {
+  WebRtc_UWord8* buffer = video_frame_.Buffer();
+  if (!buffer)
+    return NULL;
+
+  size_t new_buffer_size = video_frame_.Length();
+  uint8* new_buffer = new uint8[new_buffer_size];
+  memcpy(new_buffer, buffer, new_buffer_size);
+  WebRtcVideoFrame* copy = new WebRtcVideoFrame();
+  copy->Attach(new_buffer, new_buffer_size,
+               video_frame_.Width(), video_frame_.Height(),
+               elapsed_time_, video_frame_.TimeStamp());
+  return copy;
+}
+
+bool WebRtcVideoFrame::MakeExclusive() {
+  // WebRtcVideoFrame::Copy makes a deep copy of the frame buffer.  No action
+  // is needed for MakeExclusive.
+  return true;
+}
+
+size_t WebRtcVideoFrame::CopyToBuffer(
+    uint8* buffer, size_t size) const {
+  if (!video_frame_.Buffer()) {
+    return 0;
+  }
+
+  size_t needed = video_frame_.Length();
+  if (needed <= size) {
+    memcpy(buffer, video_frame_.Buffer(), needed);
+  }
+  return needed;
+}
+
+size_t WebRtcVideoFrame::ConvertToRgbBuffer(uint32 to_fourcc,
+                                            uint8* buffer,
+                                            size_t size,
+                                            size_t pitch_rgb) const {
+  if (!video_frame_.Buffer()) {
+    return 0;
+  }
+
+  size_t width = video_frame_.Width();
+  size_t height = video_frame_.Height();
+  // See http://www.virtualdub.org/blog/pivot/entry.php?id=190 for a good
+  // explanation of pitch and why this is the amount of space we need.
+  size_t needed = pitch_rgb * (height - 1) + 4 * width;
+
+  if (needed > size) {
+    LOG(LS_WARNING) << "RGB buffer is not large enough";
+    return 0;
+  }
+
+  webrtc::VideoType outgoingVideoType = webrtc::kUnknown;
+  switch (to_fourcc) {
+    case FOURCC_ARGB:
+      outgoingVideoType = webrtc::kARGB;
+      break;
+    default:
+      LOG(LS_WARNING) << "RGB type not supported: " << to_fourcc;
+      return 0;
+      break;
+  }
+
+  if (outgoingVideoType != webrtc::kUnknown)
+    webrtc::ConvertFromI420(outgoingVideoType, video_frame_.Buffer(),
+                    width, height, buffer);
+
+  return needed;
+}
+
+void WebRtcVideoFrame::StretchToPlanes(
+    uint8* y, uint8* u, uint8* v,
+    int32 dst_pitch_y, int32 dst_pitch_u, int32 dst_pitch_v,
+    size_t width, size_t height, bool interpolate, bool crop) const {
+  // TODO: Implement StretchToPlanes
+}
+
+size_t WebRtcVideoFrame::StretchToBuffer(size_t w, size_t h,
+                                         uint8* buffer, size_t size,
+                                         bool interpolate,
+                                         bool crop) const {
+  if (!video_frame_.Buffer()) {
+    return 0;
+  }
+
+  size_t needed = video_frame_.Length();
+
+  if (needed <= size) {
+    uint8* bufy = buffer;
+    uint8* bufu = bufy + w * h;
+    uint8* bufv = bufu + ((w + 1) >> 1) * ((h + 1) >> 1);
+    StretchToPlanes(bufy, bufu, bufv, w, (w + 1) >> 1, (w + 1) >> 1, w, h,
+                    interpolate, crop);
+  }
+  return needed;
+}
+
+void WebRtcVideoFrame::StretchToFrame(VideoFrame* target,
+    bool interpolate, bool crop) const {
+  if (!target) return;
+
+  StretchToPlanes(target->GetYPlane(),
+                  target->GetUPlane(),
+                  target->GetVPlane(),
+                  target->GetYPitch(),
+                  target->GetUPitch(),
+                  target->GetVPitch(),
+                  target->GetWidth(),
+                  target->GetHeight(),
+                  interpolate, crop);
+  target->SetElapsedTime(GetElapsedTime());
+  target->SetTimeStamp(GetTimeStamp());
+}
+
+VideoFrame* WebRtcVideoFrame::Stretch(size_t w, size_t h,
+    bool interpolate, bool crop) const {
+  // TODO: implement
+  return NULL;
+}
+}  // namespace cricket
diff --git a/talk/session/phone/webrtcvideoframe.h b/talk/session/phone/webrtcvideoframe.h
new file mode 100644
index 0000000..6538fbc
--- /dev/null
+++ b/talk/session/phone/webrtcvideoframe.h
@@ -0,0 +1,98 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_SESSION_PHONE_WEBRTCVIDEOFRAME_H_
+#define TALK_SESSION_PHONE_WEBRTCVIDEOFRAME_H_
+
+#ifdef WEBRTC_RELATIVE_PATH
+#include "common_types.h"
+#include "modules/interface/module_common_types.h"
+#else
+#include "third_party/webrtc/files/include/common_types.h"
+#include "third_party/webrtc/files/include/module_common_types.h"
+#endif
+#include "talk/session/phone/videoframe.h"
+
+namespace cricket {
+// WebRtcVideoFrame only supports I420
+class WebRtcVideoFrame : public VideoFrame {
+ public:
+  WebRtcVideoFrame();
+  ~WebRtcVideoFrame();
+
+  void Attach(uint8* buffer, size_t buffer_size,
+              size_t w, size_t h, int64 elapsed_time, int64 time_stamp);
+  void Detach(uint8** buffer, size_t* buffer_size);
+  bool InitToBlack(size_t w, size_t h, int64 elapsed_time, int64 time_stamp);
+  bool HasImage() const { return video_frame_.Buffer() != NULL; }
+
+  virtual size_t GetWidth() const;
+  virtual size_t GetHeight() const;
+  virtual const uint8* GetYPlane() const;
+  virtual const uint8* GetUPlane() const;
+  virtual const uint8* GetVPlane() const;
+  virtual uint8* GetYPlane();
+  virtual uint8* GetUPlane();
+  virtual uint8* GetVPlane();
+  virtual int32 GetYPitch() const { return video_frame_.Width(); }
+  virtual int32 GetUPitch() const { return video_frame_.Width() / 2; }
+  virtual int32 GetVPitch() const { return video_frame_.Width() / 2; }
+
+  virtual size_t GetPixelWidth() const { return 1; }
+  virtual size_t GetPixelHeight() const { return 1; }
+  virtual int64 GetElapsedTime() const { return elapsed_time_; }
+  virtual int64 GetTimeStamp() const { return video_frame_.TimeStamp(); }
+  virtual void SetElapsedTime(int64 elapsed_time) {
+    elapsed_time_ = elapsed_time;
+  }
+  virtual void SetTimeStamp(int64 time_stamp) {
+    video_frame_.SetTimeStamp(static_cast<WebRtc_UWord32>(time_stamp));
+  }
+
+  virtual VideoFrame* Copy() const;
+  virtual bool MakeExclusive();
+  virtual size_t CopyToBuffer(uint8* buffer, size_t size) const;
+  virtual size_t ConvertToRgbBuffer(uint32 to_fourcc, uint8* buffer,
+                                    size_t size, size_t pitch_rgb) const;
+  virtual void StretchToPlanes(uint8* y, uint8* u, uint8* v,
+                               int32 pitchY, int32 pitchU, int32 pitchV,
+                               size_t width, size_t height,
+                               bool interpolate, bool crop) const;
+  virtual size_t StretchToBuffer(size_t w, size_t h, uint8* buffer, size_t size,
+                                 bool interpolate, bool crop) const;
+  virtual void StretchToFrame(VideoFrame* target, bool interpolate,
+                              bool crop) const;
+  virtual VideoFrame* Stretch(size_t w, size_t h, bool interpolate,
+                              bool crop) const;
+
+ private:
+  webrtc::VideoFrame video_frame_;
+  int64 elapsed_time_;
+};
+}  // namespace cricket
+
+#endif  // TALK_SESSION_PHONE_WEBRTCVIDEOFRAME_H_
diff --git a/talk/session/phone/webrtcvideoframe_unittest.cc b/talk/session/phone/webrtcvideoframe_unittest.cc
new file mode 100644
index 0000000..4bd9244
--- /dev/null
+++ b/talk/session/phone/webrtcvideoframe_unittest.cc
@@ -0,0 +1,443 @@
+// Copyright 2008 Google Inc. All Rights Reserved,
+//
+// Author: Justin Uberti (juberti@google.com)
+//         Frank Barchard (fbarchard@google.com)
+#include <string>
+
+#include "talk/base/flags.h"
+#include "talk/base/gunit.h"
+#include "talk/base/pathutils.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/stream.h"
+#include "talk/base/stringutils.h"
+#include "talk/session/phone/formatconversion.h"
+#include "talk/session/phone/webrtcvideoframe.h"
+#include "talk/session/phone/testutils.h"
+#include "talk/session/phone/videocommon.h"
+
+enum {
+  ROTATION_0 = 0,
+  ROTATION_90 = 90,
+  ROTATION_180 = 180,
+  ROTATION_270 = 270
+};
+
+using cricket::WebRtcVideoFrame;
+using cricket::FOURCC_I420;
+
+static const int kWidth = 1280;
+static const int kHeight = 720;
+static const int kAlignment = 16;
+static const std::string kImageFilename = "faces.1280x720_P420.yuv";
+
+DEFINE_int(yuvconverter_repeat, 1,
+    "how many times to perform each conversion operation (for perf testing)");
+
+class WebRtcVideoFrameTest : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    repeat_ = FLAG_yuvconverter_repeat;
+  }
+
+ public:
+  // Load a video frame from disk or a buffer.
+  bool LoadFrame(const std::string& filename, uint32 format,
+                 int32 width, int32 height, WebRtcVideoFrame* frame,
+                 int rotation) {
+    talk_base::scoped_ptr<talk_base::MemoryStream> ms(LoadSample(filename));
+    return LoadFrame(ms.get(), format, width, height, frame, rotation);
+  }
+
+  bool LoadFrame(talk_base::MemoryStream* ms, uint32 format,
+                 int32 width, int32 height, WebRtcVideoFrame* frame,
+                 int rotation) {
+    if (!ms) {
+      return false;
+    }
+    size_t data_size;
+    bool ret = ms->GetSize(&data_size);
+    EXPECT_TRUE(ret);
+    if (ret) {
+      ret = LoadFrame(reinterpret_cast<uint8*>(ms->GetBuffer()), data_size,
+                      format, width, height, frame, rotation);
+    }
+    return ret;
+  }
+
+  bool LoadFrame(uint8* sample, size_t sample_size, uint32 format,
+                 int32 width, int32 height, WebRtcVideoFrame* frame,
+                 int rotation) {
+    // WebRtcVideoFrame only supporst I420 for now
+    if (format != FOURCC_I420)
+      return false;
+    for (int i = 0; i < repeat_; ++i) {
+      uint8* new_buffer = new uint8[sample_size];
+      memcpy(new_buffer, sample, sample_size);
+      frame->Attach(new_buffer, sample_size, width, height, 0, 0);
+    }
+    return true;
+  }
+
+  talk_base::MemoryStream* LoadSample(const std::string& filename) {
+    talk_base::Pathname path(cricket::GetTestFilePath(filename));
+    talk_base::scoped_ptr<talk_base::FileStream> fs(
+        talk_base::Filesystem::OpenFile(path, "rb"));
+    if (!fs.get()) {
+      return NULL;
+    }
+
+    char buf[4096];
+    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+        new talk_base::MemoryStream());
+    talk_base::StreamResult res = Flow(fs.get(), buf, sizeof(buf), ms.get());
+    if (res != talk_base::SR_SUCCESS) {
+      return NULL;
+    }
+
+    return ms.release();
+  }
+
+  // Write an I420 frame out to disk.
+  bool DumpFrame(const std::string& prefix,
+                 const WebRtcVideoFrame& frame) {
+    char filename[256];
+    talk_base::sprintfn(filename, sizeof(filename), "%s.%dx%d_P420.yuv",
+                        prefix.c_str(), frame.GetWidth(), frame.GetHeight());
+    size_t out_size = cricket::VideoFrame::SizeOf(frame.GetWidth(),
+                                                  frame.GetHeight());
+    talk_base::scoped_array<uint8> out(new uint8[out_size]);
+    frame.CopyToBuffer(out.get(), out_size);
+    return DumpSample(filename, out.get(), out_size);
+  }
+
+  bool DumpSample(const std::string& filename, const void* buffer, int size) {
+    talk_base::Pathname path(filename);
+    talk_base::scoped_ptr<talk_base::FileStream> fs(
+        talk_base::Filesystem::OpenFile(path, "wb"));
+    if (!fs.get()) {
+      return false;
+    }
+
+    return (fs->Write(buffer, size, NULL, NULL) == talk_base::SR_SUCCESS);
+  }
+
+  // Create a test image for YUV 420 formats with 12 bits per pixel.
+  talk_base::MemoryStream* CreateYuv420Sample(uint32 width, uint32 height) {
+    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+        new talk_base::MemoryStream);
+    if (!ms->ReserveSize(width * height * 12 / 8)) {
+      return NULL;
+    }
+
+    for (uint32 i = 0; i < width * height * 12 / 8; ++i) {
+      char value = ((i / 63) & 1) ? 192 : 64;
+      ms->Write(&value, sizeof(value), NULL, NULL);
+    }
+    return ms.release();
+  }
+
+  talk_base::MemoryStream* CreateRgbSample(uint32 fourcc,
+                                           uint32 width, uint32 height) {
+    int r_pos, g_pos, b_pos, bytes;
+    if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
+      return NULL;
+    }
+
+    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+        new talk_base::MemoryStream);
+    if (!ms->ReserveSize(width * height * bytes)) {
+      return NULL;
+    }
+
+    for (uint32 y = 0; y < height; ++y) {
+      for (uint32 x = 0; x < width; ++x) {
+        uint8 rgb[4] = { 255, 255, 255, 255 };
+        rgb[r_pos] = ((x / 63) & 1) ? 224 : 32;
+        rgb[g_pos] = (x % 63 + y % 63) + 96;
+        rgb[b_pos] = ((y / 63) & 1) ? 224 : 32;
+        ms->Write(rgb, bytes, NULL, NULL);
+      }
+    }
+    return ms.release();
+  }
+
+  // Convert RGB to 420.
+  // A negative height inverts the image.
+  bool ConvertRgb(const talk_base::MemoryStream* ms,
+                  uint32 fourcc, int32 width, int32 height,
+                  WebRtcVideoFrame* frame) {
+    int r_pos, g_pos, b_pos, bytes;
+    if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
+      return false;
+    }
+    int stride = width * bytes;
+    const uint8* start = reinterpret_cast<const uint8*>(ms->GetBuffer());
+    if (height < 0) {
+      height = -height;
+      start = start + stride * (height - 1);
+      stride = -stride;
+    }
+    frame->InitToBlack(width, height, 0, 0);
+    for (int32 y = 0; y < height; y += 2) {
+      for (int32 x = 0; x < width; x += 2) {
+        const uint8* rgb[4];
+        uint8 yuv[4][3];
+        rgb[0] = start + y * stride + x * bytes;
+        rgb[1] = rgb[0] + bytes;
+        rgb[2] = rgb[0] + stride;
+        rgb[3] = rgb[2] + bytes;
+        for (size_t i = 0; i < 4; ++i) {
+          ConvertRgbPixel(rgb[i][r_pos], rgb[i][g_pos], rgb[i][b_pos],
+                          &yuv[i][0], &yuv[i][1], &yuv[i][2]);
+        }
+        frame->GetYPlane()[width * y + x] = yuv[0][0];
+        frame->GetYPlane()[width * y + x + 1] = yuv[1][0];
+        frame->GetYPlane()[width * (y + 1) + x] = yuv[2][0];
+        frame->GetYPlane()[width * (y + 1) + x + 1] = yuv[3][0];
+        frame->GetUPlane()[width / 2 * (y / 2) + x / 2] =
+            (yuv[0][1] + yuv[1][1] + yuv[2][1] + yuv[3][1] + 2) / 4;
+        frame->GetVPlane()[width / 2 * (y / 2) + x / 2] =
+            (yuv[0][2] + yuv[1][2] + yuv[2][2] + yuv[3][2] + 2) / 4;
+      }
+    }
+    return true;
+  }
+
+  // Simple and slow RGB->YUV conversion. From NTSC standard, c/o Wikipedia.
+  void ConvertRgbPixel(uint8 r, uint8 g, uint8 b,
+                       uint8* y, uint8* u, uint8* v) {
+    *y = static_cast<int>(.257 * r + .504 * g + .098 * b) + 16;
+    *u = static_cast<int>(-.148 * r - .291 * g + .439 * b) + 128;
+    *v = static_cast<int>(.439 * r - .368 * g - .071 * b) + 128;
+  }
+
+  bool GetRgbPacking(uint32 fourcc,
+                     int* r_pos, int* g_pos, int* b_pos, int* bytes) {
+    if (fourcc == cricket::FOURCC_RAW) {
+      *r_pos = 0;
+      *g_pos = 1;
+      *b_pos = 2;
+      *bytes = 3;  // RGB in memory
+    } else if (fourcc == cricket::FOURCC_24BG) {
+      *r_pos = 2;
+      *g_pos = 1;
+      *b_pos = 0;
+      *bytes = 3;  // BGR in memory
+    } else if (fourcc == cricket::FOURCC_ABGR) {
+      *r_pos = 0;
+      *g_pos = 1;
+      *b_pos = 2;
+      *bytes = 4;  // RGBA in memory
+    } else if (fourcc == cricket::FOURCC_BGRA) {
+      *r_pos = 1;
+      *g_pos = 2;
+      *b_pos = 3;
+      *bytes = 4;  // ARGB in memory
+    } else if (fourcc == cricket::FOURCC_ARGB) {
+      *r_pos = 2;
+      *g_pos = 1;
+      *b_pos = 0;
+      *bytes = 4;  // BGRA in memory
+    } else {
+      return false;
+    }
+    return true;
+  }
+
+  // Comparison functions for testing.
+  static bool IsNull(const WebRtcVideoFrame& frame) {
+    return !frame.HasImage();
+  }
+
+  static bool IsSize(const WebRtcVideoFrame& frame,
+                     uint32 width, uint32 height) {
+    return frame.HasImage() &&
+        frame.GetYPitch() >= static_cast<int32>(width) &&
+        frame.GetUPitch() >= static_cast<int32>(width) / 2 &&
+        frame.GetVPitch() >= static_cast<int32>(width) / 2 &&
+        frame.GetWidth() == width && frame.GetHeight() == height;
+  }
+
+  static bool IsPlaneEqual(const std::string& name,
+                           const uint8* plane1, uint32 pitch1,
+                           const uint8* plane2, uint32 pitch2,
+                           uint32 width, uint32 height,
+                           int max_error) {
+    const uint8* r1 = plane1;
+    const uint8* r2 = plane2;
+    for (uint32 y = 0; y < height; ++y) {
+      for (uint32 x = 0; x < width; ++x) {
+        if (abs(static_cast<int>(r1[x] - r2[x])) > max_error) {
+          LOG(LS_INFO) << "IsPlaneEqual(" << name << "): pixel["
+                       << x << "," << y << "] differs: "
+                       << static_cast<int>(r1[x]) << " vs "
+                       << static_cast<int>(r2[x]);
+          return false;
+        }
+      }
+      r1 += pitch1;
+      r2 += pitch2;
+    }
+    return true;
+  }
+
+  static bool IsFrameContiguous(const WebRtcVideoFrame& frame) {
+    int width = frame.GetWidth();
+    int height = frame.GetHeight();
+    const uint8* y = frame.GetYPlane();
+    const uint8* u = frame.GetUPlane();
+    const uint8* v = frame.GetVPlane();
+    int size = width * height * 3 / 2;
+    bool u_near = (u - y) < size;
+    bool v_near = (v - y) < size;
+    return u_near && v_near;
+  }
+
+  static bool IsEqual(const WebRtcVideoFrame& frame,
+                      size_t width, size_t height,
+                      size_t pixel_width, size_t pixel_height,
+                      int64 elapsed_time, int64 time_stamp,
+                      const uint8* y, uint32 ypitch,
+                      const uint8* u, uint32 upitch,
+                      const uint8* v, uint32 vpitch,
+                      int max_error) {
+    if (!IsFrameContiguous(frame)) {
+      LOG(LS_INFO) << "lmi frame is not contiguous";
+    }
+    return IsSize(frame, width, height) &&
+        frame.GetPixelWidth() == pixel_width &&
+        frame.GetPixelHeight() == pixel_height &&
+        frame.GetElapsedTime() == elapsed_time &&
+        frame.GetTimeStamp() == time_stamp &&
+        IsPlaneEqual("y", frame.GetYPlane(), frame.GetYPitch(), y, ypitch,
+                     width, height, max_error) &&
+        IsPlaneEqual("u", frame.GetUPlane(), frame.GetUPitch(), u, upitch,
+                     width / 2, height / 2, max_error) &&
+        IsPlaneEqual("v", frame.GetVPlane(), frame.GetVPitch(), v, vpitch,
+                     width / 2, height / 2, max_error);
+  }
+
+  static bool IsEqual(const WebRtcVideoFrame& frame1,
+                      const WebRtcVideoFrame& frame2,
+                      int max_error) {
+    return IsEqual(frame1, frame2.GetWidth(), frame2.GetHeight(),
+                frame2.GetPixelWidth(), frame2.GetPixelHeight(),
+                frame2.GetElapsedTime(), frame2.GetTimeStamp(),
+                frame2.GetYPlane(), frame2.GetYPitch(),
+                frame2.GetUPlane(), frame2.GetUPitch(),
+                frame2.GetVPlane(), frame2.GetVPitch(),
+                max_error);
+  }
+
+ protected:
+  int repeat_;
+};
+
+TEST_F(WebRtcVideoFrameTest, ConvertToARGBBuffer) {
+  size_t out_size = kWidth * kHeight * 4;
+  talk_base::scoped_array<uint8> outbuf(new uint8[out_size + kAlignment]);
+  uint8 *out = ALIGNP(outbuf.get(), kAlignment);
+  WebRtcVideoFrame frame;
+  ASSERT_TRUE(LoadFrame(kImageFilename, FOURCC_I420, kWidth, kHeight,
+                        &frame, ROTATION_0));
+
+  // TODO: Add test to convert these back to I420, to ensure the
+  // conversion is done correctly.
+  for (int i = 0; i < repeat_; ++i) {
+    EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB,
+                                                 out,
+                                                 out_size, kWidth * 4));
+  }
+}
+
+// Test basic contruction of an image from an I420 buffer.
+TEST_F(WebRtcVideoFrameTest, InitI420) {
+  WebRtcVideoFrame frame;
+  EXPECT_TRUE(IsNull(frame));
+  talk_base::scoped_ptr<talk_base::MemoryStream> ms(LoadSample(kImageFilename));
+  ASSERT_TRUE(ms.get() != NULL);
+  size_t data_size;
+  ASSERT_TRUE(ms->GetSize(&data_size));
+  uint8* buf = reinterpret_cast<uint8*>(ms->GetBuffer());
+  EXPECT_TRUE(LoadFrame(buf, data_size, FOURCC_I420,
+                        kWidth, kHeight, &frame, ROTATION_0));
+
+  const uint8* y = reinterpret_cast<uint8*>(ms->GetBuffer());
+  const uint8* u = y + kWidth * kHeight;
+  const uint8* v = u + kWidth * kHeight / 4;
+  EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 1, 1, 0, 0,
+                      y, kWidth, u, kWidth / 2, v, kWidth / 2, 0));
+}
+
+// Test constructing an image from a I420 buffer
+TEST_F(WebRtcVideoFrameTest, ConstructI420) {
+  WebRtcVideoFrame frame;
+  talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+      CreateYuv420Sample(kWidth, kHeight));
+  EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420,
+                        kWidth, kHeight, &frame, ROTATION_0));
+
+  const uint8* y = reinterpret_cast<uint8*>(ms.get()->GetBuffer());
+  const uint8* u = y + kWidth * kHeight;
+  const uint8* v = u + kWidth * kHeight / 4;
+  EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 1, 1, 0, 0,
+                      y, kWidth, u, kWidth / 2, v, kWidth / 2, 0));
+}
+
+// Test creating an empty image and initing it to black.
+TEST_F(WebRtcVideoFrameTest, ConstructBlack) {
+  WebRtcVideoFrame frame;
+  for (int i = 0; i < repeat_; ++i) {
+    EXPECT_TRUE(frame.InitToBlack(kWidth, kHeight, 0, 0));
+  }
+  EXPECT_TRUE(IsSize(frame, kWidth, kHeight));
+  EXPECT_EQ(16, *frame.GetYPlane());
+  EXPECT_EQ(128, *frame.GetUPlane());
+  EXPECT_EQ(128, *frame.GetVPlane());
+}
+
+TEST_F(WebRtcVideoFrameTest, Copy) {
+  WebRtcVideoFrame frame1;
+  talk_base::scoped_ptr<cricket::WebRtcVideoFrame> frame2;
+  ASSERT_TRUE(LoadFrame(kImageFilename, FOURCC_I420, kWidth, kHeight,
+                        &frame1, ROTATION_0));
+  frame2.reset(static_cast<WebRtcVideoFrame*>(frame1.Copy()));
+  EXPECT_TRUE(IsEqual(frame1, *frame2.get(), 0));
+}
+
+TEST_F(WebRtcVideoFrameTest, CopyToBuffer) {
+  size_t out_size = kWidth * kHeight * 3 / 2;
+  talk_base::scoped_array<uint8> out(new uint8[out_size]);
+  WebRtcVideoFrame frame;
+  talk_base::scoped_ptr<talk_base::MemoryStream> ms(LoadSample(kImageFilename));
+  ASSERT_TRUE(ms.get() != NULL);
+  size_t data_size;
+  ASSERT_TRUE(ms->GetSize(&data_size));
+  EXPECT_TRUE(LoadFrame(reinterpret_cast<uint8*>(ms->GetBuffer()),
+                        data_size, FOURCC_I420,
+                        kWidth, kHeight, &frame, ROTATION_0));
+  for (int i = 0; i < repeat_; ++i) {
+    EXPECT_EQ(out_size, frame.CopyToBuffer(out.get(), out_size));
+  }
+  EXPECT_EQ(0, memcmp(out.get(), ms->GetBuffer(), out_size));
+}
+
+TEST_F(WebRtcVideoFrameTest, CopyToBuffer1Pixel) {
+  size_t out_size = 3;
+  talk_base::scoped_array<uint8> out(new uint8[out_size + 1]);
+  memset(out.get(), 0xfb, out_size + 1);  // Fill buffer
+  uint8 pixel[3] = { 1, 2, 3 };
+  WebRtcVideoFrame frame;
+  EXPECT_TRUE(LoadFrame(pixel, sizeof(pixel), FOURCC_I420,
+                        1, 1, &frame, ROTATION_0));
+  for (int i = 0; i < repeat_; ++i) {
+    EXPECT_EQ(out_size, frame.CopyToBuffer(out.get(), out_size));
+  }
+  EXPECT_EQ(1, out.get()[0]);  // Check Y.  Should be 1.
+  EXPECT_EQ(2, out.get()[1]);  // Check U.  Should be 2.
+  EXPECT_EQ(3, out.get()[2]);  // Check V.  Should be 3.
+  EXPECT_EQ(0xfb, out.get()[3]);  // Check sentinel is still intact.
+}
+
+// TODO: Merge this with the LmiVideoFrame test for more test cases
+// when they are supported.
diff --git a/talk/session/phone/webrtcvie.h b/talk/session/phone/webrtcvie.h
new file mode 100644
index 0000000..d6ef007
--- /dev/null
+++ b/talk/session/phone/webrtcvie.h
@@ -0,0 +1,144 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef TALK_SESSION_PHONE_WEBRTCVIE_H_
+#define TALK_SESSION_PHONE_WEBRTCVIE_H_
+
+#include "talk/base/common.h"
+#include "talk/session/phone/webrtccommon.h"
+
+#ifdef WEBRTC_RELATIVE_PATH
+#include "common_types.h"
+#include "modules/interface/module_common_types.h"
+#include "modules/video_capture/main/interface/video_capture.h"
+#include "modules/video_render/main/interface/video_render.h"
+#include "video_engine/main/interface/vie_base.h"
+#include "video_engine/main/interface/vie_capture.h"
+#include "video_engine/main/interface/vie_codec.h"
+#include "video_engine/main/interface/vie_errors.h"
+#include "video_engine/main/interface/vie_image_process.h"
+#include "video_engine/main/interface/vie_network.h"
+#include "video_engine/main/interface/vie_render.h"
+#include "video_engine/main/interface/vie_rtp_rtcp.h"
+#else
+#include "third_party/webrtc/files/include/common_types.h"
+#include "third_party/webrtc/files/include/module_common_types.h"
+#include "third_party/webrtc/files/include/video_capture.h"
+#include "third_party/webrtc/files/include/video_render.h"
+#include "third_party/webrtc/files/include/vie_base.h"
+#include "third_party/webrtc/files/include/vie_capture.h"
+#include "third_party/webrtc/files/include/vie_codec.h"
+#include "third_party/webrtc/files/include/vie_errors.h"
+#include "third_party/webrtc/files/include/vie_image_process.h"
+#include "third_party/webrtc/files/include/vie_network.h"
+#include "third_party/webrtc/files/include/vie_render.h"
+#include "third_party/webrtc/files/include/vie_rtp_rtcp.h"
+#endif  // WEBRTC_RELATIVE_PATH
+
+namespace cricket {
+
+// all tracing macros should go to a common file
+
+// automatically handles lifetime of VideoEngine
+class scoped_vie_engine {
+ public:
+  explicit scoped_vie_engine(webrtc::VideoEngine* e) : ptr(e) {}
+  // VERIFY, to ensure that there are no leaks at shutdown
+  ~scoped_vie_engine() {
+    if (ptr) {
+      webrtc::VideoEngine::Delete(ptr);
+    }
+  }
+  webrtc::VideoEngine* get() const { return ptr; }
+ private:
+  webrtc::VideoEngine* ptr;
+};
+
+// scoped_ptr class to handle obtaining and releasing VideoEngine
+// interface pointers
+template<class T> class scoped_vie_ptr {
+ public:
+  explicit scoped_vie_ptr(const scoped_vie_engine& e)
+       : ptr(T::GetInterface(e.get())) {}
+  explicit scoped_vie_ptr(T* p) : ptr(p) {}
+  ~scoped_vie_ptr() { if (ptr) ptr->Release(); }
+  T* operator->() const { return ptr; }
+  T* get() const { return ptr; }
+ private:
+  T* ptr;
+};
+
+// Utility class for aggregating the various WebRTC interface.
+// Fake implementations can also be injected for testing.
+class ViEWrapper {
+ public:
+  ViEWrapper()
+      : engine_(webrtc::VideoEngine::Create()),
+        base_(engine_), codec_(engine_), capture_(engine_),
+        network_(engine_), render_(engine_), rtp_(engine_),
+        image_(engine_) {
+  }
+
+  ViEWrapper(webrtc::ViEBase* base, webrtc::ViECodec* codec,
+             webrtc::ViECapture* capture, webrtc::ViENetwork* network,
+             webrtc::ViERender* render, webrtc::ViERTP_RTCP* rtp,
+             webrtc::ViEImageProcess* image)
+      : engine_(NULL),
+        base_(base),
+        codec_(codec),
+        capture_(capture),
+        network_(network),
+        render_(render),
+        rtp_(rtp),
+        image_(image) {
+  }
+
+  virtual ~ViEWrapper() {}
+  webrtc::VideoEngine* engine() { return engine_.get(); }
+  webrtc::ViEBase* base() { return base_.get(); }
+  webrtc::ViECodec* codec() { return codec_.get(); }
+  webrtc::ViECapture* capture() { return capture_.get(); }
+  webrtc::ViENetwork* network() { return network_.get(); }
+  webrtc::ViERender* render() { return render_.get(); }
+  webrtc::ViERTP_RTCP* rtp() { return rtp_.get(); }
+  webrtc::ViEImageProcess* sync() { return image_.get(); }
+  int error() { return base_->LastError(); }
+
+ private:
+  scoped_vie_engine engine_;
+  scoped_vie_ptr<webrtc::ViEBase> base_;
+  scoped_vie_ptr<webrtc::ViECodec> codec_;
+  scoped_vie_ptr<webrtc::ViECapture> capture_;
+  scoped_vie_ptr<webrtc::ViENetwork> network_;
+  scoped_vie_ptr<webrtc::ViERender> render_;
+  scoped_vie_ptr<webrtc::ViERTP_RTCP> rtp_;
+  scoped_vie_ptr<webrtc::ViEImageProcess> image_;
+};
+}
+
+#endif  // TALK_SESSION_PHONE_WEBRTCVIE_H_
diff --git a/talk/session/phone/webrtcvoe.h b/talk/session/phone/webrtcvoe.h
new file mode 100644
index 0000000..398928e
--- /dev/null
+++ b/talk/session/phone/webrtcvoe.h
@@ -0,0 +1,196 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef TALK_SESSION_PHONE_WEBRTCVOE_H_
+#define TALK_SESSION_PHONE_WEBRTCVOE_H_
+
+#include "talk/base/common.h"
+#include "talk/session/phone/webrtccommon.h"
+
+#ifdef WEBRTC_RELATIVE_PATH
+#include "common_types.h"
+#include "modules/audio_device/main/interface/audio_device.h"
+#include "voice_engine/main/interface/voe_audio_processing.h"
+#include "voice_engine/main/interface/voe_base.h"
+#include "voice_engine/main/interface/voe_codec.h"
+#include "voice_engine/main/interface/voe_dtmf.h"
+#include "voice_engine/main/interface/voe_errors.h"
+#include "voice_engine/main/interface/voe_external_media.h"
+#include "voice_engine/main/interface/voe_file.h"
+#include "voice_engine/main/interface/voe_hardware.h"
+#include "voice_engine/main/interface/voe_neteq_stats.h"
+#include "voice_engine/main/interface/voe_network.h"
+#include "voice_engine/main/interface/voe_rtp_rtcp.h"
+#include "voice_engine/main/interface/voe_video_sync.h"
+#include "voice_engine/main/interface/voe_volume_control.h"
+#else
+#include "third_party/webrtc/files/include/audio_device.h"
+#include "third_party/webrtc/files/include/common_types.h"
+#include "third_party/webrtc/files/include/voe_audio_processing.h"
+#include "third_party/webrtc/files/include/voe_base.h"
+#include "third_party/webrtc/files/include/voe_codec.h"
+#include "third_party/webrtc/files/include/voe_dtmf.h"
+#include "third_party/webrtc/files/include/voe_errors.h"
+#include "third_party/webrtc/files/include/voe_external_media.h"
+#include "third_party/webrtc/files/include/voe_file.h"
+#include "third_party/webrtc/files/include/voe_hardware.h"
+#include "third_party/webrtc/files/include/voe_neteq_stats.h"
+#include "third_party/webrtc/files/include/voe_network.h"
+#include "third_party/webrtc/files/include/voe_rtp_rtcp.h"
+#include "third_party/webrtc/files/include/voe_video_sync.h"
+#include "third_party/webrtc/files/include/voe_volume_control.h"
+#endif  // WEBRTC_RELATIVE_PATH
+
+namespace cricket {
+// automatically handles lifetime of WebRtc VoiceEngine
+class scoped_voe_engine {
+ public:
+  explicit scoped_voe_engine(webrtc::VoiceEngine* e) : ptr(e) {}
+  // VERIFY, to ensure that there are no leaks at shutdown
+  ~scoped_voe_engine() { if (ptr) VERIFY(webrtc::VoiceEngine::Delete(ptr)); }
+  // Releases the current pointer.
+  void reset() {
+    if (ptr) {
+      VERIFY(webrtc::VoiceEngine::Delete(ptr));
+      ptr = NULL;
+    }
+  }
+  webrtc::VoiceEngine* get() const { return ptr; }
+ private:
+  webrtc::VoiceEngine* ptr;
+};
+
+// scoped_ptr class to handle obtaining and releasing WebRTC interface pointers
+template<class T>
+class scoped_voe_ptr {
+ public:
+  explicit scoped_voe_ptr(const scoped_voe_engine& e)
+      : ptr(T::GetInterface(e.get())) {}
+  explicit scoped_voe_ptr(T* p) : ptr(p) {}
+  ~scoped_voe_ptr() { if (ptr) ptr->Release(); }
+  T* operator->() const { return ptr; }
+  T* get() const { return ptr; }
+
+  // Releases the current pointer.
+  void reset() {
+    if (ptr) {
+      ptr->Release();
+      ptr = NULL;
+    }
+  }
+
+ private:
+  T* ptr;
+};
+
+// Utility class for aggregating the various WebRTC interface.
+// Fake implementations can also be injected for testing.
+class VoEWrapper {
+ public:
+  VoEWrapper()
+      : engine_(webrtc::VoiceEngine::Create()), processing_(engine_),
+        base_(engine_), codec_(engine_), dtmf_(engine_), file_(engine_),
+        hw_(engine_), media_(engine_), neteq_(engine_), network_(engine_),
+        rtp_(engine_), sync_(engine_), volume_(engine_) {
+  }
+  VoEWrapper(webrtc::VoEAudioProcessing* processing,
+             webrtc::VoEBase* base,
+             webrtc::VoECodec* codec,
+             webrtc::VoEDtmf* dtmf,
+             webrtc::VoEFile* file,
+             webrtc::VoEHardware* hw,
+             webrtc::VoEExternalMedia* media,
+             webrtc::VoENetEqStats* neteq,
+             webrtc::VoENetwork* network,
+             webrtc::VoERTP_RTCP* rtp,
+             webrtc::VoEVideoSync* sync,
+             webrtc::VoEVolumeControl* volume)
+      : engine_(NULL),
+        processing_(processing),
+        base_(base),
+        codec_(codec),
+        dtmf_(dtmf),
+        file_(file),
+        hw_(hw),
+        media_(media),
+        neteq_(neteq),
+        network_(network),
+        rtp_(rtp),
+        sync_(sync),
+        volume_(volume) {
+  }
+  ~VoEWrapper() {}
+  webrtc::VoiceEngine* engine() const { return engine_.get(); }
+  webrtc::VoEAudioProcessing* processing() const { return processing_.get(); }
+  webrtc::VoEBase* base() const { return base_.get(); }
+  webrtc::VoECodec* codec() const { return codec_.get(); }
+  webrtc::VoEDtmf* dtmf() const { return dtmf_.get(); }
+  webrtc::VoEFile* file() const { return file_.get(); }
+  webrtc::VoEHardware* hw() const { return hw_.get(); }
+  webrtc::VoEExternalMedia* media() const { return media_.get(); }
+  webrtc::VoENetEqStats* neteq() const { return neteq_.get(); }
+  webrtc::VoENetwork* network() const { return network_.get(); }
+  webrtc::VoERTP_RTCP* rtp() const { return rtp_.get(); }
+  webrtc::VoEVideoSync* sync() const { return sync_.get(); }
+  webrtc::VoEVolumeControl* volume() const { return volume_.get(); }
+  int error() { return base_->LastError(); }
+
+ private:
+  scoped_voe_engine engine_;
+  scoped_voe_ptr<webrtc::VoEAudioProcessing> processing_;
+  scoped_voe_ptr<webrtc::VoEBase> base_;
+  scoped_voe_ptr<webrtc::VoECodec> codec_;
+  scoped_voe_ptr<webrtc::VoEDtmf> dtmf_;
+  scoped_voe_ptr<webrtc::VoEFile> file_;
+  scoped_voe_ptr<webrtc::VoEHardware> hw_;
+  scoped_voe_ptr<webrtc::VoEExternalMedia> media_;
+  scoped_voe_ptr<webrtc::VoENetEqStats> neteq_;
+  scoped_voe_ptr<webrtc::VoENetwork> network_;
+  scoped_voe_ptr<webrtc::VoERTP_RTCP> rtp_;
+  scoped_voe_ptr<webrtc::VoEVideoSync> sync_;
+  scoped_voe_ptr<webrtc::VoEVolumeControl> volume_;
+};
+
+// Adds indirection to static WebRtc functions, allowing them to be mocked.
+class VoETraceWrapper {
+ public:
+  virtual ~VoETraceWrapper() {}
+
+  virtual int SetTraceFilter(const unsigned int filter) {
+    return webrtc::VoiceEngine::SetTraceFilter(filter);
+  }
+  virtual int SetTraceFile(const char* fileNameUTF8) {
+    return webrtc::VoiceEngine::SetTraceFile(fileNameUTF8);
+  }
+  virtual int SetTraceCallback(webrtc::TraceCallback* callback) {
+    return webrtc::VoiceEngine::SetTraceCallback(callback);
+  }
+};
+}
+
+#endif  // TALK_SESSION_PHONE_WEBRTCVOE_H_
diff --git a/talk/session/phone/webrtcvoiceengine.cc b/talk/session/phone/webrtcvoiceengine.cc
new file mode 100644
index 0000000..a53dfc1
--- /dev/null
+++ b/talk/session/phone/webrtcvoiceengine.cc
@@ -0,0 +1,1988 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifdef HAVE_WEBRTC_VOICE
+
+#include "talk/session/phone/webrtcvoiceengine.h"
+
+#include <algorithm>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+#include "talk/base/base64.h"
+#include "talk/base/byteorder.h"
+#include "talk/base/common.h"
+#include "talk/base/helpers.h"
+#include "talk/base/logging.h"
+#include "talk/base/stringencode.h"
+#include "talk/session/phone/webrtcvoe.h"
+
+#ifdef WIN32
+#include <objbase.h>  // NOLINT
+#endif
+
+namespace cricket {
+
+// For Linux/Mac, using the default device is done by specifying index 0 for
+// VoE 4.0 and not -1 (which was the case for VoE 3.5).
+//
+// On Windows Vista and newer, Microsoft introduced the concept of "Default
+// Communications Device". This means that there are two types of default
+// devices (old Wave Audio style default and Default Communications Device).
+//
+// On Windows systems which only support Wave Audio style default, uses either
+// -1 or 0 to select the default device.
+//
+// On Windows systems which support both "Default Communication Device" and
+// old Wave Audio style default, use -1 for Default Communications Device and
+// -2 for Wave Audio style default, which is what we want to use for clips.
+// It's not clear yet whether the -2 index is handled properly on other OSes.
+
+#ifdef WIN32
+static const int kDefaultAudioDeviceId = -1;
+static const int kDefaultSoundclipDeviceId = -2;
+#else
+static const int kDefaultAudioDeviceId = 0;
+#endif
+
+// extension header for audio levels, as defined in
+// http://tools.ietf.org/html/draft-ietf-avtext-client-to-mixer-audio-level-03
+static const char kRtpAudioLevelHeaderExtension[] =
+    "urn:ietf:params:rtp-hdrext:ssrc-audio-level";
+
+static void LogMultiline(talk_base::LoggingSeverity sev, char* text) {
+  const char* delim = "\r\n";
+  for (char* tok = strtok(text, delim); tok; tok = strtok(NULL, delim)) {
+    LOG_V(sev) << tok;
+  }
+}
+
+static const char kL16CodecName[] = "L16";
+
+// WebRtcVoiceEngine
+const WebRtcVoiceEngine::CodecPref WebRtcVoiceEngine::kCodecPrefs[] = {
+  { "ISAC",   16000 },
+  { "ISAC",   32000 },
+  { "speex",  16000 },
+  { "G722",   16000 },
+  { "iLBC",   8000 },
+  { "speex",  8000 },
+  { "PCMU",   8000 },
+  { "PCMA",   8000 },
+  { "CN",     32000 },
+  { "CN",     16000 },
+  { "CN",     8000 },
+  { "red",    8000 },
+  { "telephone-event", 8000 },
+};
+
+class WebRtcSoundclipMedia : public SoundclipMedia {
+ public:
+  explicit WebRtcSoundclipMedia(WebRtcVoiceEngine *engine)
+      : engine_(engine), webrtc_channel_(-1) {
+    engine_->RegisterSoundclip(this);
+  }
+
+  virtual ~WebRtcSoundclipMedia() {
+    engine_->UnregisterSoundclip(this);
+    if (webrtc_channel_ != -1) {
+      if (engine_->voe_sc()->base()->DeleteChannel(webrtc_channel_)
+          == -1) {
+        LOG_RTCERR1(DeleteChannel, webrtc_channel_);
+      }
+    }
+  }
+
+  bool Init() {
+    webrtc_channel_ = engine_->voe_sc()->base()->CreateChannel();
+    if (webrtc_channel_ == -1) {
+      LOG_RTCERR0(CreateChannel);
+      return false;
+    }
+    return true;
+  }
+
+  bool Enable() {
+    if (engine_->voe_sc()->base()->StartPlayout(webrtc_channel_) == -1) {
+      LOG_RTCERR1(StartPlayout, webrtc_channel_);
+      return false;
+    }
+    return true;
+  }
+
+  bool Disable() {
+    if (engine_->voe_sc()->base()->StopPlayout(webrtc_channel_) == -1) {
+      LOG_RTCERR1(StopPlayout, webrtc_channel_);
+      return false;
+    }
+    return true;
+  }
+
+  virtual bool PlaySound(const char *buf, int len, int flags) {
+    // Must stop playing the current sound (if any), because we are about to
+    // modify the stream.
+    if (engine_->voe_sc()->file()->StopPlayingFileLocally(webrtc_channel_)
+        == -1) {
+      LOG_RTCERR1(StopPlayingFileLocally, webrtc_channel_);
+      return false;
+    }
+
+    if (buf) {
+      stream_.reset(new WebRtcSoundclipStream(buf, len));
+      stream_->set_loop((flags & SF_LOOP) != 0);
+      stream_->Rewind();
+
+      // Play it.
+      if (engine_->voe_sc()->file()->StartPlayingFileLocally(
+          webrtc_channel_, stream_.get()) == -1) {
+        LOG_RTCERR2(StartPlayingFileLocally, webrtc_channel_, stream_.get());
+        LOG(LS_ERROR) << "Unable to start soundclip";
+        return false;
+      }
+    } else {
+      stream_.reset();
+    }
+    return true;
+  }
+
+  int GetLastEngineError() const { return engine_->voe_sc()->error(); }
+
+ private:
+  WebRtcVoiceEngine *engine_;
+  int webrtc_channel_;
+  talk_base::scoped_ptr<WebRtcSoundclipStream> stream_;
+};
+
+WebRtcVoiceEngine::WebRtcVoiceEngine()
+    : voe_wrapper_(new VoEWrapper()),
+      voe_wrapper_sc_(new VoEWrapper()),
+      tracing_(new VoETraceWrapper()),
+      adm_(NULL),
+      adm_sc_(NULL),
+      log_level_(kDefaultLogSeverity),
+      is_dumping_aec_(false),
+      desired_local_monitor_enable_(false) {
+  Construct();
+}
+
+WebRtcVoiceEngine::WebRtcVoiceEngine(webrtc::AudioDeviceModule* adm,
+                                     webrtc::AudioDeviceModule* adm_sc)
+    : voe_wrapper_(new VoEWrapper()),
+      voe_wrapper_sc_(new VoEWrapper()),
+      tracing_(new VoETraceWrapper()),
+      adm_(adm),
+      adm_sc_(adm_sc),
+      log_level_(kDefaultLogSeverity),
+      is_dumping_aec_(false),
+      desired_local_monitor_enable_(false) {
+  Construct();
+}
+
+WebRtcVoiceEngine::WebRtcVoiceEngine(VoEWrapper* voe_wrapper,
+                                     VoEWrapper* voe_wrapper_sc,
+                                     VoETraceWrapper* tracing)
+    : voe_wrapper_(voe_wrapper),
+      voe_wrapper_sc_(voe_wrapper_sc),
+      tracing_(tracing),
+      adm_(NULL),
+      adm_sc_(NULL),
+      log_level_(kDefaultLogSeverity),
+      is_dumping_aec_(false),
+      desired_local_monitor_enable_(false) {
+  Construct();
+}
+
+void WebRtcVoiceEngine::Construct() {
+  initialized_ = false;
+  LOG(LS_VERBOSE) << "WebRtcVoiceEngine::WebRtcVoiceEngine";
+  ApplyLogging("");
+  if (tracing_->SetTraceCallback(this) == -1) {
+    LOG_RTCERR0(SetTraceCallback);
+  }
+  if (voe_wrapper_->base()->RegisterVoiceEngineObserver(*this) == -1) {
+    LOG_RTCERR0(RegisterVoiceEngineObserver);
+  }
+  // Clear the default agc state.
+  memset(&default_agc_config_, 0, sizeof(default_agc_config_));
+
+  // Load our audio codec list
+  LOG(LS_INFO) << "WebRtc VoiceEngine codecs:";
+  int ncodecs = voe_wrapper_->codec()->NumOfCodecs();
+  for (int i = 0; i < ncodecs; ++i) {
+    webrtc::CodecInst gcodec;
+    if (voe_wrapper_->codec()->GetCodec(i, gcodec) >= 0) {
+      // Skip the codecs that we don't support.
+      if (strcmp(gcodec.plname, kL16CodecName) == 0) {
+        continue;
+      }
+      int pref = GetCodecPreference(gcodec.plname, gcodec.plfreq);
+      if (pref != -1) {
+        if (gcodec.rate == -1) gcodec.rate = 0;
+        AudioCodec codec(gcodec.pltype, gcodec.plname, gcodec.plfreq,
+                         gcodec.rate, gcodec.channels, pref);
+        LOG(LS_INFO) << gcodec.plname << "/" << gcodec.plfreq << "/" \
+                     << gcodec.channels << " " << gcodec.pltype;
+        codecs_.push_back(codec);
+      }
+    }
+  }
+  // Make sure they are in local preference order
+  std::sort(codecs_.begin(), codecs_.end(), &AudioCodec::Preferable);
+}
+
+WebRtcVoiceEngine::~WebRtcVoiceEngine() {
+  LOG(LS_VERBOSE) << "WebRtcVoiceEngine::~WebRtcVoiceEngine";
+  if (voe_wrapper_->base()->DeRegisterVoiceEngineObserver() == -1) {
+    LOG_RTCERR0(DeRegisterVoiceEngineObserver);
+  }
+  if (adm_) {
+    voe_wrapper_.reset();
+    webrtc::AudioDeviceModule::Destroy(adm_);
+    adm_ = NULL;
+  }
+  if (adm_sc_) {
+    voe_wrapper_sc_.reset();
+    webrtc::AudioDeviceModule::Destroy(adm_sc_);
+    adm_sc_ = NULL;
+  }
+
+  tracing_->SetTraceCallback(NULL);
+}
+
+bool WebRtcVoiceEngine::Init() {
+  LOG(LS_INFO) << "WebRtcVoiceEngine::Init";
+  bool res = InitInternal();
+  if (res) {
+    LOG(LS_INFO) << "WebRtcVoiceEngine::Init Done!";
+  } else {
+    LOG(LS_ERROR) << "WebRtcVoiceEngine::Init failed";
+    Terminate();
+  }
+  return res;
+}
+
+bool WebRtcVoiceEngine::InitInternal() {
+  // Temporarily turn logging level up for the Init call
+  int old_level = log_level_;
+  log_level_ = talk_base::_min(log_level_,
+                               static_cast<int>(talk_base::LS_INFO));
+  ApplyLogging("");
+
+  if (adm_) {
+    if (voe_wrapper_->base()->RegisterAudioDeviceModule(*adm_) == -1) {
+      LOG_RTCERR0_EX(Init, voe_wrapper_->error());
+      return false;
+    }
+  }
+  if (adm_sc_) {
+    if (voe_wrapper_sc_->base()->RegisterAudioDeviceModule(*adm_sc_) == -1) {
+      LOG_RTCERR0_EX(Init, voe_wrapper_sc_->error());
+      return false;
+    }
+  }
+
+  // Init WebRtc VoiceEngine, enabling AEC logging if specified in SetLogging.
+  if (voe_wrapper_->base()->Init() == -1) {
+    LOG_RTCERR0_EX(Init, voe_wrapper_->error());
+    return false;
+  }
+
+  // Restore the previous log level and apply the log filter.
+  log_level_ = old_level;
+  ApplyLogging(log_filter_);
+
+  // Log the VoiceEngine version info
+  char buffer[1024] = "";
+  voe_wrapper_->base()->GetVersion(buffer);
+  LOG(LS_INFO) << "WebRtc VoiceEngine Version:";
+  LogMultiline(talk_base::LS_INFO, buffer);
+
+  // Turn on AEC and AGC by default.
+  if (!SetOptions(
+      MediaEngineInterface::ECHO_CANCELLATION |
+      MediaEngineInterface::AUTO_GAIN_CONTROL)) {
+    return false;
+  }
+
+  // Save the default AGC configuration settings.
+  if (voe_wrapper_->processing()->SetAgcConfig(default_agc_config_) == -1) {
+    LOG_RTCERR0(GetAGCConfig);
+    return false;
+  }
+
+  // Print our codec list again for the call diagnostic log
+  LOG(LS_INFO) << "WebRtc VoiceEngine codecs:";
+  for (std::vector<AudioCodec>::const_iterator it = codecs_.begin();
+      it != codecs_.end(); ++it) {
+    LOG(LS_INFO) << it->name << "/" << it->clockrate << "/"
+              << it->channels << " " << it->id;
+  }
+
+#if defined(LINUX) && !defined(HAVE_LIBPULSE)
+  voe_wrapper_sc_->hw()->SetAudioDeviceLayer(webrtc::kAudioLinuxAlsa);
+#endif
+
+  // Initialize the VoiceEngine instance that we'll use to play out sound clips.
+  if (voe_wrapper_sc_->base()->Init() == -1) {
+    LOG_RTCERR0_EX(Init, voe_wrapper_sc_->error());
+    return false;
+  }
+
+  // On Windows, tell it to use the default sound (not communication) devices.
+  // First check whether there is a valid sound device for playback.
+  // TODO: Clean this up when we support setting the soundclip device.
+#ifdef WIN32
+  int num_of_devices = 0;
+  if (voe_wrapper_sc_->hw()->GetNumOfPlayoutDevices(num_of_devices) != -1 &&
+      num_of_devices > 0) {
+    if (voe_wrapper_sc_->hw()->SetPlayoutDevice(kDefaultSoundclipDeviceId)
+        == -1) {
+      LOG_RTCERR1_EX(SetPlayoutDevice, kDefaultSoundclipDeviceId,
+                      voe_wrapper_sc_->error());
+      return false;
+    }
+  } else {
+    LOG(LS_WARNING) << "No valid sound playout device found.";
+  }
+#endif
+
+  initialized_ = true;
+  return true;
+}
+
+void WebRtcVoiceEngine::Terminate() {
+  LOG(LS_INFO) << "WebRtcVoiceEngine::Terminate";
+  initialized_ = false;
+
+  if (is_dumping_aec_) {
+    if (voe_wrapper_->processing()->StopDebugRecording() == -1) {
+      LOG_RTCERR0(StopDebugRecording);
+    }
+    is_dumping_aec_ = false;
+  }
+
+  voe_wrapper_sc_->base()->Terminate();
+  voe_wrapper_->base()->Terminate();
+  desired_local_monitor_enable_ = false;
+}
+
+int WebRtcVoiceEngine::GetCapabilities() {
+  return AUDIO_SEND | AUDIO_RECV;
+}
+
+VoiceMediaChannel *WebRtcVoiceEngine::CreateChannel() {
+  WebRtcVoiceMediaChannel* ch = new WebRtcVoiceMediaChannel(this);
+  if (!ch->valid()) {
+    delete ch;
+    ch = NULL;
+  }
+  return ch;
+}
+
+SoundclipMedia *WebRtcVoiceEngine::CreateSoundclip() {
+  WebRtcSoundclipMedia *soundclip = new WebRtcSoundclipMedia(this);
+  if (!soundclip->Init() || !soundclip->Enable()) {
+    delete soundclip;
+    return NULL;
+  }
+  return soundclip;
+}
+
+bool WebRtcVoiceEngine::SetOptions(int options) {
+  // NS and typing detection are always on, if supported.
+  bool aec = (options & MediaEngineInterface::ECHO_CANCELLATION) ? true : false;
+  bool agc = (options & MediaEngineInterface::AUTO_GAIN_CONTROL) ? true : false;
+#if !defined(IOS) && !defined(ANDROID)
+  if (voe_wrapper_->processing()->SetEcStatus(aec) == -1) {
+    LOG_RTCERR1(SetEcStatus, aec);
+    return false;
+  }
+
+  if (voe_wrapper_->processing()->SetAgcStatus(agc) == -1) {
+    LOG_RTCERR1(SetAgcStatus, agc);
+    return false;
+  }
+
+  if (voe_wrapper_->processing()->SetNsStatus(true) == -1) {
+    LOG_RTCERR1(SetNsStatus, true);
+    return false;
+  }
+
+  if (voe_wrapper_->processing()->SetTypingDetectionStatus(true) == -1) {
+    // In case of error, log the info and continue
+    LOG_RTCERR1(SetTypingDetectionStatus, true);
+  }
+#else
+  if (voe_wrapper_->processing()->SetEcStatus(aec, kEcAecm) == -1) {
+    LOG_RTCERR2(SetEcStatus, aec, kEcAecm);
+    return false;
+  }
+
+  if (aec) {
+    // Use speakerphone mode with comfort noise generation for mobile.
+    if (voe_wrapper_->processing()->SetAecmMode(kAecmSpeakerphone, true) != 0) {
+      LOG_RTCERR2(SetAecmMode, kAecmSpeakerphone, true);
+    }
+  }
+
+  // On mobile, GIPS recommends fixed AGC (not adaptive)
+  if (voe_wrapper_->processing()->SetAgcStatus(agc, kAgcFixedDigital) == -1) {
+    LOG_RTCERR2(SetAgcStatus, agc, kAgcFixedDigital);
+    return false;
+  }
+
+  // On mobile, GIPS recommends moderate aggressiveness.
+  if (voe_wrapper_->processing()->SetNsStatus(true,
+      kNsModerateSuppression) == -1) {
+    LOG_RTCERR2(SetNsStatus, ns, kNsModerateSuppression);
+    return false;
+  }
+
+  // No typing detection support on iOS or Android.
+#endif // !IOS && !ANDROID
+
+  return true;
+}
+
+struct ResumeEntry {
+  ResumeEntry(WebRtcVoiceMediaChannel *c, bool p, SendFlags s)
+      : channel(c),
+        playout(p),
+        send(s) {
+  }
+
+  WebRtcVoiceMediaChannel *channel;
+  bool playout;
+  SendFlags send;
+};
+
+// TODO: Refactor this so that the core logic can be used to set the
+// soundclip device. At that time, reinstate the soundclip pause/resume code.
+bool WebRtcVoiceEngine::SetDevices(const Device* in_device,
+                                   const Device* out_device) {
+#if !defined(IOS) && !defined(ANDROID)
+  int in_id = in_device ? talk_base::FromString<int>(in_device->id) :
+      kDefaultAudioDeviceId;
+  int out_id = out_device ? talk_base::FromString<int>(out_device->id) :
+      kDefaultAudioDeviceId;
+  // The device manager uses -1 as the default device, which was the case for
+  // VoE 3.5. VoE 4.0, however, uses 0 as the default in Linux and Mac.
+#ifndef WIN32
+  if (-1 == in_id) {
+    in_id = kDefaultAudioDeviceId;
+  }
+  if (-1 == out_id) {
+    out_id = kDefaultAudioDeviceId;
+  }
+#endif
+
+  std::string in_name = (in_id != kDefaultAudioDeviceId) ?
+      in_device->name : "Default device";
+  std::string out_name = (out_id != kDefaultAudioDeviceId) ?
+      out_device->name : "Default device";
+  LOG(LS_INFO) << "Setting microphone to (id=" << in_id << ", name=" << in_name
+            << ") and speaker to (id=" << out_id << ", name=" << out_name
+            << ")";
+
+  // If we're running the local monitor, we need to stop it first.
+  bool ret = true;
+  if (!PauseLocalMonitor()) {
+    LOG(LS_WARNING) << "Failed to pause local monitor";
+    ret = false;
+  }
+
+  // Must also pause all audio playback and capture.
+  for (ChannelList::const_iterator i = channels_.begin();
+       i != channels_.end(); ++i) {
+    WebRtcVoiceMediaChannel *channel = *i;
+    if (!channel->PausePlayout()) {
+      LOG(LS_WARNING) << "Failed to pause playout";
+      ret = false;
+    }
+    if (!channel->PauseSend()) {
+      LOG(LS_WARNING) << "Failed to pause send";
+      ret = false;
+    }
+  }
+
+  // Find the recording device id in VoiceEngine and set recording device.
+  if (!FindWebRtcAudioDeviceId(true, in_name, in_id, &in_id)) {
+    ret = false;
+  }
+  if (ret) {
+    if (voe_wrapper_->hw()->SetRecordingDevice(in_id) == -1) {
+      LOG_RTCERR2(SetRecordingDevice, in_device->name, in_id);
+      ret = false;
+    }
+  }
+
+  // Find the playout device id in VoiceEngine and set playout device.
+  if (!FindWebRtcAudioDeviceId(false, out_name, out_id, &out_id)) {
+    LOG(LS_WARNING) << "Failed to find VoiceEngine device id for " << out_name;
+    ret = false;
+  }
+  if (ret) {
+    if (voe_wrapper_->hw()->SetPlayoutDevice(out_id) == -1) {
+      LOG_RTCERR2(SetPlayoutDevice, out_device->name, out_id);
+      ret = false;
+    }
+  }
+
+  // Resume all audio playback and capture.
+  for (ChannelList::const_iterator i = channels_.begin();
+       i != channels_.end(); ++i) {
+    WebRtcVoiceMediaChannel *channel = *i;
+    if (!channel->ResumePlayout()) {
+      LOG(LS_WARNING) << "Failed to resume playout";
+      ret = false;
+    }
+    if (!channel->ResumeSend()) {
+      LOG(LS_WARNING) << "Failed to resume send";
+      ret = false;
+    }
+  }
+
+  // Resume local monitor.
+  if (!ResumeLocalMonitor()) {
+    LOG(LS_WARNING) << "Failed to resume local monitor";
+    ret = false;
+  }
+
+  if (ret) {
+    LOG(LS_INFO) << "Set microphone to (id=" << in_id <<" name=" << in_name
+                 << ") and speaker to (id="<< out_id << " name=" << out_name
+                 << ")";
+  }
+
+  return ret;
+#else
+  return true;
+#endif  // !IOS && !ANDROID
+}
+
+bool WebRtcVoiceEngine::FindWebRtcAudioDeviceId(
+  bool is_input, const std::string& dev_name, int dev_id, int* rtc_id) {
+  // In Linux, VoiceEngine uses the same device dev_id as the device manager.
+#ifdef LINUX
+  *rtc_id = dev_id;
+  return true;
+#else
+  // In Windows and Mac, we need to find the VoiceEngine device id by name
+  // unless the input dev_id is the default device id.
+  if (kDefaultAudioDeviceId == dev_id) {
+    *rtc_id = dev_id;
+    return true;
+  }
+
+  // Get the number of VoiceEngine audio devices.
+  int count = 0;
+  if (is_input) {
+    if (-1 == voe_wrapper_->hw()->GetNumOfRecordingDevices(count)) {
+      LOG_RTCERR0(GetNumOfRecordingDevices);
+      return false;
+    }
+  } else {
+    if (-1 == voe_wrapper_->hw()->GetNumOfPlayoutDevices(count)) {
+      LOG_RTCERR0(GetNumOfPlayoutDevices);
+      return false;
+    }
+  }
+
+  for (int i = 0; i < count; ++i) {
+    char name[128];
+    char guid[128];
+    if (is_input) {
+      voe_wrapper_->hw()->GetRecordingDeviceName(i, name, guid);
+      LOG(LS_VERBOSE) << "VoiceEngine microphone " << i << ": " << name;
+    } else {
+      voe_wrapper_->hw()->GetPlayoutDeviceName(i, name, guid);
+      LOG(LS_VERBOSE) << "VoiceEngine speaker " << i << ": " << name;
+    }
+
+    std::string webrtc_name(name);
+    if (dev_name.compare(0, webrtc_name.size(), webrtc_name) == 0) {
+      *rtc_id = i;
+      return true;
+    }
+  }
+  LOG(LS_WARNING) << "VoiceEngine cannot find device: " << dev_name;
+  return false;
+#endif
+}
+
+bool WebRtcVoiceEngine::GetOutputVolume(int* level) {
+  unsigned int ulevel;
+  if (voe_wrapper_->volume()->GetSpeakerVolume(ulevel) == -1) {
+    LOG_RTCERR1(GetSpeakerVolume, level);
+    return false;
+  }
+  *level = ulevel;
+  return true;
+}
+
+bool WebRtcVoiceEngine::SetOutputVolume(int level) {
+  ASSERT(level >= 0 && level <= 255);
+  if (voe_wrapper_->volume()->SetSpeakerVolume(level) == -1) {
+    LOG_RTCERR1(SetSpeakerVolume, level);
+    return false;
+  }
+  return true;
+}
+
+int WebRtcVoiceEngine::GetInputLevel() {
+  unsigned int ulevel;
+  return (voe_wrapper_->volume()->GetSpeechInputLevel(ulevel) != -1) ?
+      static_cast<int>(ulevel) : -1;
+}
+
+bool WebRtcVoiceEngine::SetLocalMonitor(bool enable) {
+  desired_local_monitor_enable_ = enable;
+  return ChangeLocalMonitor(desired_local_monitor_enable_);
+}
+
+bool WebRtcVoiceEngine::ChangeLocalMonitor(bool enable) {
+  if (enable && !monitor_.get()) {
+    monitor_.reset(new WebRtcMonitorStream);
+    if (voe_wrapper_->file()->StartRecordingMicrophone(monitor_.get()) == -1) {
+      LOG_RTCERR1(StartRecordingMicrophone, monitor_.get());
+      // Must call Stop() because there are some cases where Start will report
+      // failure but still change the state, and if we leave VE in the on state
+      // then it could crash later when trying to invoke methods on our monitor.
+      voe_wrapper_->file()->StopRecordingMicrophone();
+      monitor_.reset();
+      return false;
+    }
+  } else if (!enable && monitor_.get()) {
+    voe_wrapper_->file()->StopRecordingMicrophone();
+    monitor_.reset();
+  }
+  return true;
+}
+
+bool WebRtcVoiceEngine::PauseLocalMonitor() {
+  return ChangeLocalMonitor(false);
+}
+
+bool WebRtcVoiceEngine::ResumeLocalMonitor() {
+  return ChangeLocalMonitor(desired_local_monitor_enable_);
+}
+
+const std::vector<AudioCodec>& WebRtcVoiceEngine::codecs() {
+  return codecs_;
+}
+
+bool WebRtcVoiceEngine::FindCodec(const AudioCodec& in) {
+  return FindWebRtcCodec(in, NULL);
+}
+
+bool WebRtcVoiceEngine::FindWebRtcCodec(const AudioCodec& in,
+                                        webrtc::CodecInst* out) {
+  int ncodecs = voe_wrapper_->codec()->NumOfCodecs();
+  for (int i = 0; i < ncodecs; ++i) {
+    webrtc::CodecInst gcodec;
+    if (voe_wrapper_->codec()->GetCodec(i, gcodec) >= 0) {
+      AudioCodec codec(gcodec.pltype, gcodec.plname,
+                       gcodec.plfreq, gcodec.rate, gcodec.channels, 0);
+      if (codec.Matches(in)) {
+        if (out) {
+          // If the codec is VBR and an explicit rate is specified, use it.
+          if (in.bitrate != 0 && gcodec.rate == -1) {
+            gcodec.rate = in.bitrate;
+          }
+          *out = gcodec;
+        }
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void WebRtcVoiceEngine::SetLogging(int min_sev, const char* filter) {
+  // if min_sev == -1, we keep the current log level.
+  if (min_sev >= 0) {
+    log_level_ = min_sev;
+  }
+  log_filter_ = filter;
+  ApplyLogging(initialized_ ? log_filter_ : "");
+}
+
+int WebRtcVoiceEngine::GetLastEngineError() {
+  return voe_wrapper_->error();
+}
+
+// We suppport three different logging settings for VoiceEngine:
+// 1. Observer callback that goes into talk diagnostic logfile.
+//    Use --logfile and --loglevel
+//
+// 2. Encrypted VoiceEngine log for debugging VoiceEngine.
+//    Use --voice_loglevel --voice_logfilter "tracefile file_name"
+//
+// 3. EC log and dump for debugging QualityEngine.
+//    Use --voice_loglevel --voice_logfilter "recordEC file_name"
+//
+// For more details see: "https://sites.google.com/a/google.com/wavelet/Home/
+//    Magic-Flute--RTC-Engine-/Magic-Flute-Command-Line-Parameters"
+void WebRtcVoiceEngine::ApplyLogging(const std::string& log_filter) {
+  // Set log level.
+  int filter = 0;
+  switch (log_level_) {
+    case talk_base::LS_VERBOSE:
+      filter |= webrtc::kTraceAll;      // fall through
+    case talk_base::LS_INFO:
+      filter |= webrtc::kTraceStateInfo;  // fall through
+    case talk_base::LS_WARNING:
+      filter |= (webrtc::kTraceInfo | webrtc::kTraceWarning);  // fall through
+    case talk_base::LS_ERROR:
+      filter |= (webrtc::kTraceError | webrtc::kTraceCritical);
+  }
+  tracing_->SetTraceFilter(filter);
+
+  // Set encrypted trace file.
+  std::vector<std::string> opts;
+  talk_base::tokenize(log_filter, ' ', '"', '"', &opts);
+  std::vector<std::string>::iterator tracefile =
+      std::find(opts.begin(), opts.end(), "tracefile");
+  if (tracefile != opts.end() && ++tracefile != opts.end()) {
+    // Write encrypted debug output (at same loglevel) to file
+    // EncryptedTraceFile no longer supported.
+    if (tracing_->SetTraceFile(tracefile->c_str()) == -1) {
+      LOG_RTCERR1(SetTraceFile, *tracefile);
+    }
+  }
+
+  // Set AEC dump file
+  std::vector<std::string>::iterator recordEC =
+      std::find(opts.begin(), opts.end(), "recordEC");
+  if (recordEC != opts.end()) {
+    ++recordEC;
+    if (recordEC != opts.end() && !is_dumping_aec_) {
+      // Start dumping AEC when we are not dumping and recordEC has a filename.
+      if (voe_wrapper_->processing()->StartDebugRecording(
+          recordEC->c_str()) == -1) {
+        LOG_RTCERR0(StartDebugRecording);
+      } else {
+        is_dumping_aec_ = true;
+      }
+    } else if (recordEC == opts.end() && is_dumping_aec_) {
+      // Stop dumping EC when we are dumping and recordEC has no filename.
+      if (voe_wrapper_->processing()->StopDebugRecording() == -1) {
+        LOG_RTCERR0(StopDebugRecording);
+      }
+      is_dumping_aec_ = false;
+    }
+  }
+}
+
+// Ignore spammy trace messages, mostly from the stats API when we haven't
+// gotten RTCP info yet from the remote side.
+static bool ShouldIgnoreTrace(const std::string& trace) {
+  static const char* kTracesToIgnore[] = {
+    "\tfailed to GetReportBlockInformation",
+    "GetRecCodec() failed to get received codec",
+    "GetRemoteRTCPData() failed to retrieve sender info for remote side",
+    "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",
+    "RTCPReceiver::SenderInfoReceived No received SR",
+    "StatisticsRTP() no statisitics availble",
+    NULL
+  };
+  for (const char* const* p = kTracesToIgnore; *p; ++p) {
+    if (trace.find(*p) == 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void WebRtcVoiceEngine::Print(const webrtc::TraceLevel level,
+                              const char* trace, const int length) {
+  talk_base::LoggingSeverity sev = talk_base::LS_VERBOSE;
+  if (level == webrtc::kTraceError || level == webrtc::kTraceCritical)
+    sev = talk_base::LS_ERROR;
+  else if (level == webrtc::kTraceWarning)
+    sev = talk_base::LS_WARNING;
+  else if (level == webrtc::kTraceStateInfo || level == webrtc::kTraceInfo)
+    sev = talk_base::LS_INFO;
+
+  if (sev >= log_level_) {
+    // Skip past boilerplate prefix text
+    if (length < 72) {
+      std::string msg(trace, length);
+      LOG(LS_ERROR) << "Malformed webrtc log message: ";
+      LOG_V(sev) << msg;
+    } else {
+      std::string msg(trace + 71, length - 72);
+      if (!ShouldIgnoreTrace(msg)) {
+        LOG_V(sev) << "WebRtc VoE:" << msg;
+      }
+    }
+  }
+}
+
+void WebRtcVoiceEngine::CallbackOnError(const int channel_num,
+                                        const int err_code) {
+  talk_base::CritScope lock(&channels_cs_);
+  WebRtcVoiceMediaChannel* channel = NULL;
+  uint32 ssrc = 0;
+  LOG(LS_WARNING) << "VoiceEngine error " << err_code << " reported on channel "
+               << channel_num << ".";
+  if (FindChannelAndSsrc(channel_num, &channel, &ssrc)) {
+    ASSERT(channel != NULL);
+    channel->OnError(ssrc, err_code);
+  } else {
+    LOG(LS_ERROR) << "VoiceEngine channel " << channel_num
+        << " could not be found in the channel list when error reported.";
+  }
+}
+
+int WebRtcVoiceEngine::GetCodecPreference(const char *name, int clockrate) {
+  for (size_t i = 0; i < ARRAY_SIZE(kCodecPrefs); ++i) {
+    if ((strcmp(kCodecPrefs[i].name, name) == 0) &&
+        (kCodecPrefs[i].clockrate == clockrate))
+      return ARRAY_SIZE(kCodecPrefs) - i;
+  }
+  LOG(LS_WARNING) << "Unexpected codec \"" << name << "/" << clockrate << "\"";
+  return -1;
+}
+
+bool WebRtcVoiceEngine::FindChannelAndSsrc(
+    int channel_num, WebRtcVoiceMediaChannel** channel, uint32* ssrc) const {
+  ASSERT(channel != NULL && ssrc != NULL);
+
+  *channel = NULL;
+  *ssrc = 0;
+  // Find corresponding channel and ssrc
+  for (ChannelList::const_iterator it = channels_.begin();
+      it != channels_.end(); ++it) {
+    ASSERT(*it != NULL);
+    if ((*it)->FindSsrc(channel_num, ssrc)) {
+      *channel = *it;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void WebRtcVoiceEngine::RegisterChannel(WebRtcVoiceMediaChannel *channel) {
+  talk_base::CritScope lock(&channels_cs_);
+  channels_.push_back(channel);
+}
+
+void WebRtcVoiceEngine::UnregisterChannel(WebRtcVoiceMediaChannel *channel) {
+  talk_base::CritScope lock(&channels_cs_);
+  ChannelList::iterator i = std::find(channels_.begin(),
+                                      channels_.end(),
+                                      channel);
+  if (i != channels_.end()) {
+    channels_.erase(i);
+  }
+}
+
+void WebRtcVoiceEngine::RegisterSoundclip(WebRtcSoundclipMedia *soundclip) {
+  soundclips_.push_back(soundclip);
+}
+
+void WebRtcVoiceEngine::UnregisterSoundclip(WebRtcSoundclipMedia *soundclip) {
+  SoundclipList::iterator i = std::find(soundclips_.begin(),
+                                        soundclips_.end(),
+                                        soundclip);
+  if (i != soundclips_.end()) {
+    soundclips_.erase(i);
+  }
+}
+
+// Adjusts the default AGC target level by the specified delta.
+// NB: If we start messing with other config fields, we'll want
+// to save the current webrtc::AgcConfig as well.
+bool WebRtcVoiceEngine::AdjustAgcLevel(int delta) {
+  webrtc::AgcConfig config = default_agc_config_;
+  config.targetLeveldBOv += delta;
+
+  LOG(LS_INFO) << "Adjusting AGC level from default -"
+               << default_agc_config_.targetLeveldBOv << "dB to -"
+               << config.targetLeveldBOv << "dB";
+
+  if (voe_wrapper_->processing()->SetAgcConfig(config) == -1) {
+    LOG_RTCERR1(SetAgcConfig, config.targetLeveldBOv);
+    return false;
+  }
+  return true;
+}
+
+// Configures echo cancellation and noise suppression modes according to
+// whether or not we are in a multi-point conference.
+bool WebRtcVoiceEngine::SetConferenceMode(bool enable) {
+// Only use EC_AECM for mobile.
+#if defined(IOS) || defined(ANDROID)
+  return true;
+#endif
+
+  LOG(LS_INFO) << (enable ? "Enabling" : "Disabling")
+               << " Conference Mode noise reduction";
+
+  // We always configure noise suppression on, so just toggle the mode.
+  const webrtc::NsModes ns_mode = enable ? webrtc::kNsConference
+                                         : webrtc::kNsDefault;
+  if (voe_wrapper_->processing()->SetNsStatus(true, ns_mode) == -1) {
+    LOG_RTCERR2(SetNsStatus, true, ns_mode);
+    return false;
+  }
+
+  // Echo-cancellation is a user-option, so preserve the enable state and
+  // just toggle the mode.
+  bool aec;
+  webrtc::EcModes ec_mode;
+  if (voe_wrapper_->processing()->GetEcStatus(aec, ec_mode) == -1) {
+    LOG_RTCERR0(GetEcStatus);
+    return false;
+  }
+  ec_mode = enable ? webrtc::kEcConference : webrtc::kEcDefault;
+  if (voe_wrapper_->processing()->SetEcStatus(aec, ec_mode) == -1) {
+    LOG_RTCERR2(SetEcStatus, aec, ec_mode);
+    return false;
+  }
+  return true;
+}
+
+// WebRtcVoiceMediaChannel
+WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(WebRtcVoiceEngine *engine)
+    : WebRtcMediaChannel<VoiceMediaChannel, WebRtcVoiceEngine>(
+          engine,
+          engine->voe()->base()->CreateChannel()),
+      channel_options_(0),
+      agc_adjusted_(false),
+      dtmf_allowed_(false),
+      desired_playout_(false),
+      playout_(false),
+      desired_send_(SEND_NOTHING),
+      send_(SEND_NOTHING) {
+  engine->RegisterChannel(this);
+  LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel "
+                  << voe_channel();
+
+  // Register external transport
+  if (engine->voe()->network()->RegisterExternalTransport(
+      voe_channel(), *static_cast<Transport*>(this)) == -1) {
+    LOG_RTCERR2(RegisterExternalTransport, voe_channel(), this);
+  }
+
+  // Enable RTCP (for quality stats and feedback messages)
+  EnableRtcp(voe_channel());
+
+  // Create a random but nonzero send SSRC
+  SetSendSsrc(talk_base::CreateRandomNonZeroId());
+}
+
+WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
+  LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel "
+                  << voe_channel();
+
+  // DeRegister external transport
+  if (engine()->voe()->network()->DeRegisterExternalTransport(
+      voe_channel()) == -1) {
+    LOG_RTCERR1(DeRegisterExternalTransport, voe_channel());
+  }
+
+  // Unregister ourselves from the engine.
+  engine()->UnregisterChannel(this);
+  // Remove any remaining streams.
+  while (!mux_channels_.empty()) {
+    RemoveStream(mux_channels_.begin()->first);
+  }
+  // Delete the primary channel.
+  if (engine()->voe()->base()->DeleteChannel(voe_channel()) == -1) {
+    LOG_RTCERR1(DeleteChannel, voe_channel());
+  }
+}
+
+bool WebRtcVoiceMediaChannel::SetOptions(int flags) {
+  // Always accept flags that are unchanged.
+  if (channel_options_ == flags) {
+    return true;
+  }
+
+  // Reject new options if we're already sending.
+  if (send_ != SEND_NOTHING) {
+    return false;
+  }
+
+  // Save the options, to be interpreted where appropriate.
+  channel_options_ = flags;
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::SetRecvCodecs(
+    const std::vector<AudioCodec>& codecs) {
+  // Update our receive payload types to match what we offered. This only is
+  // an issue when a different entity (i.e. a server) is generating the offer
+  // for us.
+  bool ret = true;
+  for (std::vector<AudioCodec>::const_iterator i = codecs.begin();
+       i != codecs.end() && ret; ++i) {
+    webrtc::CodecInst gcodec;
+    if (engine()->FindWebRtcCodec(*i, &gcodec)) {
+      if (gcodec.pltype != i->id) {
+        LOG(LS_INFO) << "Updating payload type for " << gcodec.plname
+                  << " from " << gcodec.pltype << " to " << i->id;
+        gcodec.pltype = i->id;
+        if (engine()->voe()->codec()->SetRecPayloadType(
+            voe_channel(), gcodec) == -1) {
+          LOG_RTCERR1(SetRecPayloadType, voe_channel());
+          ret = false;
+        }
+      }
+    } else {
+      LOG(LS_WARNING) << "Unknown codec " << i->name;
+      ret = false;
+    }
+  }
+
+  return ret;
+}
+
+bool WebRtcVoiceMediaChannel::SetSendCodecs(
+    const std::vector<AudioCodec>& codecs) {
+  // Disable DTMF, VAD, and FEC unless we know the other side wants them.
+  dtmf_allowed_ = false;
+  engine()->voe()->codec()->SetVADStatus(voe_channel(), false);
+  engine()->voe()->rtp()->SetFECStatus(voe_channel(), false);
+
+  // Scan through the list to figure out the codec to use for sending, along
+  // with the proper configuration for VAD and DTMF.
+  bool first = true;
+  webrtc::CodecInst send_codec;
+  memset(&send_codec, 0, sizeof(send_codec));
+
+  for (std::vector<AudioCodec>::const_iterator i = codecs.begin();
+       i != codecs.end(); ++i) {
+    // Ignore codecs we don't know about. The negotiation step should prevent
+    // this, but double-check to be sure.
+    webrtc::CodecInst gcodec;
+    if (!engine()->FindWebRtcCodec(*i, &gcodec)) {
+      LOG(LS_WARNING) << "Unknown codec " << i->name;
+      continue;
+    }
+
+    // Find the DTMF telephone event "codec" and tell VoiceEngine about it.
+    if (i->name == "telephone-event" || i->name == "audio/telephone-event") {
+      engine()->voe()->dtmf()->SetSendTelephoneEventPayloadType(
+          voe_channel(), i->id);
+      dtmf_allowed_ = true;
+    }
+
+    // Turn voice activity detection/comfort noise on if supported.
+    // Set the wideband CN payload type appropriately.
+    // (narrowband always uses the static payload type 13).
+    if (i->name == "CN") {
+      webrtc::PayloadFrequencies cn_freq;
+      switch (i->clockrate) {
+        case 8000:
+          cn_freq = webrtc::kFreq8000Hz;
+          break;
+        case 16000:
+          cn_freq = webrtc::kFreq16000Hz;
+          break;
+        case 32000:
+          cn_freq = webrtc::kFreq32000Hz;
+          break;
+        default:
+          LOG(LS_WARNING) << "CN frequency " << i->clockrate
+                          << " not supported.";
+          continue;
+      }
+      engine()->voe()->codec()->SetVADStatus(voe_channel(), true);
+      if (cn_freq != webrtc::kFreq8000Hz) {
+        engine()->voe()->codec()->SetSendCNPayloadType(voe_channel(),
+                                                       i->id, cn_freq);
+      }
+    }
+
+    // We'll use the first codec in the list to actually send audio data.
+    // Be sure to use the payload type requested by the remote side.
+    // "red", for FEC audio, is a special case where the actual codec to be
+    // used is specified in params.
+    if (first) {
+      if (i->name == "red") {
+        // Parse out the RED parameters. If we fail, just ignore RED;
+        // we don't support all possible params/usage scenarios.
+        if (!GetRedSendCodec(*i, codecs, &send_codec)) {
+          continue;
+        }
+
+        // Enable redundant encoding of the specified codec. Treat any
+        // failure as a fatal internal error.
+        LOG(LS_INFO) << "Enabling RED";
+        if (engine()->voe()->rtp()->SetFECStatus(voe_channel(),
+                                                    true, i->id) == -1) {
+          LOG_RTCERR3(SetFECStatus, voe_channel(), true, i->id);
+          return false;
+        }
+      } else {
+        send_codec = gcodec;
+        send_codec.pltype = i->id;
+      }
+      first = false;
+    }
+  }
+
+  // If we're being asked to set an empty list of codecs, due to a buggy client,
+  // choose the most common format: PCMU
+  if (first) {
+    LOG(LS_WARNING) << "Received empty list of codecs; using PCMU/8000";
+    AudioCodec codec(0, "PCMU", 8000, 0, 1, 0);
+    engine()->FindWebRtcCodec(codec, &send_codec);
+  }
+
+  // Set the codec.
+  LOG(LS_INFO) << "Selected voice codec " << send_codec.plname
+            << "/" << send_codec.plfreq;
+  if (engine()->voe()->codec()->SetSendCodec(voe_channel(),
+                                                send_codec) == -1) {
+    LOG_RTCERR1(SetSendCodec, voe_channel());
+    return false;
+  }
+
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::SetRecvRtpHeaderExtensions(
+    const std::vector<RtpHeaderExtension>& extensions) {
+  // We don't support any incoming extensions headers right now.
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::SetSendRtpHeaderExtensions(
+    const std::vector<RtpHeaderExtension>& extensions) {
+  // Enable the audio level extension header if requested.
+  std::vector<RtpHeaderExtension>::const_iterator it;
+  for (it = extensions.begin(); it != extensions.end(); ++it) {
+    if (it->uri == kRtpAudioLevelHeaderExtension) {
+      break;
+    }
+  }
+
+  bool enable = (it != extensions.end());
+  int id = 0;
+
+  if (enable) {
+    id = it->id;
+    if (id < kMinRtpHeaderExtensionId ||
+        id > kMaxRtpHeaderExtensionId) {
+      LOG(LS_WARNING) << "Invalid RTP header extension id " << id;
+      return false;
+    }
+  }
+
+// This api call is not available in iOS version of VoiceEngine currently.
+#if !defined(IOS) && !defined(ANDROID)
+  if (engine()->voe()->rtp()->SetRTPAudioLevelIndicationStatus(
+      voe_channel(), enable, id) == -1) {
+    LOG_RTCERR3(SetRTPAudioLevelIndicationStatus, voe_channel(), enable, id);
+    return false;
+  }
+#endif
+
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::SetPlayout(bool playout) {
+  desired_playout_ = playout;
+  return ChangePlayout(desired_playout_);
+}
+
+bool WebRtcVoiceMediaChannel::PausePlayout() {
+  return ChangePlayout(false);
+}
+
+bool WebRtcVoiceMediaChannel::ResumePlayout() {
+  return ChangePlayout(desired_playout_);
+}
+
+bool WebRtcVoiceMediaChannel::ChangePlayout(bool playout) {
+  if (playout_ == playout) {
+    return true;
+  }
+
+  bool result = true;
+  if (mux_channels_.empty()) {
+    // Only toggle the default channel if we don't have any other channels.
+    result = SetPlayout(voe_channel(), playout);
+  }
+  for (ChannelMap::iterator it = mux_channels_.begin();
+       it != mux_channels_.end() && result; ++it) {
+    if (!SetPlayout(it->second, playout)) {
+      LOG(LS_ERROR) << "SetPlayout " << playout << " on channel " << it->second
+                    << " failed";
+      result = false;
+    }
+  }
+
+  if (result) {
+    playout_ = playout;
+  }
+  return result;
+}
+
+bool WebRtcVoiceMediaChannel::SetSend(SendFlags send) {
+  desired_send_ = send;
+  return ChangeSend(desired_send_);
+}
+
+bool WebRtcVoiceMediaChannel::PauseSend() {
+  return ChangeSend(SEND_NOTHING);
+}
+
+bool WebRtcVoiceMediaChannel::ResumeSend() {
+  return ChangeSend(desired_send_);
+}
+
+bool WebRtcVoiceMediaChannel::ChangeSend(SendFlags send) {
+  if (send_ == send) {
+    return true;
+  }
+
+  if (send == SEND_MICROPHONE) {
+#ifdef CHROMEOS
+    // Conference mode doesn't work well on ChromeOS.
+    if (!engine()->SetConferenceMode(false)) {
+      LOG_RTCERR1(SetConferenceMode, voe_channel());
+      return false;
+    }
+#else
+    // Multi-point conferences use conference-mode noise filtering.
+    if (!engine()->SetConferenceMode(
+        0 != (channel_options_ & OPT_CONFERENCE))) {
+      LOG_RTCERR1(SetConferenceMode, voe_channel());
+      return false;
+    }
+#endif  // CHROMEOS
+
+    // Tandberg-bridged conferences have an AGC target that is lower than
+    // GTV-only levels.
+    if ((channel_options_ & OPT_AGC_TANDBERG_LEVELS) && !agc_adjusted_) {
+      if (engine()->AdjustAgcLevel(kTandbergDbAdjustment)) {
+        agc_adjusted_ = true;
+      }
+    }
+
+    // VoiceEngine resets sequence number when StopSend is called. This
+    // sometimes causes libSRTP to complain about packets being
+    // replayed. To get around this we store the last sent sequence
+    // number and initializes the channel with the next to continue on
+    // the same sequence.
+    if (sequence_number() != -1) {
+      LOG(LS_INFO) << "WebRtcVoiceMediaChannel restores seqnum="
+                   << sequence_number() + 1;
+      if (engine()->voe()->sync()->SetInitSequenceNumber(
+              voe_channel(), sequence_number() + 1) == -1) {
+        LOG_RTCERR2(SetInitSequenceNumber, voe_channel(),
+                    sequence_number() + 1);
+      }
+    }
+    if (engine()->voe()->base()->StartSend(voe_channel()) == -1) {
+      LOG_RTCERR1(StartSend, voe_channel());
+      return false;
+    }
+    if (engine()->voe()->file()->StopPlayingFileAsMicrophone(
+        voe_channel()) == -1) {
+      LOG_RTCERR1(StopPlayingFileAsMicrophone, voe_channel());
+      return false;
+    }
+  } else if (send == SEND_RINGBACKTONE) {
+    ASSERT(ringback_tone_.get() != NULL);
+    if (!ringback_tone_.get()) {
+      return false;
+    }
+    if (engine()->voe()->file()->StartPlayingFileAsMicrophone(
+        voe_channel(), ringback_tone_.get(), false) == -1) {
+      LOG_RTCERR3(StartPlayingFileAsMicrophone, voe_channel(),
+                  ringback_tone_.get(), false);
+      return false;
+    }
+    // VoiceEngine resets sequence number when StopSend is called. This
+    // sometimes causes libSRTP to complain about packets being
+    // replayed. To get around this we store the last sent sequence
+    // number and initializes the channel with the next to continue on
+    // the same sequence.
+    if (sequence_number() != -1) {
+      LOG(LS_INFO) << "WebRtcVoiceMediaChannel restores seqnum="
+                   << sequence_number() + 1;
+      if (engine()->voe()->sync()->SetInitSequenceNumber(
+              voe_channel(), sequence_number() + 1) == -1) {
+        LOG_RTCERR2(SetInitSequenceNumber, voe_channel(),
+                    sequence_number() + 1);
+      }
+    }
+    if (engine()->voe()->base()->StartSend(voe_channel()) == -1) {
+      LOG_RTCERR1(StartSend, voe_channel());
+      return false;
+    }
+  } else {  // SEND_NOTHING
+    if (engine()->voe()->base()->StopSend(voe_channel()) == -1) {
+      LOG_RTCERR1(StopSend, voe_channel());
+    }
+
+    // Reset the AGC level, if it was set.
+    if (agc_adjusted_) {
+      if (engine()->AdjustAgcLevel(0)) {
+        agc_adjusted_ = false;
+      }
+    }
+
+    // Disable conference-mode noise filtering.
+    if (!engine()->SetConferenceMode(false)) {
+      LOG_RTCERR1(SetConferenceMode, voe_channel());
+    }
+  }
+  send_ = send;
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::AddStream(uint32 ssrc) {
+  talk_base::CritScope lock(&mux_channels_cs_);
+
+  if (mux_channels_.find(ssrc) != mux_channels_.end()) {
+    return false;
+  }
+
+  // Create a new channel for receiving audio data.
+  int channel = engine()->voe()->base()->CreateChannel();
+  if (channel == -1) {
+    LOG_RTCERR0(CreateChannel);
+    return false;
+  }
+
+  // Configure to use external transport, like our default channel.
+  if (engine()->voe()->network()->RegisterExternalTransport(
+          channel, *this) == -1) {
+    LOG_RTCERR2(SetExternalTransport, channel, this);
+    return false;
+  }
+
+  // Use the same SSRC as our default channel (so the RTCP reports are correct).
+  unsigned int send_ssrc;
+  webrtc::VoERTP_RTCP* rtp = engine()->voe()->rtp();
+  if (rtp->GetLocalSSRC(voe_channel(), send_ssrc) == -1) {
+    LOG_RTCERR2(GetSendSSRC, channel, send_ssrc);
+    return false;
+  }
+  if (rtp->SetLocalSSRC(channel, send_ssrc) == -1) {
+    LOG_RTCERR2(SetSendSSRC, channel, send_ssrc);
+    return false;
+  }
+
+  if (mux_channels_.empty() && playout_) {
+    // This is the first stream in a multi user meeting. We can now
+    // disable playback of the default stream. This since the default
+    // stream will probably have received some initial packets before
+    // the new stream was added. This will mean that the CN state from
+    // the default channel will be mixed in with the other streams
+    // throughout the whole meeting, which might be disturbing.
+    LOG(LS_INFO) << "Disabling playback on the default voice channel";
+    SetPlayout(voe_channel(), false);
+  }
+
+  mux_channels_[ssrc] = channel;
+
+  // TODO: We should rollback the add if SetPlayout fails.
+  LOG(LS_INFO) << "New audio stream " << ssrc
+            << " registered to VoiceEngine channel #"
+            << channel << ".";
+  return SetPlayout(channel, playout_);
+}
+
+bool WebRtcVoiceMediaChannel::RemoveStream(uint32 ssrc) {
+  talk_base::CritScope lock(&mux_channels_cs_);
+  ChannelMap::iterator it = mux_channels_.find(ssrc);
+
+  if (it != mux_channels_.end()) {
+    if (engine()->voe()->network()->DeRegisterExternalTransport(
+        it->second) == -1) {
+      LOG_RTCERR1(DeRegisterExternalTransport, it->second);
+    }
+
+    LOG(LS_INFO) << "Removing audio stream " << ssrc
+              << " with VoiceEngine channel #"
+              << it->second << ".";
+    if (engine()->voe()->base()->DeleteChannel(it->second) == -1) {
+      LOG_RTCERR1(DeleteChannel, voe_channel());
+      return false;
+    }
+
+    mux_channels_.erase(it);
+    if (mux_channels_.empty() && playout_) {
+      // The last stream was removed. We can now enable the default
+      // channel for new channels to be played out immediately without
+      // waiting for AddStream messages.
+      // TODO: Does the default channel still have it's CN state?
+      LOG(LS_INFO) << "Enabling playback on the default voice channel";
+      SetPlayout(voe_channel(), true);
+    }
+  }
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::GetActiveStreams(
+    AudioInfo::StreamList* actives) {
+  actives->clear();
+  for (ChannelMap::iterator it = mux_channels_.begin();
+       it != mux_channels_.end(); ++it) {
+    int level = GetOutputLevel(it->second);
+    if (level > 0) {
+      actives->push_back(std::make_pair(it->first, level));
+    }
+  }
+  return true;
+}
+
+int WebRtcVoiceMediaChannel::GetOutputLevel() {
+  // return the highest output level of all streams
+  int highest = GetOutputLevel(voe_channel());
+  for (ChannelMap::iterator it = mux_channels_.begin();
+       it != mux_channels_.end(); ++it) {
+    int level = GetOutputLevel(it->second);
+    highest = talk_base::_max(level, highest);
+  }
+  return highest;
+}
+
+
+bool WebRtcVoiceMediaChannel::SetOutputScaling(
+    uint32 ssrc, double left, double right) {
+  talk_base::CritScope lock(&mux_channels_cs_);
+  // Collect the channels to scale the output volume.
+  std::vector<int> channels;
+  if (0 == ssrc) {  // Collect all channels, including the default one.
+    channels.push_back(voe_channel());
+    for (ChannelMap::const_iterator it = mux_channels_.begin();
+        it != mux_channels_.end(); ++it) {
+      channels.push_back(it->second);
+    }
+  } else {  // Collect only the channel of the specified ssrc.
+    int channel = GetChannel(ssrc);
+    if (-1 == channel) {
+      LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
+      return false;
+    }
+    channels.push_back(channel);
+  }
+
+  // Scale the output volume for the collected channels. We first normalize to
+  // scale the volume and then set the left and right pan.
+  float scale = static_cast<float>(talk_base::_max(left, right));
+  if (scale > 0.0001f) {
+    left /= scale;
+    right /= scale;
+  }
+  for (std::vector<int>::const_iterator it = channels.begin();
+      it != channels.end(); ++it) {
+    if (-1 == engine()->voe()->volume()->SetChannelOutputVolumeScaling(
+        *it, scale)) {
+      LOG_RTCERR2(SetChannelOutputVolumeScaling, *it, scale);
+      return false;
+    }
+    if (-1 == engine()->voe()->volume()->SetOutputVolumePan(
+        *it, static_cast<float>(left), static_cast<float>(right))) {
+      LOG_RTCERR3(SetOutputVolumePan, *it, left, right);
+      // Do not return if fails. SetOutputVolumePan is not available for all
+      // pltforms.
+    }
+    LOG(LS_INFO) << "SetOutputScaling to left=" << left * scale
+                 << " right=" << right * scale
+                 << " for channel " << *it << " and ssrc " << ssrc;
+  }
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::GetOutputScaling(
+    uint32 ssrc, double* left, double* right) {
+  if (!left || !right) return false;
+
+  talk_base::CritScope lock(&mux_channels_cs_);
+  // Determine which channel based on ssrc.
+  int channel = (0 == ssrc) ? voe_channel() : GetChannel(ssrc);
+  if (channel == -1) {
+    LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
+    return false;
+  }
+
+  float scaling;
+  if (-1 == engine()->voe()->volume()->GetChannelOutputVolumeScaling(
+      channel, scaling)) {
+    LOG_RTCERR2(GetChannelOutputVolumeScaling, channel, scaling);
+    return false;
+  }
+
+  float left_pan;
+  float right_pan;
+  if (-1 == engine()->voe()->volume()->GetOutputVolumePan(
+      channel, left_pan, right_pan)) {
+    LOG_RTCERR3(GetOutputVolumePan, channel, left_pan, right_pan);
+    // If GetOutputVolumePan fails, we use the default left and right pan.
+    left_pan = 1.0f;
+    right_pan = 1.0f;
+  }
+
+  *left = scaling * left_pan;
+  *right = scaling * right_pan;
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::SetRingbackTone(const char *buf, int len) {
+  ringback_tone_.reset(new WebRtcSoundclipStream(buf, len));
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::PlayRingbackTone(uint32 ssrc,
+                                             bool play, bool loop) {
+  if (!ringback_tone_.get()) {
+    return false;
+  }
+
+  // Determine which VoiceEngine channel to play on.
+  int channel = (ssrc == 0) ? voe_channel() : GetChannel(ssrc);
+  if (channel == -1) {
+    return false;
+  }
+
+  // Make sure the ringtone is cued properly, and play it out.
+  if (play) {
+    ringback_tone_->set_loop(loop);
+    ringback_tone_->Rewind();
+    if (engine()->voe()->file()->StartPlayingFileLocally(channel,
+        ringback_tone_.get()) == -1) {
+      LOG_RTCERR2(StartPlayingFileLocally, channel, ringback_tone_.get());
+      LOG(LS_ERROR) << "Unable to start ringback tone";
+      return false;
+    }
+    ringback_channels_.insert(channel);
+    LOG(LS_INFO) << "Started ringback on channel " << channel;
+  } else {
+    if (engine()->voe()->file()->StopPlayingFileLocally(channel)
+        == -1) {
+      LOG_RTCERR1(StopPlayingFileLocally, channel);
+      return false;
+    }
+    LOG(LS_INFO) << "Stopped ringback on channel " << channel;
+    ringback_channels_.erase(channel);
+  }
+
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::PressDTMF(int event, bool playout) {
+  if (!dtmf_allowed_) {
+    return false;
+  }
+
+  // Enable or disable DTMF playout of this tone as requested. This will linger
+  // until the next call to this method, but that's OK.
+  if (engine()->voe()->dtmf()->SetDtmfFeedbackStatus(playout) == -1) {
+    LOG_RTCERR2(SendDTMF, voe_channel(), playout);
+    return false;
+  }
+
+  // Send DTMF using out-of-band DTMF. ("true", as 3rd arg)
+  if (engine()->voe()->dtmf()->SendTelephoneEvent(voe_channel(), event,
+      true) == -1) {
+    LOG_RTCERR3(SendDTMF, voe_channel(), event, true);
+    return false;
+  }
+
+  return true;
+}
+
+void WebRtcVoiceMediaChannel::OnPacketReceived(talk_base::Buffer* packet) {
+  // Pick which channel to send this packet to. If this packet doesn't match
+  // any multiplexed streams, just send it to the default channel. Otherwise,
+  // send it to the specific decoder instance for that stream.
+  int which_channel = GetChannel(
+      ParseSsrc(packet->data(), packet->length(), false));
+  if (which_channel == -1) {
+    which_channel = voe_channel();
+  }
+
+  // Stop any ringback that might be playing on the channel.
+  // It's possible the ringback has already stopped, ih which case we'll just
+  // use the opportunity to remove the channel from ringback_channels_.
+  const std::set<int>::iterator it = ringback_channels_.find(which_channel);
+  if (it != ringback_channels_.end()) {
+    if (engine()->voe()->file()->IsPlayingFileLocally(
+        which_channel) == 1) {
+      engine()->voe()->file()->StopPlayingFileLocally(which_channel);
+      LOG(LS_INFO) << "Stopped ringback on channel " << which_channel
+                   << " due to incoming media";
+    }
+    ringback_channels_.erase(which_channel);
+  }
+
+  // Pass it off to the decoder.
+  engine()->voe()->network()->ReceivedRTPPacket(which_channel,
+                                                   packet->data(),
+                                                   packet->length());
+}
+
+void WebRtcVoiceMediaChannel::OnRtcpReceived(talk_base::Buffer* packet) {
+  // See above.
+  int which_channel = GetChannel(
+      ParseSsrc(packet->data(), packet->length(), true));
+  if (which_channel == -1) {
+    which_channel = voe_channel();
+  }
+
+  engine()->voe()->network()->ReceivedRTCPPacket(which_channel,
+                                                    packet->data(),
+                                                    packet->length());
+}
+
+void WebRtcVoiceMediaChannel::SetSendSsrc(uint32 ssrc) {
+  if (engine()->voe()->rtp()->SetLocalSSRC(voe_channel(), ssrc)
+      == -1) {
+     LOG_RTCERR2(SetSendSSRC, voe_channel(), ssrc);
+  }
+}
+
+bool WebRtcVoiceMediaChannel::SetRtcpCName(const std::string& cname) {
+  if (engine()->voe()->rtp()->SetRTCP_CNAME(voe_channel(),
+                                                    cname.c_str()) == -1) {
+     LOG_RTCERR2(SetRTCP_CNAME, voe_channel(), cname);
+     return false;
+  }
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::Mute(bool muted) {
+  if (engine()->voe()->volume()->SetInputMute(voe_channel(),
+      muted) == -1) {
+    LOG_RTCERR2(SetInputMute, voe_channel(), muted);
+    return false;
+  }
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::GetStats(VoiceMediaInfo* info) {
+  // In VoiceEngine 3.5, GetRTCPStatistics will return 0 even when it fails,
+  // causing the stats to contain garbage information. To prevent this, we
+  // zero the stats structure before calling this API.
+  // TODO: Remove this workaround.
+  webrtc::CallStatistics cs;
+  unsigned int ssrc;
+  webrtc::CodecInst codec;
+  unsigned int level;
+
+  // Fill in the sender info, based on what we know, and what the
+  // remote side told us it got from its RTCP report.
+  VoiceSenderInfo sinfo;
+  memset(&sinfo, 0, sizeof(sinfo));
+
+  // Data we obtain locally.
+  memset(&cs, 0, sizeof(cs));
+  if (engine()->voe()->rtp()->GetRTCPStatistics(voe_channel(), cs) == -1 ||
+      engine()->voe()->rtp()->GetLocalSSRC(voe_channel(), ssrc) == -1) {
+    return false;
+  }
+
+  sinfo.ssrc = ssrc;
+  sinfo.bytes_sent = cs.bytesSent;
+  sinfo.packets_sent = cs.packetsSent;
+  // RTT isn't known until a RTCP report is received. Until then, VoiceEngine
+  // returns 0 to indicate an error value.
+  sinfo.rtt_ms = (cs.rttMs > 0) ? cs.rttMs : -1;
+
+  // Data from the last remote RTCP report.
+  unsigned int ntp_high, ntp_low, timestamp, ptimestamp, jitter;
+  unsigned short loss;  // NOLINT
+  if (engine()->voe()->rtp()->GetRemoteRTCPData(voe_channel(),
+          ntp_high, ntp_low, timestamp, ptimestamp, &jitter, &loss) != -1 &&
+      engine()->voe()->codec()->GetSendCodec(voe_channel(),
+          codec) != -1) {
+    // Convert Q8 to floating point.
+    sinfo.fraction_lost = static_cast<float>(loss) / (1 << 8);
+    // Convert samples to milliseconds.
+    if (codec.plfreq / 1000 > 0) {
+      sinfo.jitter_ms = jitter / (codec.plfreq / 1000);
+    }
+  } else {
+    sinfo.fraction_lost = -1;
+    sinfo.jitter_ms = -1;
+  }
+  // TODO: Figure out how to get remote packets_lost, ext_seqnum
+  sinfo.packets_lost = -1;
+  sinfo.ext_seqnum = -1;
+
+  // Local speech level.
+  sinfo.audio_level = (engine()->voe()->volume()->
+      GetSpeechInputLevelFullRange(level) != -1) ? level : -1;
+  info->senders.push_back(sinfo);
+
+  // Build the list of receivers, one for each mux channel, or 1 in a 1:1 call.
+  std::vector<int> channels;
+  for (ChannelMap::const_iterator it = mux_channels_.begin();
+       it != mux_channels_.end(); ++it) {
+    channels.push_back(it->second);
+  }
+  if (channels.empty()) {
+    channels.push_back(voe_channel());
+  }
+
+  // Get the SSRC and stats for each receiver, based on our own calculations.
+  for (std::vector<int>::const_iterator it = channels.begin();
+       it != channels.end(); ++it) {
+    memset(&cs, 0, sizeof(cs));
+    if (engine()->voe()->rtp()->GetRemoteSSRC(*it, ssrc) != -1 &&
+        engine()->voe()->rtp()->GetRTCPStatistics(*it, cs) != -1 &&
+        engine()->voe()->codec()->GetRecCodec(*it, codec) != -1) {
+      VoiceReceiverInfo rinfo;
+      memset(&rinfo, 0, sizeof(rinfo));
+      rinfo.ssrc = ssrc;
+      rinfo.bytes_rcvd = cs.bytesReceived;
+      rinfo.packets_rcvd = cs.packetsReceived;
+      // The next four fields are from the most recently sent RTCP report.
+      // Convert Q8 to floating point.
+      rinfo.fraction_lost = static_cast<float>(cs.fractionLost) / (1 << 8);
+      rinfo.packets_lost = cs.cumulativeLost;
+      rinfo.ext_seqnum = cs.extendedMax;
+      // Convert samples to milliseconds.
+      if (codec.plfreq / 1000 > 0) {
+        rinfo.jitter_ms = cs.jitterSamples / (codec.plfreq / 1000);
+      }
+
+      // Get jitter buffer and total delay (alg + jitter + playout) stats.
+      webrtc::NetworkStatistics ns;
+      if (engine()->voe()->neteq() &&
+          engine()->voe()->neteq()->GetNetworkStatistics(
+              *it, ns) != -1) {
+        rinfo.jitter_buffer_ms = ns.currentBufferSize;
+        rinfo.jitter_buffer_preferred_ms = ns.preferredBufferSize;
+      }
+      if (engine()->voe()->sync()) {
+        engine()->voe()->sync()->GetDelayEstimate(*it,
+            rinfo.delay_estimate_ms);
+      }
+
+      // Get speech level.
+      rinfo.audio_level = (engine()->voe()->volume()->
+          GetSpeechOutputLevelFullRange(*it, level) != -1) ? level : -1;
+      info->receivers.push_back(rinfo);
+    }
+  }
+
+  return true;
+}
+
+void WebRtcVoiceMediaChannel::GetLastMediaError(
+    uint32* ssrc, VoiceMediaChannel::Error* error) {
+  ASSERT(ssrc != NULL);
+  ASSERT(error != NULL);
+  FindSsrc(voe_channel(), ssrc);
+  *error = WebRtcErrorToChannelError(GetLastEngineError());
+}
+
+bool WebRtcVoiceMediaChannel::FindSsrc(int channel_num, uint32* ssrc) {
+  talk_base::CritScope lock(&mux_channels_cs_);
+  ASSERT(ssrc != NULL);
+  if (channel_num == voe_channel()) {
+    unsigned local_ssrc = 0;
+    // This is a sending channel.
+    if (engine()->voe()->rtp()->GetLocalSSRC(
+        channel_num, local_ssrc) != -1) {
+      *ssrc = local_ssrc;
+    }
+    return true;
+  } else if (channel_num == -1 && send_ != SEND_NOTHING) {
+    // Sometimes the VoiceEngine core will throw error with channel_num = -1.
+    // This means the error is not limited to a specific channel.  Signal the
+    // message using ssrc=0.  If the current channel is sending, use this
+    // channel for sending the message.
+    *ssrc = 0;
+    return true;
+  } else {
+    // Check whether this is a receiving channel.
+    for (ChannelMap::const_iterator it = mux_channels_.begin();
+        it != mux_channels_.end(); ++it) {
+      if (it->second == channel_num) {
+        *ssrc = it->first;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void WebRtcVoiceMediaChannel::OnError(uint32 ssrc, int error) {
+  SignalMediaError(ssrc, WebRtcErrorToChannelError(error));
+}
+
+int WebRtcVoiceMediaChannel::GetOutputLevel(int channel) {
+  unsigned int ulevel;
+  int ret =
+      engine()->voe()->volume()->GetSpeechOutputLevel(channel, ulevel);
+  return (ret == 0) ? static_cast<int>(ulevel) : -1;
+}
+
+int WebRtcVoiceMediaChannel::GetChannel(uint32 ssrc) {
+  ChannelMap::iterator it = mux_channels_.find(ssrc);
+  return (it != mux_channels_.end()) ? it->second : -1;
+}
+
+bool WebRtcVoiceMediaChannel::GetRedSendCodec(const AudioCodec& red_codec,
+    const std::vector<AudioCodec>& all_codecs, webrtc::CodecInst* send_codec) {
+  // Get the RED encodings from the parameter with no name. This may
+  // change based on what is discussed on the Jingle list.
+  // The encoding parameter is of the form "a/b"; we only support where
+  // a == b. Verify this and parse out the value into red_pt.
+  // If the parameter value is absent (as it will be until we wire up the
+  // signaling of this message), use the second codec specified (i.e. the
+  // one after "red") as the encoding parameter.
+  int red_pt = -1;
+  std::string red_params;
+  CodecParameterMap::const_iterator it = red_codec.params.find("");
+  if (it != red_codec.params.end()) {
+    red_params = it->second;
+    std::vector<std::string> red_pts;
+    if (talk_base::split(red_params, '/', &red_pts) != 2 ||
+        red_pts[0] != red_pts[1] ||
+        !talk_base::FromString(red_pts[0], &red_pt)) {
+      LOG(LS_WARNING) << "RED params " << red_params << " not supported.";
+      return false;
+    }
+  } else if (red_codec.params.empty()) {
+    LOG(LS_WARNING) << "RED params not present, using defaults";
+    if (all_codecs.size() > 1) {
+      red_pt = all_codecs[1].id;
+    }
+  }
+
+  // Try to find red_pt in |codecs|.
+  std::vector<AudioCodec>::const_iterator codec;
+  for (codec = all_codecs.begin(); codec != all_codecs.end(); ++codec) {
+    if (codec->id == red_pt)
+      break;
+  }
+
+  // If we find the right codec, that will be the codec we pass to
+  // SetSendCodec, with the desired payload type.
+  if (codec != all_codecs.end() &&
+    engine()->FindWebRtcCodec(*codec, send_codec)) {
+    send_codec->pltype = red_pt;
+  } else {
+    LOG(LS_WARNING) << "RED params " << red_params << " are invalid.";
+    return false;
+  }
+
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::EnableRtcp(int channel) {
+  if (engine()->voe()->rtp()->SetRTCPStatus(channel, true) == -1) {
+    LOG_RTCERR2(SetRTCPStatus, voe_channel(), 1);
+    return false;
+  }
+  // TODO: Enable VQMon and RTCP XR reports, once we know what
+  // what we want to do with them.
+  // engine()->voe().EnableVQMon(voe_channel(), true);
+  // engine()->voe().EnableRTCP_XR(voe_channel(), true);
+  return true;
+}
+
+bool WebRtcVoiceMediaChannel::SetPlayout(int channel, bool playout) {
+  if (playout) {
+    LOG(LS_INFO) << "Starting playout for channel #" << channel;
+    if (engine()->voe()->base()->StartPlayout(channel) == -1) {
+      LOG_RTCERR1(StartPlayout, channel);
+      return false;
+    }
+  } else {
+    LOG(LS_INFO) << "Stopping playout for channel #" << channel;
+    engine()->voe()->base()->StopPlayout(channel);
+  }
+  return true;
+}
+
+uint32 WebRtcVoiceMediaChannel::ParseSsrc(const void* data, size_t len,
+                                        bool rtcp) {
+  size_t ssrc_pos = (!rtcp) ? 8 : 4;
+  uint32 ssrc = 0;
+  if (len >= (ssrc_pos + sizeof(ssrc))) {
+    ssrc = talk_base::GetBE32(static_cast<const char*>(data) + ssrc_pos);
+  }
+  return ssrc;
+}
+
+// Convert VoiceEngine error code into VoiceMediaChannel::Error enum.
+VoiceMediaChannel::Error
+    WebRtcVoiceMediaChannel::WebRtcErrorToChannelError(int err_code) {
+  switch (err_code) {
+    case 0:
+      return ERROR_NONE;
+    case VE_CANNOT_START_RECORDING:
+    case VE_MIC_VOL_ERROR:
+    case VE_GET_MIC_VOL_ERROR:
+    case VE_CANNOT_ACCESS_MIC_VOL:
+      return ERROR_REC_DEVICE_OPEN_FAILED;
+    case VE_SATURATION_WARNING:
+      return ERROR_REC_DEVICE_SATURATION;
+    case VE_REC_DEVICE_REMOVED:
+      return ERROR_REC_DEVICE_REMOVED;
+    case VE_RUNTIME_REC_WARNING:
+    case VE_RUNTIME_REC_ERROR:
+      return ERROR_REC_RUNTIME_ERROR;
+    case VE_CANNOT_START_PLAYOUT:
+    case VE_SPEAKER_VOL_ERROR:
+    case VE_GET_SPEAKER_VOL_ERROR:
+    case VE_CANNOT_ACCESS_SPEAKER_VOL:
+      return ERROR_PLAY_DEVICE_OPEN_FAILED;
+    case VE_RUNTIME_PLAY_WARNING:
+    case VE_RUNTIME_PLAY_ERROR:
+      return ERROR_PLAY_RUNTIME_ERROR;
+    case VE_TYPING_NOISE_WARNING:
+      return ERROR_REC_TYPING_NOISE_DETECTED;
+    default:
+      return VoiceMediaChannel::ERROR_OTHER;
+  }
+}
+
+int WebRtcSoundclipStream::Read(void *buf, int len) {
+  size_t res = 0;
+  mem_.Read(buf, len, &res, NULL);
+  return res;
+}
+
+int WebRtcSoundclipStream::Rewind() {
+  mem_.Rewind();
+  // Return -1 to keep VoiceEngine from looping.
+  return (loop_) ? 0 : -1;
+}
+
+}  // namespace cricket
+
+#endif  // HAVE_WEBRTC_VOICE
diff --git a/talk/session/phone/webrtcvoiceengine.h b/talk/session/phone/webrtcvoiceengine.h
new file mode 100644
index 0000000..8234b9b
--- /dev/null
+++ b/talk/session/phone/webrtcvoiceengine.h
@@ -0,0 +1,323 @@
+/*
+ * libjingle
+ * Copyright 2004--2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_SESSION_PHONE_WEBRTCVOICEENGINE_H_
+#define TALK_SESSION_PHONE_WEBRTCVOICEENGINE_H_
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "talk/base/buffer.h"
+#include "talk/base/byteorder.h"
+#include "talk/base/logging.h"
+#include "talk/base/scoped_ptr.h"
+#include "talk/base/stream.h"
+#include "talk/session/phone/channel.h"
+#include "talk/session/phone/rtputils.h"
+#include "talk/session/phone/webrtccommon.h"
+
+namespace cricket {
+
+// WebRtcSoundclipStream is an adapter object that allows a memory stream to be
+// passed into WebRtc, and support looping.
+class WebRtcSoundclipStream : public webrtc::InStream {
+ public:
+  WebRtcSoundclipStream(const char* buf, size_t len)
+      : mem_(buf, len), loop_(true) {
+  }
+  void set_loop(bool loop) { loop_ = loop; }
+  virtual int Read(void* buf, int len);
+  virtual int Rewind();
+
+ private:
+  talk_base::MemoryStream mem_;
+  bool loop_;
+};
+
+// WebRtcMonitorStream is used to monitor a stream coming from WebRtc.
+// For now we just dump the data.
+class WebRtcMonitorStream : public webrtc::OutStream {
+  virtual bool Write(const void *buf, int len) {
+    return true;
+  }
+};
+
+class AudioDeviceModule;
+class VoETraceWrapper;
+class VoEWrapper;
+class WebRtcSoundclipMedia;
+class WebRtcVoiceMediaChannel;
+
+// WebRtcVoiceEngine is a class to be used with CompositeMediaEngine.
+// It uses the WebRtc VoiceEngine library for audio handling.
+class WebRtcVoiceEngine
+    : public webrtc::VoiceEngineObserver,
+      public webrtc::TraceCallback {
+ public:
+  WebRtcVoiceEngine();
+  WebRtcVoiceEngine(webrtc::AudioDeviceModule* adm,
+                    webrtc::AudioDeviceModule* adm_sc);
+  // Dependency injection for testing.
+  WebRtcVoiceEngine(VoEWrapper* voe_wrapper,
+                    VoEWrapper* voe_wrapper_sc,
+                    VoETraceWrapper* tracing);
+  ~WebRtcVoiceEngine();
+  bool Init();
+  void Terminate();
+
+  int GetCapabilities();
+  VoiceMediaChannel* CreateChannel();
+
+  SoundclipMedia* CreateSoundclip();
+
+  bool SetOptions(int options);
+  bool SetDevices(const Device* in_device, const Device* out_device);
+  bool GetOutputVolume(int* level);
+  bool SetOutputVolume(int level);
+  int GetInputLevel();
+  bool SetLocalMonitor(bool enable);
+
+  const std::vector<AudioCodec>& codecs();
+  bool FindCodec(const AudioCodec& codec);
+  bool FindWebRtcCodec(const AudioCodec& codec, webrtc::CodecInst* gcodec);
+
+  void SetLogging(int min_sev, const char* filter);
+
+  // For tracking WebRtc channels. Needed because we have to pause them
+  // all when switching devices.
+  // May only be called by WebRtcVoiceMediaChannel.
+  void RegisterChannel(WebRtcVoiceMediaChannel *channel);
+  void UnregisterChannel(WebRtcVoiceMediaChannel *channel);
+
+  // May only be called by WebRtcSoundclipMedia.
+  void RegisterSoundclip(WebRtcSoundclipMedia *channel);
+  void UnregisterSoundclip(WebRtcSoundclipMedia *channel);
+
+  // Called by WebRtcVoiceMediaChannel to set a gain offset from
+  // the default AGC target level.
+  bool AdjustAgcLevel(int delta);
+
+  // Called by WebRtcVoiceMediaChannel to configure echo cancellation
+  // and noise suppression modes.
+  bool SetConferenceMode(bool enable);
+
+  VoEWrapper* voe() { return voe_wrapper_.get(); }
+  VoEWrapper* voe_sc() { return voe_wrapper_sc_.get(); }
+  int GetLastEngineError();
+
+ private:
+  typedef std::vector<WebRtcSoundclipMedia *> SoundclipList;
+  typedef std::vector<WebRtcVoiceMediaChannel *> ChannelList;
+
+  struct CodecPref {
+    const char* name;
+    int clockrate;
+  };
+
+  void Construct();
+  bool InitInternal();
+  void ApplyLogging(const std::string& log_filter);
+  virtual void Print(const webrtc::TraceLevel level,
+                     const char* trace_string, const int length);
+  virtual void CallbackOnError(const int channel, const int errCode);
+  static int GetCodecPreference(const char *name, int clockrate);
+  // Given the device type, name, and id, find device id. Return true and
+  // set the output parameter rtc_id if successful.
+  bool FindWebRtcAudioDeviceId(
+      bool is_input, const std::string& dev_name, int dev_id, int* rtc_id);
+  bool FindChannelAndSsrc(int channel_num,
+                          WebRtcVoiceMediaChannel** channel,
+                          uint32* ssrc) const;
+  bool ChangeLocalMonitor(bool enable);
+  bool PauseLocalMonitor();
+  bool ResumeLocalMonitor();
+
+  static const int kDefaultLogSeverity = talk_base::LS_WARNING;
+  static const CodecPref kCodecPrefs[];
+
+  // The primary instance of WebRtc VoiceEngine.
+  talk_base::scoped_ptr<VoEWrapper> voe_wrapper_;
+  // A secondary instance, for playing out soundclips (on the 'ring' device).
+  talk_base::scoped_ptr<VoEWrapper> voe_wrapper_sc_;
+  talk_base::scoped_ptr<VoETraceWrapper> tracing_;
+  // The external audio device manager
+  webrtc::AudioDeviceModule* adm_;
+  webrtc::AudioDeviceModule* adm_sc_;
+  int log_level_;
+  std::string log_filter_;
+  bool is_dumping_aec_;
+  std::vector<AudioCodec> codecs_;
+  bool desired_local_monitor_enable_;
+  talk_base::scoped_ptr<WebRtcMonitorStream> monitor_;
+  SoundclipList soundclips_;
+  ChannelList channels_;
+  // channels_ can be read from WebRtc callback thread. We need a lock on that
+  // callback as well as the RegisterChannel/UnregisterChannel.
+  talk_base::CriticalSection channels_cs_;
+  webrtc::AgcConfig default_agc_config_;
+  bool initialized_;
+};
+
+// WebRtcMediaChannel is a class that implements the common WebRtc channel
+// functionality.
+template <class T, class E>
+class WebRtcMediaChannel : public T, public webrtc::Transport {
+ public:
+  WebRtcMediaChannel(E *engine, int channel)
+      : engine_(engine), voe_channel_(channel), sequence_number_(-1) {}
+  E *engine() { return engine_; }
+  int voe_channel() const { return voe_channel_; }
+  bool valid() const { return voe_channel_ != -1; }
+
+ protected:
+  // implements Transport interface
+  virtual int SendPacket(int channel, const void *data, int len) {
+    if (!T::network_interface_) {
+      return -1;
+    }
+
+    // We need to store the sequence number to be able to pick up
+    // the same sequence when the device is restarted.
+    // TODO: Remove when WebRtc has fixed the problem.
+    int seq_num;
+    if (!GetRtpSeqNum(data, len, &seq_num)) {
+      return -1;
+    }
+    if (sequence_number() == -1) {
+      LOG(INFO) << "WebRtcVoiceMediaChannel sends first packet seqnum="
+                << seq_num;
+    }
+    sequence_number_ = seq_num;
+
+    talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+    return T::network_interface_->SendPacket(&packet) ? len : -1;
+  }
+  virtual int SendRTCPPacket(int channel, const void *data, int len) {
+    if (!T::network_interface_) {
+      return -1;
+    }
+
+    talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+    return T::network_interface_->SendRtcp(&packet) ? len : -1;
+  }
+  int sequence_number() const {
+    return sequence_number_;
+  }
+
+ private:
+  E *engine_;
+  int voe_channel_;
+  int sequence_number_;
+};
+
+// WebRtcVoiceMediaChannel is an implementation of VoiceMediaChannel that uses
+// WebRtc Voice Engine.
+class WebRtcVoiceMediaChannel
+    : public WebRtcMediaChannel<VoiceMediaChannel,
+                                WebRtcVoiceEngine> {
+ public:
+  explicit WebRtcVoiceMediaChannel(WebRtcVoiceEngine *engine);
+  virtual ~WebRtcVoiceMediaChannel();
+  virtual bool SetOptions(int options);
+  virtual bool SetRecvCodecs(const std::vector<AudioCodec> &codecs);
+  virtual bool SetSendCodecs(const std::vector<AudioCodec> &codecs);
+  virtual bool SetRecvRtpHeaderExtensions(
+      const std::vector<RtpHeaderExtension>& extensions);
+  virtual bool SetSendRtpHeaderExtensions(
+      const std::vector<RtpHeaderExtension>& extensions);
+  virtual bool SetPlayout(bool playout);
+  bool PausePlayout();
+  bool ResumePlayout();
+  virtual bool SetSend(SendFlags send);
+  bool PauseSend();
+  bool ResumeSend();
+  virtual bool AddStream(uint32 ssrc);
+  virtual bool RemoveStream(uint32 ssrc);
+  virtual bool GetActiveStreams(AudioInfo::StreamList* actives);
+  virtual int GetOutputLevel();
+  virtual bool SetOutputScaling(uint32 ssrc, double left, double right);
+  virtual bool GetOutputScaling(uint32 ssrc, double* left, double* right);
+
+  virtual bool SetRingbackTone(const char *buf, int len);
+  virtual bool PlayRingbackTone(uint32 ssrc, bool play, bool loop);
+  virtual bool PressDTMF(int event, bool playout);
+
+  virtual void OnPacketReceived(talk_base::Buffer* packet);
+  virtual void OnRtcpReceived(talk_base::Buffer* packet);
+  virtual void SetSendSsrc(uint32 id);
+  virtual bool SetRtcpCName(const std::string& cname);
+  virtual bool Mute(bool mute);
+  virtual bool SetSendBandwidth(bool autobw, int bps) { return false; }
+  virtual bool GetStats(VoiceMediaInfo* info);
+  // Gets last reported error from WebRtc voice engine.  This should be only
+  // called in response a failure.
+  virtual void GetLastMediaError(uint32* ssrc,
+                                 VoiceMediaChannel::Error* error);
+  bool FindSsrc(int channel_num, uint32* ssrc);
+  void OnError(uint32 ssrc, int error);
+
+ protected:
+  int GetLastEngineError() { return engine()->GetLastEngineError(); }
+  int GetChannel(uint32 ssrc);
+  int GetOutputLevel(int channel);
+  bool GetRedSendCodec(const AudioCodec& red_codec,
+                       const std::vector<AudioCodec>& all_codecs,
+                       webrtc::CodecInst* send_codec);
+  bool EnableRtcp(int channel);
+  bool SetPlayout(int channel, bool playout);
+  static uint32 ParseSsrc(const void* data, size_t len, bool rtcp);
+  static Error WebRtcErrorToChannelError(int err_code);
+
+ private:
+  // Tandberg-bridged conferences require a -10dB gain adjustment,
+  // which is actually +10 in AgcConfig.targetLeveldBOv
+  static const int kTandbergDbAdjustment = 10;
+
+  bool ChangePlayout(bool playout);
+  bool ChangeSend(SendFlags send);
+
+  typedef std::map<uint32, int> ChannelMap;
+  talk_base::scoped_ptr<WebRtcSoundclipStream> ringback_tone_;
+  std::set<int> ringback_channels_;  // channels playing ringback
+  int channel_options_;
+  bool agc_adjusted_;
+  bool dtmf_allowed_;
+  bool desired_playout_;
+  bool playout_;
+  SendFlags desired_send_;
+  SendFlags send_;
+  ChannelMap mux_channels_;  // for multiple sources
+  // mux_channels_ can be read from WebRtc callback thread.  Accesses off the
+  // WebRtc thread must be synchronized with edits on the worker thread.  Reads
+  // on the worker thread are ok.
+  mutable talk_base::CriticalSection mux_channels_cs_;
+};
+}
+
+#endif  // TALK_SESSION_PHONE_WEBRTCVOICEENGINE_H_
diff --git a/talk/session/phone/webrtcvoiceengine_unittest.cc b/talk/session/phone/webrtcvoiceengine_unittest.cc
new file mode 100644
index 0000000..0660630
--- /dev/null
+++ b/talk/session/phone/webrtcvoiceengine_unittest.cc
@@ -0,0 +1,1148 @@
+// Copyright 2008 Google Inc. All Rights Reserved.
+//
+// Author: Justin Uberti (juberti@google.com)
+
+#include "talk/base/byteorder.h"
+#include "talk/base/gunit.h"
+#include "talk/session/phone/channel.h"
+#include "talk/session/phone/fakemediaengine.h"
+#include "talk/session/phone/fakertp.h"
+#include "talk/session/phone/fakesession.h"
+#include "talk/session/phone/fakewebrtcvoiceengine.h"
+#include "talk/session/phone/webrtcvoiceengine.h"
+
+// Tests for the WebRtcVoiceEngine/VoiceChannel code.
+
+static const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1, 0);
+static const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, -1, 1, 0);
+static const cricket::AudioCodec kRedCodec(117, "red", 8000, 0, 1, 0);
+static const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1, 0);
+static const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1, 0);
+static const cricket::AudioCodec
+    kTelephoneEventCodec(106, "telephone-event", 8000, 0, 1, 0);
+static const cricket::AudioCodec* const kAudioCodecs[] = {
+    &kPcmuCodec, &kIsacCodec, &kRedCodec, &kCn8000Codec, &kCn16000Codec,
+    &kTelephoneEventCodec,
+};
+const char kRingbackTone[] = "RIFF____WAVE____ABCD1234";
+
+class FakeVoEWrapper : public cricket::VoEWrapper {
+ public:
+  explicit FakeVoEWrapper(cricket::FakeWebRtcVoiceEngine* engine)
+      : cricket::VoEWrapper(engine,  // processing
+                            engine,  // base
+                            engine,  // codec
+                            engine,  // dtmf
+                            engine,  // file
+                            engine,  // hw
+                            engine,  // media
+                            engine,  // neteq
+                            engine,  // network
+                            engine,  // rtp
+                            engine,  // sync
+                            engine) {  // volume
+  }
+};
+
+class NullVoETraceWrapper : public cricket::VoETraceWrapper {
+ public:
+  virtual int SetTraceFilter(const unsigned int filter) {
+    return 0;
+  }
+  virtual int SetTraceFile(const char* fileNameUTF8) {
+    return 0;
+  }
+  virtual int SetTraceCallback(webrtc::TraceCallback* callback) {
+    return 0;
+  }
+};
+
+class WebRtcVoiceEngineTest : public testing::Test {
+ public:
+  class ChannelErrorListener : public sigslot::has_slots<> {
+   public:
+    explicit ChannelErrorListener(cricket::VoiceMediaChannel* channel)
+        : ssrc_(0), error_(cricket::VoiceMediaChannel::ERROR_NONE) {
+      ASSERT(channel != NULL);
+      channel->SignalMediaError.connect(
+          this, &ChannelErrorListener::OnVoiceChannelError);
+    }
+    void OnVoiceChannelError(uint32 ssrc,
+                             cricket::VoiceMediaChannel::Error error) {
+      ssrc_ = ssrc;
+      error_ = error;
+    }
+    void Reset() {
+      ssrc_ = 0;
+      error_ = cricket::VoiceMediaChannel::ERROR_NONE;
+    }
+    uint32 ssrc() const {
+      return ssrc_;
+    }
+    cricket::VoiceMediaChannel::Error error() const {
+      return error_;
+    }
+
+   private:
+    uint32 ssrc_;
+    cricket::VoiceMediaChannel::Error error_;
+  };
+  // TODO: Implement other stub interfaces (VQE)
+  WebRtcVoiceEngineTest()
+      : voe_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)),
+        voe_sc_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)),
+        engine_(new FakeVoEWrapper(&voe_),
+                new FakeVoEWrapper(&voe_sc_),
+                new NullVoETraceWrapper()),
+        channel_(NULL), soundclip_(NULL) {
+  }
+  bool SetupEngine() {
+    bool result = engine_.Init();
+    if (result) {
+      channel_ = engine_.CreateChannel();
+      result = (channel_ != NULL);
+    }
+    return result;
+  }
+  void DeliverPacket(const void* data, int len) {
+    talk_base::Buffer packet(data, len);
+    channel_->OnPacketReceived(&packet);
+  }
+  virtual void TearDown() {
+    delete soundclip_;
+    delete channel_;
+    engine_.Terminate();
+  }
+
+ protected:
+  cricket::FakeWebRtcVoiceEngine voe_;
+  cricket::FakeWebRtcVoiceEngine voe_sc_;
+  cricket::WebRtcVoiceEngine engine_;
+  cricket::VoiceMediaChannel* channel_;
+  cricket::SoundclipMedia* soundclip_;
+};
+
+// Tests that our stub library "works".
+TEST_F(WebRtcVoiceEngineTest, StartupShutdown) {
+  EXPECT_FALSE(voe_.IsInited());
+  EXPECT_FALSE(voe_sc_.IsInited());
+  EXPECT_TRUE(engine_.Init());
+  EXPECT_TRUE(voe_.IsInited());
+  EXPECT_TRUE(voe_sc_.IsInited());
+  engine_.Terminate();
+  EXPECT_FALSE(voe_.IsInited());
+  EXPECT_FALSE(voe_sc_.IsInited());
+}
+
+// Tests that we can create and destroy a channel.
+TEST_F(WebRtcVoiceEngineTest, CreateChannel) {
+  EXPECT_TRUE(engine_.Init());
+  channel_ = engine_.CreateChannel();
+  EXPECT_TRUE(channel_ != NULL);
+}
+
+// Tests that we properly handle failures in CreateChannel.
+TEST_F(WebRtcVoiceEngineTest, CreateChannelFail) {
+  voe_.set_fail_create_channel(true);
+  EXPECT_TRUE(engine_.Init());
+  channel_ = engine_.CreateChannel();
+  EXPECT_TRUE(channel_ == NULL);
+}
+
+// Tests that we can find codecs by name or id, and that we interpret the
+// clockrate and bitrate fields properly.
+TEST_F(WebRtcVoiceEngineTest, FindCodec) {
+  cricket::AudioCodec codec;
+  webrtc::CodecInst codec_inst;
+  // Find PCMU with explicit clockrate and bitrate.
+  EXPECT_TRUE(engine_.FindWebRtcCodec(kPcmuCodec, &codec_inst));
+  // Find ISAC with explicit clockrate and 0 bitrate.
+  EXPECT_TRUE(engine_.FindWebRtcCodec(kIsacCodec, &codec_inst));
+  // Find telephone-event with explicit clockrate and 0 bitrate.
+  EXPECT_TRUE(engine_.FindWebRtcCodec(kTelephoneEventCodec, &codec_inst));
+  // Find ISAC with a different payload id.
+  codec = kIsacCodec;
+  codec.id = 127;
+  EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst));
+  // Find PCMU with a 0 clockrate.
+  codec = kPcmuCodec;
+  codec.clockrate = 0;
+  EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst));
+  EXPECT_EQ(8000, codec_inst.plfreq);
+  // Find PCMU with a 0 bitrate.
+  codec = kPcmuCodec;
+  codec.bitrate = 0;
+  EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst));
+  EXPECT_EQ(64000, codec_inst.rate);
+  // Find ISAC with an explicit bitrate.
+  codec = kIsacCodec;
+  codec.bitrate = 32000;
+  EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst));
+  EXPECT_EQ(32000, codec_inst.rate);
+}
+
+// Test that we set our inbound codecs properly, including changing PT.
+TEST_F(WebRtcVoiceEngineTest, SetRecvCodecs) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(kPcmuCodec);
+  codecs[0].id = 96;
+  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
+  gcodec.plfreq = 16000;
+  EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
+  EXPECT_EQ(96, gcodec.pltype);
+  EXPECT_STREQ("ISAC", gcodec.plname);
+}
+
+// Test that we fail to set an unknown inbound codec.
+TEST_F(WebRtcVoiceEngineTest, SetRecvCodecsUnsupportedCodec) {
+  EXPECT_TRUE(SetupEngine());
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(cricket::AudioCodec(127, "XYZ", 32000, 0, 1, 0));
+  EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
+}
+
+// Test that we apply codecs properly.
+TEST_F(WebRtcVoiceEngineTest, SetSendCodecs) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(kPcmuCodec);
+  codecs.push_back(kRedCodec);
+  codecs[0].id = 96;
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(96, gcodec.pltype);
+  EXPECT_STREQ("ISAC", gcodec.plname);
+  EXPECT_FALSE(voe_.GetVAD(channel_num));
+  EXPECT_FALSE(voe_.GetFEC(channel_num));
+  EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
+  EXPECT_EQ(105, voe_.GetSendCNPayloadType(channel_num, true));
+  EXPECT_EQ(106, voe_.GetSendTelephoneEventPayloadType(channel_num));
+}
+
+// Test that we fall back to PCMU if no codecs are specified.
+TEST_F(WebRtcVoiceEngineTest, SetSendCodecsNoCodecs) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(0, gcodec.pltype);
+  EXPECT_STREQ("PCMU", gcodec.plname);
+  EXPECT_FALSE(voe_.GetVAD(channel_num));
+  EXPECT_FALSE(voe_.GetFEC(channel_num));
+  EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
+  EXPECT_EQ(105, voe_.GetSendCNPayloadType(channel_num, true));
+  EXPECT_EQ(106, voe_.GetSendTelephoneEventPayloadType(channel_num));
+}
+
+// Test that we set VAD and DTMF types correctly.
+TEST_F(WebRtcVoiceEngineTest, SetSendCodecsCNandDTMF) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(kPcmuCodec);
+  // TODO: cn 32000
+  codecs.push_back(kCn16000Codec);
+  codecs.push_back(kCn8000Codec);
+  codecs.push_back(kTelephoneEventCodec);
+  codecs.push_back(kRedCodec);
+  codecs[0].id = 96;
+  codecs[2].id = 97;  // wideband CN
+  codecs[4].id = 98;  // DTMF
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(96, gcodec.pltype);
+  EXPECT_STREQ("ISAC", gcodec.plname);
+  EXPECT_TRUE(voe_.GetVAD(channel_num));
+  EXPECT_FALSE(voe_.GetFEC(channel_num));
+  EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
+  EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
+  EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num));
+}
+
+// Test that we set up FEC correctly.
+TEST_F(WebRtcVoiceEngineTest, SetSendCodecsRED) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kRedCodec);
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(kPcmuCodec);
+  codecs[0].id = 127;
+  codecs[0].params[""] = "96/96";
+  codecs[1].id = 96;
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(96, gcodec.pltype);
+  EXPECT_STREQ("ISAC", gcodec.plname);
+  EXPECT_TRUE(voe_.GetFEC(channel_num));
+  EXPECT_EQ(127, voe_.GetSendFECPayloadType(channel_num));
+}
+
+// Test that we set up FEC correctly if params are omitted.
+TEST_F(WebRtcVoiceEngineTest, SetSendCodecsREDNoParams) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kRedCodec);
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(kPcmuCodec);
+  codecs[0].id = 127;
+  codecs[1].id = 96;
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(96, gcodec.pltype);
+  EXPECT_STREQ("ISAC", gcodec.plname);
+  EXPECT_TRUE(voe_.GetFEC(channel_num));
+  EXPECT_EQ(127, voe_.GetSendFECPayloadType(channel_num));
+}
+
+// Test that we ignore RED if the parameters aren't named the way we expect.
+TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBadRED1) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kRedCodec);
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(kPcmuCodec);
+  codecs[0].id = 127;
+  codecs[0].params["ABC"] = "96/96";
+  codecs[1].id = 96;
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(96, gcodec.pltype);
+  EXPECT_STREQ("ISAC", gcodec.plname);
+  EXPECT_FALSE(voe_.GetFEC(channel_num));
+}
+
+// Test that we ignore RED if it uses different primary/secondary encoding.
+TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBadRED2) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kRedCodec);
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(kPcmuCodec);
+  codecs[0].id = 127;
+  codecs[0].params[""] = "96/0";
+  codecs[1].id = 96;
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(96, gcodec.pltype);
+  EXPECT_STREQ("ISAC", gcodec.plname);
+  EXPECT_FALSE(voe_.GetFEC(channel_num));
+}
+
+// Test that we ignore RED if it uses more than 2 encodings.
+TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBadRED3) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kRedCodec);
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(kPcmuCodec);
+  codecs[0].id = 127;
+  codecs[0].params[""] = "96/96/96";
+  codecs[1].id = 96;
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(96, gcodec.pltype);
+  EXPECT_STREQ("ISAC", gcodec.plname);
+  EXPECT_FALSE(voe_.GetFEC(channel_num));
+}
+
+// Test that we ignore RED if it has bogus codec ids.
+TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBadRED4) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kRedCodec);
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(kPcmuCodec);
+  codecs[0].id = 127;
+  codecs[0].params[""] = "ABC/ABC";
+  codecs[1].id = 96;
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(96, gcodec.pltype);
+  EXPECT_STREQ("ISAC", gcodec.plname);
+  EXPECT_FALSE(voe_.GetFEC(channel_num));
+}
+
+// Test that we ignore RED if it refers to a codec that is not present.
+TEST_F(WebRtcVoiceEngineTest, SetSendCodecsBadRED5) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kRedCodec);
+  codecs.push_back(kIsacCodec);
+  codecs.push_back(kPcmuCodec);
+  codecs[0].id = 127;
+  codecs[0].params[""] = "97/97";
+  codecs[1].id = 96;
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  webrtc::CodecInst gcodec;
+  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  EXPECT_EQ(96, gcodec.pltype);
+  EXPECT_STREQ("ISAC", gcodec.plname);
+  EXPECT_FALSE(voe_.GetFEC(channel_num));
+}
+
+// Test that we support setting an empty list of recv header extensions.
+TEST_F(WebRtcVoiceEngineTest, SetRecvRtpHeaderExtensions) {
+  EXPECT_TRUE(SetupEngine());
+  std::vector<cricket::RtpHeaderExtension> extensions;
+  int channel_num = voe_.GetLastChannel();
+  bool enable = false;
+  unsigned char id = 0;
+
+  // An empty list shouldn't cause audio-level headers to be enabled.
+  EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+  EXPECT_EQ(0, voe_.GetRTPAudioLevelIndicationStatus(
+      channel_num, enable, id));
+  EXPECT_FALSE(enable);
+
+  // Nor should indicating we can receive the audio-level header.
+  extensions.push_back(cricket::RtpHeaderExtension(
+      "urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8));
+  EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+  EXPECT_EQ(0, voe_.GetRTPAudioLevelIndicationStatus(
+      channel_num, enable, id));
+  EXPECT_FALSE(enable);
+}
+
+// Test that we support setting certain send header extensions.
+TEST_F(WebRtcVoiceEngineTest, SetSendRtpHeaderExtensions) {
+  EXPECT_TRUE(SetupEngine());
+  std::vector<cricket::RtpHeaderExtension> extensions;
+  int channel_num = voe_.GetLastChannel();
+  bool enable = false;
+  unsigned char id = 0;
+
+  // Ensure audio levels are off by default.
+  EXPECT_EQ(0, voe_.GetRTPAudioLevelIndicationStatus(
+      channel_num, enable, id));
+  EXPECT_FALSE(enable);
+
+  // Ensure audio levels stay off with an empty list of headers.
+  EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+  EXPECT_EQ(0, voe_.GetRTPAudioLevelIndicationStatus(
+      channel_num, enable, id));
+  EXPECT_FALSE(enable);
+
+  // Ensure audio levels are enabled if the audio-level header is specified.
+  extensions.push_back(cricket::RtpHeaderExtension(
+      "urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8));
+  EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+  EXPECT_EQ(0, voe_.GetRTPAudioLevelIndicationStatus(
+      channel_num, enable, id));
+  EXPECT_TRUE(enable);
+  EXPECT_EQ(8, id);
+
+  // Ensure audio levels go back off with an empty list.
+  extensions.clear();
+  EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+  EXPECT_EQ(0, voe_.GetRTPAudioLevelIndicationStatus(
+      channel_num, enable, id));
+  EXPECT_FALSE(enable);
+}
+
+// Test that we can create a channel and start sending/playing out on it.
+TEST_F(WebRtcVoiceEngineTest, SendAndPlayout) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
+  EXPECT_TRUE(voe_.GetSend(channel_num));
+  EXPECT_TRUE(channel_->SetPlayout(true));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num));
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
+  EXPECT_FALSE(voe_.GetSend(channel_num));
+  EXPECT_TRUE(channel_->SetPlayout(false));
+  EXPECT_FALSE(voe_.GetPlayout(channel_num));
+}
+
+// Test that we can set the devices to use.
+TEST_F(WebRtcVoiceEngineTest, SetDevices) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+
+  cricket::Device default_dev(cricket::kFakeDefaultDeviceName,
+                              cricket::kFakeDefaultDeviceId);
+  cricket::Device dev(cricket::kFakeDeviceName,
+                      cricket::kFakeDeviceId);
+
+  // Test SetDevices() while not sending or playing.
+  EXPECT_TRUE(engine_.SetDevices(&default_dev, &default_dev));
+
+  // Test SetDevices() while sending and playing.
+  EXPECT_TRUE(engine_.SetLocalMonitor(true));
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
+  EXPECT_TRUE(channel_->SetPlayout(true));
+  EXPECT_TRUE(voe_.GetRecordingMicrophone());
+  EXPECT_TRUE(voe_.GetSend(channel_num));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num));
+
+  EXPECT_TRUE(engine_.SetDevices(&dev, &dev));
+
+  EXPECT_TRUE(voe_.GetRecordingMicrophone());
+  EXPECT_TRUE(voe_.GetSend(channel_num));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num));
+
+  // Test that failure to open newly selected devices does not prevent opening
+  // ones after that.
+  voe_.set_fail_start_recording_microphone(true);
+  voe_.set_playout_fail_channel(channel_num);
+  voe_.set_send_fail_channel(channel_num);
+
+  EXPECT_FALSE(engine_.SetDevices(&default_dev, &default_dev));
+
+  EXPECT_FALSE(voe_.GetRecordingMicrophone());
+  EXPECT_FALSE(voe_.GetSend(channel_num));
+  EXPECT_FALSE(voe_.GetPlayout(channel_num));
+
+  voe_.set_fail_start_recording_microphone(false);
+  voe_.set_playout_fail_channel(-1);
+  voe_.set_send_fail_channel(-1);
+
+  EXPECT_TRUE(engine_.SetDevices(&dev, &dev));
+
+  EXPECT_TRUE(voe_.GetRecordingMicrophone());
+  EXPECT_TRUE(voe_.GetSend(channel_num));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num));
+}
+
+// Test that we can set the devices to use even if we failed to
+// open the initial ones.
+TEST_F(WebRtcVoiceEngineTest, SetDevicesWithInitiallyBadDevices) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+
+  cricket::Device default_dev(cricket::kFakeDefaultDeviceName,
+                              cricket::kFakeDefaultDeviceId);
+  cricket::Device dev(cricket::kFakeDeviceName,
+                      cricket::kFakeDeviceId);
+
+  // Test that failure to open devices selected before starting
+  // send/play does not prevent opening newly selected ones after that.
+  voe_.set_fail_start_recording_microphone(true);
+  voe_.set_playout_fail_channel(channel_num);
+  voe_.set_send_fail_channel(channel_num);
+
+  EXPECT_TRUE(engine_.SetDevices(&default_dev, &default_dev));
+
+  EXPECT_FALSE(engine_.SetLocalMonitor(true));
+  EXPECT_FALSE(channel_->SetSend(cricket::SEND_MICROPHONE));
+  EXPECT_FALSE(channel_->SetPlayout(true));
+  EXPECT_FALSE(voe_.GetRecordingMicrophone());
+  EXPECT_FALSE(voe_.GetSend(channel_num));
+  EXPECT_FALSE(voe_.GetPlayout(channel_num));
+
+  voe_.set_fail_start_recording_microphone(false);
+  voe_.set_playout_fail_channel(-1);
+  voe_.set_send_fail_channel(-1);
+
+  EXPECT_TRUE(engine_.SetDevices(&dev, &dev));
+
+  EXPECT_TRUE(voe_.GetRecordingMicrophone());
+  EXPECT_TRUE(voe_.GetSend(channel_num));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num));
+}
+
+// Test that we can create a channel configured for multi-point conferences,
+// and start sending/playing out on it.
+TEST_F(WebRtcVoiceEngineTest, ConferenceSendAndPlayout) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_CONFERENCE));
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
+  EXPECT_TRUE(voe_.GetSend(channel_num));
+
+  bool enabled;
+  webrtc::EcModes ec_mode;
+  webrtc::NsModes ns_mode;
+  EXPECT_EQ(0, voe_.GetEcStatus(enabled, ec_mode));
+#ifdef CHROMEOS
+  EXPECT_EQ(webrtc::kEcDefault, ec_mode);
+#else
+  EXPECT_EQ(webrtc::kEcConference, ec_mode);
+#endif
+  EXPECT_EQ(0, voe_.GetNsStatus(enabled, ns_mode));
+  EXPECT_TRUE(enabled);
+#ifdef CHROMEOS
+  EXPECT_EQ(webrtc::kNsDefault, ns_mode);
+#else
+  EXPECT_EQ(webrtc::kNsConference, ns_mode);
+#endif
+
+  EXPECT_TRUE(channel_->SetPlayout(true));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num));
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
+  EXPECT_FALSE(voe_.GetSend(channel_num));
+
+  EXPECT_EQ(0, voe_.GetEcStatus(enabled, ec_mode));
+  EXPECT_EQ(webrtc::kEcDefault, ec_mode);
+  EXPECT_EQ(0, voe_.GetNsStatus(enabled, ns_mode));
+  EXPECT_EQ(webrtc::kNsDefault, ns_mode);
+
+  EXPECT_TRUE(channel_->SetPlayout(false));
+  EXPECT_FALSE(voe_.GetPlayout(channel_num));
+}
+
+// Test that we can create a channel configured for Codian bridges,
+// and start sending/playing out on it.
+TEST_F(WebRtcVoiceEngineTest, CodianSendAndPlayout) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  webrtc::AgcConfig agc_config;
+  EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
+  EXPECT_EQ(0, agc_config.targetLeveldBOv);
+  EXPECT_TRUE(channel_->SetOptions(cricket::OPT_AGC_TANDBERG_LEVELS));
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
+  EXPECT_TRUE(voe_.GetSend(channel_num));
+  EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
+  EXPECT_GT(agc_config.targetLeveldBOv, 0);  // level was attenuated
+  EXPECT_TRUE(channel_->SetPlayout(true));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num));
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
+  EXPECT_FALSE(voe_.GetSend(channel_num));
+  EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
+  EXPECT_EQ(0, agc_config.targetLeveldBOv);  // level was restored
+  EXPECT_TRUE(channel_->SetPlayout(false));
+  EXPECT_FALSE(voe_.GetPlayout(channel_num));
+}
+
+// Test that we can set the outgoing SSRC properly.
+TEST_F(WebRtcVoiceEngineTest, SetSendSsrc) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  unsigned int send_ssrc;
+  EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num, send_ssrc));
+  EXPECT_NE(0U, send_ssrc);
+  channel_->SetSendSsrc(0x99);
+  EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num, send_ssrc));
+  EXPECT_EQ(0x99U, send_ssrc);
+}
+
+// Test that we can properly receive packets.
+TEST_F(WebRtcVoiceEngineTest, Recv) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
+  EXPECT_TRUE(voe_.CheckPacket(channel_num, kPcmuFrame,
+                                      sizeof(kPcmuFrame)));
+}
+
+// Test that we can add and remove streams, and do proper send/playout.
+// We can receive on multiple streams, but will only send on one.
+TEST_F(WebRtcVoiceEngineTest, SendAndPlayoutWithMultipleStreams) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num1 = voe_.GetLastChannel();
+
+  // Start playout on the default channel.
+  EXPECT_TRUE(channel_->SetPlayout(true));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num1));
+
+  // Adding another stream should disable playout on the default channel.
+  EXPECT_TRUE(channel_->AddStream(2));
+  int channel_num2 = voe_.GetLastChannel();
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
+  EXPECT_TRUE(voe_.GetSend(channel_num1));
+  EXPECT_FALSE(voe_.GetSend(channel_num2));
+
+  // Make sure only the new channel is played out.
+  EXPECT_FALSE(voe_.GetPlayout(channel_num1));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num2));
+
+  // Adding yet another stream should have stream 2 and 3 enabled for playout.
+  EXPECT_TRUE(channel_->AddStream(3));
+  int channel_num3 = voe_.GetLastChannel();
+  EXPECT_FALSE(voe_.GetPlayout(channel_num1));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num2));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num3));
+  EXPECT_FALSE(voe_.GetSend(channel_num3));
+
+  // Stop sending.
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
+  EXPECT_FALSE(voe_.GetSend(channel_num1));
+  EXPECT_FALSE(voe_.GetSend(channel_num2));
+  EXPECT_FALSE(voe_.GetSend(channel_num3));
+
+  // Stop playout.
+  EXPECT_TRUE(channel_->SetPlayout(false));
+  EXPECT_FALSE(voe_.GetPlayout(channel_num1));
+  EXPECT_FALSE(voe_.GetPlayout(channel_num2));
+  EXPECT_FALSE(voe_.GetPlayout(channel_num3));
+
+  // Restart playout and make sure the default channel still is not played out.
+  EXPECT_TRUE(channel_->SetPlayout(true));
+  EXPECT_FALSE(voe_.GetPlayout(channel_num1));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num2));
+  EXPECT_TRUE(voe_.GetPlayout(channel_num3));
+
+  // Now remove the new streams and verify that the default channel is
+  // played out again.
+  EXPECT_TRUE(channel_->RemoveStream(3));
+  EXPECT_TRUE(channel_->RemoveStream(2));
+
+  EXPECT_TRUE(voe_.GetPlayout(channel_num1));
+}
+
+// Test that we can set the outgoing SSRC properly with multiple streams.
+TEST_F(WebRtcVoiceEngineTest, SetSendSsrcWithMultipleStreams) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num1 = voe_.GetLastChannel();
+  unsigned int send_ssrc;
+  channel_->SetSendSsrc(0x99);
+  EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num1, send_ssrc));
+  EXPECT_EQ(0x99U, send_ssrc);
+  EXPECT_TRUE(channel_->AddStream(2));
+  int channel_num2 = voe_.GetLastChannel();
+  EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num2, send_ssrc));
+  EXPECT_EQ(0x99U, send_ssrc);
+}
+
+// Test that we properly handle failures to add a stream.
+TEST_F(WebRtcVoiceEngineTest, AddStreamFail) {
+  EXPECT_TRUE(SetupEngine());
+  voe_.set_fail_create_channel(true);
+  EXPECT_FALSE(channel_->AddStream(2));
+}
+
+// Test that we can properly receive packets on multiple streams.
+TEST_F(WebRtcVoiceEngineTest, RecvWithMultipleStreams) {
+  EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->AddStream(1));
+  int channel_num1 = voe_.GetLastChannel();
+  EXPECT_TRUE(channel_->AddStream(2));
+  int channel_num2 = voe_.GetLastChannel();
+  EXPECT_TRUE(channel_->AddStream(3));
+  int channel_num3 = voe_.GetLastChannel();
+  // Create packets with the right SSRCs.
+  char packets[4][sizeof(kPcmuFrame)];
+  for (size_t i = 0; i < ARRAY_SIZE(packets); ++i) {
+    memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame));
+    talk_base::SetBE32(packets[i] + 8, i);
+  }
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
+  DeliverPacket(packets[0], sizeof(packets[0]));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
+  DeliverPacket(packets[1], sizeof(packets[1]));
+  EXPECT_TRUE(voe_.CheckPacket(channel_num1, packets[1],
+                                      sizeof(packets[1])));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
+  DeliverPacket(packets[2], sizeof(packets[2]));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
+  EXPECT_TRUE(voe_.CheckPacket(channel_num2, packets[2],
+                                      sizeof(packets[2])));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
+  DeliverPacket(packets[3], sizeof(packets[3]));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
+  EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
+  EXPECT_TRUE(voe_.CheckPacket(channel_num3, packets[3],
+                                      sizeof(packets[3])));
+  EXPECT_TRUE(channel_->RemoveStream(3));
+  EXPECT_TRUE(channel_->RemoveStream(2));
+  EXPECT_TRUE(channel_->RemoveStream(1));
+}
+
+// Test that we properly clean up any streams that were added, even if
+// not explicitly removed.
+TEST_F(WebRtcVoiceEngineTest, StreamCleanup) {
+  EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->AddStream(1));
+  EXPECT_TRUE(channel_->AddStream(2));
+  EXPECT_EQ(3, voe_.GetNumChannels());  // default channel + 2 added
+  delete channel_;
+  channel_ = NULL;
+  EXPECT_EQ(0, voe_.GetNumChannels());
+}
+
+// Test that we can send DTMF properly, but only if the other side supports
+// telephone-event.
+TEST_F(WebRtcVoiceEngineTest, SendDtmf) {
+  EXPECT_TRUE(SetupEngine());
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
+  EXPECT_FALSE(channel_->PressDTMF(1, true));
+  codecs.push_back(kTelephoneEventCodec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->PressDTMF(1, true));
+}
+
+// Test that we can play a ringback tone properly in a single-stream call.
+TEST_F(WebRtcVoiceEngineTest, PlayRingback) {
+  EXPECT_TRUE(SetupEngine());
+  int channel_num = voe_.GetLastChannel();
+  EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
+  // Check we fail if no ringback tone specified.
+  EXPECT_FALSE(channel_->PlayRingbackTone(0, true, true));
+  EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
+  // Check we can set and play a ringback tone.
+  EXPECT_TRUE(channel_->SetRingbackTone(kRingbackTone, strlen(kRingbackTone)));
+  EXPECT_TRUE(channel_->PlayRingbackTone(0, true, true));
+  EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
+  // Check we can stop the tone manually.
+  EXPECT_TRUE(channel_->PlayRingbackTone(0, false, false));
+  EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
+  // Check we stop the tone if a packet arrives.
+  EXPECT_TRUE(channel_->PlayRingbackTone(0, true, true));
+  EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
+  DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
+  EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
+}
+
+// Test that we can play a ringback tone properly in a multi-stream call.
+TEST_F(WebRtcVoiceEngineTest, PlayRingbackWithMultipleStreams) {
+  EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->AddStream(1));
+  EXPECT_TRUE(channel_->AddStream(2));
+  int channel_num = voe_.GetLastChannel();
+  EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
+  // Check we fail if no ringback tone specified.
+  EXPECT_FALSE(channel_->PlayRingbackTone(2, true, true));
+  EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
+  // Check we can set and play a ringback tone on the correct ssrc.
+  EXPECT_TRUE(channel_->SetRingbackTone(kRingbackTone, strlen(kRingbackTone)));
+  EXPECT_FALSE(channel_->PlayRingbackTone(77, true, true));
+  EXPECT_TRUE(channel_->PlayRingbackTone(2, true, true));
+  EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
+  // Check we can stop the tone manually.
+  EXPECT_TRUE(channel_->PlayRingbackTone(2, false, false));
+  EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
+  // Check we stop the tone if a packet arrives, but only with the right SSRC.
+  EXPECT_TRUE(channel_->PlayRingbackTone(2, true, true));
+  EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
+  // Send a packet with SSRC 1; the tone should not stop.
+  DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
+  EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
+  // Send a packet with SSRC 2; the tone should stop.
+  char packet[sizeof(kPcmuFrame)];
+  memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
+  talk_base::SetBE32(packet + 8, 2);
+  DeliverPacket(packet, sizeof(packet));
+  EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
+}
+
+// Tests creating soundclips, and make sure they come from the right engine.
+TEST_F(WebRtcVoiceEngineTest, CreateSoundclip) {
+  EXPECT_TRUE(engine_.Init());
+  soundclip_ = engine_.CreateSoundclip();
+  ASSERT_TRUE(soundclip_ != NULL);
+  EXPECT_EQ(0, voe_.GetNumChannels());
+  EXPECT_EQ(1, voe_sc_.GetNumChannels());
+  int channel_num = voe_sc_.GetLastChannel();
+  EXPECT_TRUE(voe_sc_.GetPlayout(channel_num));
+  delete soundclip_;
+  soundclip_ = NULL;
+  EXPECT_EQ(0, voe_sc_.GetNumChannels());
+}
+
+// Tests playing out a fake sound.
+TEST_F(WebRtcVoiceEngineTest, PlaySoundclip) {
+  static const char kZeroes[16000] = {};
+  EXPECT_TRUE(engine_.Init());
+  soundclip_ = engine_.CreateSoundclip();
+  ASSERT_TRUE(soundclip_ != NULL);
+  EXPECT_TRUE(soundclip_->PlaySound(kZeroes, sizeof(kZeroes), 0));
+}
+
+TEST_F(WebRtcVoiceEngineTest, MediaEngineCallbackOnError) {
+  talk_base::scoped_ptr<ChannelErrorListener> listener;
+  cricket::WebRtcVoiceMediaChannel* media_channel;
+  unsigned int ssrc = 0;
+
+  EXPECT_TRUE(SetupEngine());
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
+
+  media_channel = reinterpret_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
+  listener.reset(new ChannelErrorListener(channel_));
+
+  // Test on WebRtc VoE channel.
+  voe_.TriggerCallbackOnError(media_channel->voe_channel(),
+                               VE_SATURATION_WARNING);
+  EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_SATURATION,
+            listener->error());
+  EXPECT_NE(-1, voe_.GetLocalSSRC(voe_.GetLastChannel(), ssrc));
+  EXPECT_EQ(ssrc, listener->ssrc());
+
+  listener->Reset();
+  voe_.TriggerCallbackOnError(-1, VE_TYPING_NOISE_WARNING);
+  EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_TYPING_NOISE_DETECTED,
+            listener->error());
+  EXPECT_EQ(0U, listener->ssrc());
+
+  // Add another stream and test on that.
+  ++ssrc;
+  EXPECT_TRUE(channel_->AddStream(ssrc));
+  listener->Reset();
+  voe_.TriggerCallbackOnError(voe_.GetLastChannel(),
+                               VE_SATURATION_WARNING);
+  EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_SATURATION,
+            listener->error());
+  EXPECT_EQ(ssrc, listener->ssrc());
+
+  // Testing a non-existing channel.
+  listener->Reset();
+  voe_.TriggerCallbackOnError(voe_.GetLastChannel() + 2,
+                               VE_SATURATION_WARNING);
+  EXPECT_EQ(0, listener->error());
+}
+
+TEST_F(WebRtcVoiceEngineTest, TestSetPlayoutError) {
+  EXPECT_TRUE(SetupEngine());
+  std::vector<cricket::AudioCodec> codecs;
+  codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
+  EXPECT_TRUE(channel_->AddStream(2));
+  EXPECT_TRUE(channel_->AddStream(3));
+  EXPECT_TRUE(channel_->SetPlayout(true));
+  voe_.set_playout_fail_channel(voe_.GetLastChannel() - 1);
+  EXPECT_TRUE(channel_->SetPlayout(false));
+  EXPECT_FALSE(channel_->SetPlayout(true));
+}
+
+// Tests for the actual WebRtc VoE library.
+
+// Tests that the library initializes and shuts down properly.
+TEST(WebRtcVoiceEngineLibTest, StartupShutdown) {
+  cricket::WebRtcVoiceEngine engine;
+  EXPECT_TRUE(engine.Init());
+  cricket::VoiceMediaChannel* channel = engine.CreateChannel();
+  EXPECT_TRUE(channel != NULL);
+  delete channel;
+  engine.Terminate();
+
+  // Reinit to catch regression where VoiceEngineObserver reference is lost
+  EXPECT_TRUE(engine.Init());
+  engine.Terminate();
+}
+
+// Tests that the logging from the library is cleartext.
+// TODO: This test case is disabled due to a known bug in VoE4.0
+// which sends out truncated log message. Will be fixed in next VoE release.
+TEST(WebRtcVoiceEngineLibTest, DISABLED_HasUnencryptedLogging) {
+  cricket::WebRtcVoiceEngine engine;
+  talk_base::scoped_ptr<talk_base::MemoryStream> stream(
+      new talk_base::MemoryStream);
+  size_t size = 0;
+  bool cleartext = true;
+  talk_base::LogMessage::AddLogToStream(stream.get(), talk_base::LS_VERBOSE);
+  engine.SetLogging(talk_base::LS_VERBOSE, "");
+  EXPECT_TRUE(engine.Init());
+  EXPECT_TRUE(stream->GetSize(&size));
+  EXPECT_GT(size, 0U);
+  engine.Terminate();
+  talk_base::LogMessage::RemoveLogToStream(stream.get());
+  const char* buf = stream->GetBuffer();
+  for (size_t i = 0; i < size && cleartext; ++i) {
+    int ch = static_cast<int>(buf[i]);
+    ASSERT_GE(ch, 0) << "Out of bounds character in WebRtc VoE log: "
+                     << std::hex << ch;
+    cleartext = (isprint(ch) || isspace(ch));
+  }
+  EXPECT_TRUE(cleartext);
+}
+
+// Tests we do not see any references to a monitor thread being spun up
+// when initiating the engine.
+TEST(WebRtcVoiceEngineLibTest, HasNoMonitorThread) {
+  cricket::WebRtcVoiceEngine engine;
+  talk_base::scoped_ptr<talk_base::MemoryStream> stream(
+      new talk_base::MemoryStream);
+  talk_base::LogMessage::AddLogToStream(stream.get(), talk_base::LS_VERBOSE);
+  engine.SetLogging(talk_base::LS_VERBOSE, "");
+  EXPECT_TRUE(engine.Init());
+  engine.Terminate();
+  talk_base::LogMessage::RemoveLogToStream(stream.get());
+
+  size_t size = 0;
+  EXPECT_TRUE(stream->GetSize(&size));
+  EXPECT_GT(size, 0U);
+  const std::string logs(stream->GetBuffer());
+  EXPECT_NE(std::string::npos, logs.find("ProcessThread"));
+}
+
+// Tests that the library is configured with the codecs we want.
+TEST(WebRtcVoiceEngineLibTest, HasCorrectCodecs) {
+  cricket::WebRtcVoiceEngine engine;
+  // Check codecs by name.
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "ISAC", 16000, 0, 1, 0)));
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "ISAC", 32000, 0, 1, 0)));
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "iLBC", 8000, 0, 1, 0)));
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "PCMU", 8000, 0, 1, 0)));
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "PCMA", 8000, 0, 1, 0)));
+// TODO: Add speex back, once webrtc supports it.
+//  EXPECT_TRUE(engine.FindCodec(
+//      cricket::AudioCodec(96, "speex", 16000, 0, 1, 0)));
+//  EXPECT_TRUE(engine.FindCodec(
+//      cricket::AudioCodec(96, "speex", 8000, 0, 1, 0)));
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "G722", 16000, 0, 1, 0)));
+//  EXPECT_TRUE(engine.FindCodec(
+//      cricket::AudioCodec(96, "GSM", 8000, 0, 1, 0)));
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "red", 8000, 0, 1, 0)));
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "CN", 32000, 0, 1, 0)));
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "CN", 16000, 0, 1, 0)));
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "CN", 8000, 0, 1, 0)));
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(96, "telephone-event", 8000, 0, 1, 0)));
+  // Check codecs with an id by id.
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(0, "", 8000, 0, 1, 0)));   // PCMU
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(8, "", 8000, 0, 1, 0)));   // PCMA
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(9, "", 16000, 0, 1, 0)));   // G722
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(13, "", 8000, 0, 1, 0)));  // CN
+  // Check sample/bitrate matching.
+  EXPECT_TRUE(engine.FindCodec(
+      cricket::AudioCodec(0, "PCMU", 8000, 64000, 1, 0)));
+  // Check that bad codecs fail.
+  EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(99, "ABCD", 0, 0, 1, 0)));
+  EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(88, "", 0, 0, 1, 0)));
+  EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(0, "", 0, 0, 2, 0)));
+  EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(0, "", 5000, 0, 1, 0)));
+  EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(0, "", 0, 5000, 1, 0)));
+  // Check that there aren't any extra codecs lying around.
+  EXPECT_EQ(11U, engine.codecs().size());
+  // Verify the payload id of common audio codecs, including CN, ISAC, and G722.
+  // TODO: WebRtc team may change the payload id.
+  for (std::vector<cricket::AudioCodec>::const_iterator it =
+      engine.codecs().begin(); it != engine.codecs().end(); ++it) {
+    if (it->name == "CN" && it->clockrate == 16000) {
+      EXPECT_EQ(98, it->id);
+    } else if (it->name == "CN" && it->clockrate == 32000) {
+      EXPECT_EQ(99, it->id);
+    } else if (it->name == "ISAC" && it->clockrate == 16000) {
+      EXPECT_EQ(103, it->id);
+    } else if (it->name == "ISAC" && it->clockrate == 32000) {
+      EXPECT_EQ(104, it->id);
+    } else if (it->name == "G722" && it->clockrate == 16000) {
+      EXPECT_EQ(9, it->id);
+    }
+  }
+
+  engine.Terminate();
+}
+
+// Tests that the list of supported codecs is created properly and ordered
+// correctly
+TEST_F(WebRtcVoiceEngineTest, CodecPreference) {
+  cricket::WebRtcVoiceEngine engine;
+  const std::vector<cricket::AudioCodec>& codecs = engine.codecs();
+  ASSERT_FALSE(codecs.empty());
+  EXPECT_EQ("ISAC", codecs[0].name);
+  EXPECT_EQ(16000, codecs[0].clockrate);
+  EXPECT_EQ(32000, codecs[0].bitrate);
+  int pref = codecs[0].preference;
+  for (size_t i = 1; i < codecs.size(); ++i) {
+    EXPECT_GT(pref, codecs[i].preference);
+    pref = codecs[i].preference;
+  }
+}
+
+TEST(WebRtcVoiceEngineLibTest, Has32Channels) {
+  cricket::WebRtcVoiceEngine engine;
+  EXPECT_TRUE(engine.Init());
+
+  cricket::VoiceMediaChannel* channels[32];
+  int num_channels = 0;
+
+  while (num_channels < ARRAY_SIZE(channels)) {
+    cricket::VoiceMediaChannel* channel = engine.CreateChannel();
+    if (!channel)
+      break;
+
+    channels[num_channels++] = channel;
+  }
+
+  int expected = ARRAY_SIZE(channels);
+  EXPECT_EQ(expected, num_channels);
+
+  while (num_channels > 0) {
+    delete channels[--num_channels];
+  }
+
+  engine.Terminate();
+}
+
+#ifdef WIN32
+// Test our workarounds to WebRtc VoE' munging of the coinit count
+TEST(WebRtcVoiceEngineLibTest, CoInitialize) {
+  cricket::WebRtcVoiceEngine* engine = new cricket::WebRtcVoiceEngine();
+
+  // Initial refcount should be 0.
+  EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
+
+  // Engine should start even with COM already inited.
+  EXPECT_TRUE(engine->Init());
+  engine->Terminate();
+  EXPECT_TRUE(engine->Init());
+  engine->Terminate();
+
+  // Refcount after terminate should be 1 (in reality 3); test if it is nonzero.
+  EXPECT_EQ(S_FALSE, CoInitializeEx(NULL, COINIT_MULTITHREADED));
+  // Decrement refcount to (hopefully) 0.
+  CoUninitialize();
+  CoUninitialize();
+  delete engine;
+
+  // Ensure refcount is 0.
+  EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
+  CoUninitialize();
+}
+#endif
diff --git a/talk/sound/nullsoundsystem.cc b/talk/sound/nullsoundsystem.cc
new file mode 100644
index 0000000..2920008
--- /dev/null
+++ b/talk/sound/nullsoundsystem.cc
@@ -0,0 +1,174 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "talk/sound/nullsoundsystem.h"
+
+#include "talk/base/logging.h"
+#include "talk/sound/sounddevicelocator.h"
+#include "talk/sound/soundinputstreaminterface.h"
+#include "talk/sound/soundoutputstreaminterface.h"
+
+namespace talk_base {
+
+class Thread;
+
+}
+
+namespace cricket {
+
+// Name used for the single device and the sound system itself.
+static const char kNullName[] = "null";
+
+class NullSoundDeviceLocator : public SoundDeviceLocator {
+ public:
+  NullSoundDeviceLocator() : SoundDeviceLocator(kNullName, kNullName) {}
+
+  virtual SoundDeviceLocator *Copy() const {
+    return new NullSoundDeviceLocator();
+  }
+};
+
+class NullSoundInputStream : public SoundInputStreamInterface {
+ public:
+  virtual bool StartReading() {
+    return true;
+  }
+
+  virtual bool StopReading() {
+    return true;
+  }
+
+  virtual bool GetVolume(int *volume) {
+    *volume = SoundSystemInterface::kMinVolume;
+    return true;
+  }
+
+  virtual bool SetVolume(int volume) {
+    return false;
+  }
+
+  virtual bool Close() {
+    return true;
+  }
+
+  virtual int LatencyUsecs() {
+    return 0;
+  }
+};
+
+class NullSoundOutputStream : public SoundOutputStreamInterface {
+ public:
+  virtual bool EnableBufferMonitoring() {
+    return true;
+  }
+
+  virtual bool DisableBufferMonitoring() {
+    return true;
+  }
+
+  virtual bool WriteSamples(const void *sample_data,
+                            size_t size) {
+    LOG(LS_VERBOSE) << "Got " << size << " bytes of playback samples";
+    return true;
+  }
+
+  virtual bool GetVolume(int *volume) {
+    *volume = SoundSystemInterface::kMinVolume;
+    return true;
+  }
+
+  virtual bool SetVolume(int volume) {
+    return false;
+  }
+
+  virtual bool Close() {
+    return true;
+  }
+
+  virtual int LatencyUsecs() {
+    return 0;
+  }
+};
+
+NullSoundSystem::~NullSoundSystem() {
+}
+
+bool NullSoundSystem::Init() {
+  return true;
+}
+
+void NullSoundSystem::Terminate() {
+  // Nothing to do.
+}
+
+bool NullSoundSystem::EnumeratePlaybackDevices(
+      SoundSystemInterface::SoundDeviceLocatorList *devices) {
+  ClearSoundDeviceLocatorList(devices);
+  SoundDeviceLocator *device;
+  GetDefaultPlaybackDevice(&device);
+  devices->push_back(device);
+  return true;
+}
+
+bool NullSoundSystem::EnumerateCaptureDevices(
+      SoundSystemInterface::SoundDeviceLocatorList *devices) {
+  ClearSoundDeviceLocatorList(devices);
+  SoundDeviceLocator *device;
+  GetDefaultCaptureDevice(&device);
+  devices->push_back(device);
+  return true;
+}
+
+bool NullSoundSystem::GetDefaultPlaybackDevice(
+    SoundDeviceLocator **device) {
+  *device = new NullSoundDeviceLocator();
+  return true;
+}
+
+bool NullSoundSystem::GetDefaultCaptureDevice(
+    SoundDeviceLocator **device) {
+  *device = new NullSoundDeviceLocator();
+  return true;
+}
+
+SoundOutputStreamInterface *NullSoundSystem::OpenPlaybackDevice(
+      const SoundDeviceLocator *device,
+      const OpenParams &params) {
+  return new NullSoundOutputStream();
+}
+
+SoundInputStreamInterface *NullSoundSystem::OpenCaptureDevice(
+      const SoundDeviceLocator *device,
+      const OpenParams &params) {
+  return new NullSoundInputStream();
+}
+
+const char *NullSoundSystem::GetName() const {
+  return kNullName;
+}
+
+}  // namespace cricket
diff --git a/talk/sound/nullsoundsystem.h b/talk/sound/nullsoundsystem.h
new file mode 100644
index 0000000..3edb4f9
--- /dev/null
+++ b/talk/sound/nullsoundsystem.h
@@ -0,0 +1,70 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_SOUND_NULLSOUNDSYSTEM_H_
+#define TALK_SOUND_NULLSOUNDSYSTEM_H_
+
+#include "talk/sound/soundsysteminterface.h"
+
+namespace cricket {
+
+class SoundDeviceLocator;
+class SoundInputStreamInterface;
+class SoundOutputStreamInterface;
+
+// A simple reference sound system that drops output samples and generates
+// no input samples.
+class NullSoundSystem : public SoundSystemInterface {
+ public:
+  static SoundSystemInterface *Create() {
+    return new NullSoundSystem();
+  }
+
+  virtual ~NullSoundSystem();
+
+  virtual bool Init();
+  virtual void Terminate();
+
+  virtual bool EnumeratePlaybackDevices(SoundDeviceLocatorList *devices);
+  virtual bool EnumerateCaptureDevices(SoundDeviceLocatorList *devices);
+
+  virtual SoundOutputStreamInterface *OpenPlaybackDevice(
+      const SoundDeviceLocator *device,
+      const OpenParams &params);
+  virtual SoundInputStreamInterface *OpenCaptureDevice(
+      const SoundDeviceLocator *device,
+      const OpenParams &params);
+
+  virtual bool GetDefaultPlaybackDevice(SoundDeviceLocator **device);
+  virtual bool GetDefaultCaptureDevice(SoundDeviceLocator **device);
+
+  virtual const char *GetName() const;
+};
+
+}  // namespace cricket
+
+#endif  // TALK_SOUND_NULLSOUNDSYSTEM_H_
diff --git a/talk/sound/nullsoundsystemfactory.cc b/talk/sound/nullsoundsystemfactory.cc
new file mode 100644
index 0000000..089d51f
--- /dev/null
+++ b/talk/sound/nullsoundsystemfactory.cc
@@ -0,0 +1,49 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice, 
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products 
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "talk/sound/nullsoundsystemfactory.h"
+
+#include "talk/sound/nullsoundsystem.h"
+
+namespace cricket {
+
+NullSoundSystemFactory::NullSoundSystemFactory() {
+}
+
+NullSoundSystemFactory::~NullSoundSystemFactory() {
+}
+
+bool NullSoundSystemFactory::SetupInstance() {
+  instance_.reset(new NullSoundSystem());
+  return true;
+}
+
+void NullSoundSystemFactory::CleanupInstance() {
+  instance_.reset();
+}
+
+}  // namespace cricket
diff --git a/talk/sound/nullsoundsystemfactory.h b/talk/sound/nullsoundsystemfactory.h
new file mode 100644
index 0000000..71ae980
--- /dev/null
+++ b/talk/sound/nullsoundsystemfactory.h
@@ -0,0 +1,50 @@
+/*
+ * libjingle
+ * Copyright 2004--2010, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice, 
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products 
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_SOUND_NULLSOUNDSYSTEMFACTORY_H_
+#define TALK_SOUND_NULLSOUNDSYSTEMFACTORY_H_
+
+#include "talk/sound/soundsystemfactory.h"
+
+namespace cricket {
+
+// A SoundSystemFactory that always returns a NullSoundSystem. Intended for
+// testing.
+class NullSoundSystemFactory : public SoundSystemFactory {
+ public:
+  NullSoundSystemFactory();
+  virtual ~NullSoundSystemFactory();
+
+ protected:
+  // Inherited from SoundSystemFactory.
+  virtual bool SetupInstance();
+  virtual void CleanupInstance();
+};
+
+}  // namespace cricket
+
+#endif  // TALK_SOUND_NULLSOUNDSYSTEMFACTORY_H_
diff --git a/talk/xmpp/constants.cc b/talk/xmpp/constants.cc
index a1aaa63..cf63e79 100644
--- a/talk/xmpp/constants.cc
+++ b/talk/xmpp/constants.cc
@@ -131,6 +131,13 @@
 const std::string STR_RESULT("result");
 const std::string STR_ERROR("error");
 
+const std::string STR_FORM("form");
+const std::string STR_SUBMIT("submit");
+const std::string STR_TEXT_SINGLE("text-single");
+const std::string STR_LIST_SINGLE("list-single");
+const std::string STR_LIST_MULTI("list-multi");
+const std::string STR_HIDDEN("hidden");
+const std::string STR_FORM_TYPE("FORM_TYPE");
 
 const std::string STR_FROM("from");
 const std::string STR_TO("to");
@@ -160,7 +167,11 @@
 
 const std::string STR_UNAVAILABLE("unavailable");
 
-const std::string STR_MUC_LOOKUP_DOMAIN("lookup.groupchat.google.com");
+const Jid JID_GOOGLE_MUC_LOOKUP("lookup.groupchat.google.com");
+const std::string STR_MUC_ROOMCONFIG_ROOMNAME("muc#roomconfig_roomname");
+const std::string STR_MUC_ROOMCONFIG_FEATURES("muc#roomconfig_features");
+const std::string STR_MUC_ROOM_FEATURE_ENTERPRISE("muc_enterprise");
+const std::string STR_MUC_ROOMCONFIG("http://jabber.org/protocol/muc#roomconfig");
 
 const QName QN_STREAM_STREAM(true, NS_STREAM, STR_STREAM);
 const QName QN_STREAM_FEATURES(true, NS_STREAM, "features");
@@ -379,6 +390,22 @@
 const QName QN_DISCO_ITEMS_QUERY(true, NS_DISCO_ITEMS, "query");
 const QName QN_DISCO_ITEM(true, NS_DISCO_ITEMS, "item");
 
+// JEP 0020
+const std::string NS_FEATURE("http://jabber.org/protocol/feature-neg");
+const QName QN_FEATURE_FEATURE(true, NS_FEATURE, "feature");
+
+// JEP 0004
+const std::string NS_XDATA("jabber:x:data");
+const QName QN_XDATA_X(true, NS_XDATA, "x");
+const QName QN_XDATA_INSTRUCTIONS(true, NS_XDATA, "instructions");
+const QName QN_XDATA_TITLE(true, NS_XDATA, "title");
+const QName QN_XDATA_FIELD(true, NS_XDATA, "field");
+const QName QN_XDATA_REPORTED(true, NS_XDATA, "reported");
+const QName QN_XDATA_ITEM(true, NS_XDATA, "item");
+const QName QN_XDATA_DESC(true, NS_XDATA, "desc");
+const QName QN_XDATA_REQUIRED(true, NS_XDATA, "required");
+const QName QN_XDATA_VALUE(true, NS_XDATA, "value");
+const QName QN_XDATA_OPTION(true, NS_XDATA, "option");
 
 // JEP 0045
 const std::string NS_MUC("http://jabber.org/protocol/muc");
@@ -404,7 +431,7 @@
 const QName QN_SEARCH_QUERY(true, NS_SEARCH, "query");
 const QName QN_SEARCH_ITEM(true, NS_SEARCH, "item");
 const QName QN_SEARCH_ROOM_NAME(true, NS_SEARCH, "room-name");
-const QName QN_SEARCH_ORGANIZERS_DOMAIN(true, NS_SEARCH, "organizers-domain");
+const QName QN_SEARCH_ROOM_DOMAIN(true, NS_SEARCH, "room-domain");
 const QName QN_SEARCH_ROOM_JID(true, NS_SEARCH, "room-jid");
 
 
diff --git a/talk/xmpp/constants.h b/talk/xmpp/constants.h
index ecc8e00..ba9c9e1 100644
--- a/talk/xmpp/constants.h
+++ b/talk/xmpp/constants.h
@@ -85,6 +85,13 @@
 extern const std::string STR_RESULT;
 extern const std::string STR_ERROR;
 
+extern const std::string STR_FORM;
+extern const std::string STR_SUBMIT;
+extern const std::string STR_TEXT_SINGLE;
+extern const std::string STR_LIST_SINGLE;
+extern const std::string STR_LIST_MULTI;
+extern const std::string STR_HIDDEN;
+extern const std::string STR_FORM_TYPE;
 
 extern const std::string STR_FROM;
 extern const std::string STR_TO;
@@ -114,7 +121,10 @@
 
 extern const std::string STR_UNAVAILABLE;
 
-extern const std::string STR_MUC_LOOKUP_DOMAIN;
+extern const Jid JID_GOOGLE_MUC_LOOKUP;
+extern const std::string STR_MUC_ROOMCONFIG_ROOMNAME;
+extern const std::string STR_MUC_ROOMCONFIG_FEATURES;
+extern const std::string STR_MUC_ROOM_FEATURE_ENTERPRISE;
 
 extern const QName QN_STREAM_STREAM;
 extern const QName QN_STREAM_FEATURES;
@@ -345,6 +355,22 @@
 extern const QName QN_DISCO_ITEMS_QUERY;
 extern const QName QN_DISCO_ITEM;
 
+// JEP 0020
+extern const std::string NS_FEATURE;
+extern const QName QN_FEATURE_FEATURE;
+
+// JEP 0004
+extern const std::string NS_XDATA;
+extern const QName QN_XDATA_X;
+extern const QName QN_XDATA_INSTRUCTIONS;
+extern const QName QN_XDATA_TITLE;
+extern const QName QN_XDATA_FIELD;
+extern const QName QN_XDATA_REPORTED;
+extern const QName QN_XDATA_ITEM;
+extern const QName QN_XDATA_DESC;
+extern const QName QN_XDATA_REQUIRED;
+extern const QName QN_XDATA_VALUE;
+extern const QName QN_XDATA_OPTION;
 
 // JEP 0045
 extern const std::string NS_MUC;
@@ -371,7 +397,7 @@
 extern const QName QN_SEARCH_ITEM;
 extern const QName QN_SEARCH_ROOM_NAME;
 extern const QName QN_SEARCH_ROOM_JID;
-extern const QName QN_SEARCH_ORGANIZERS_DOMAIN;
+extern const QName QN_SEARCH_ROOM_DOMAIN;
 
 
 // JEP 0115
diff --git a/talk/xmpp/iqtask.cc b/talk/xmpp/iqtask.cc
index f319990..f54f630 100644
--- a/talk/xmpp/iqtask.cc
+++ b/talk/xmpp/iqtask.cc
@@ -73,13 +73,13 @@
   if (success) {
     HandleResult(stanza);
   } else {
-    SignalError(stanza->FirstNamed(QN_ERROR));
+    SignalError(this, stanza->FirstNamed(QN_ERROR));
   }
   return STATE_DONE;
 }
 
 int IqTask::OnTimeout() {
-  SignalError(NULL);
+  SignalError(this, NULL);
   return XmppTask::OnTimeout();
 }
 
diff --git a/talk/xmpp/iqtask.h b/talk/xmpp/iqtask.h
index 7d9d621..589616b 100644
--- a/talk/xmpp/iqtask.h
+++ b/talk/xmpp/iqtask.h
@@ -42,7 +42,8 @@
          buzz::XmlElement* el);
   virtual ~IqTask() {}
 
-  sigslot::signal1<const XmlElement*> SignalError;
+  sigslot::signal2<IqTask*,
+                   const XmlElement*> SignalError;
 
  protected:
   virtual void HandleResult(const buzz::XmlElement* element) = 0;
diff --git a/talk/xmpp/mucroomconfigtask.cc b/talk/xmpp/mucroomconfigtask.cc
new file mode 100644
index 0000000..272bd44
--- /dev/null
+++ b/talk/xmpp/mucroomconfigtask.cc
@@ -0,0 +1,91 @@
+/*
+ * libjingle
+ * Copyright 2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <string>
+#include <vector>
+
+#include "talk/xmpp/mucroomconfigtask.h"
+
+#include "talk/base/scoped_ptr.h"
+#include "talk/xmpp/constants.h"
+
+namespace buzz {
+
+MucRoomConfigTask::MucRoomConfigTask(
+    XmppTaskParentInterface* parent,
+    const Jid& room_jid,
+    const std::string& room_name,
+    const std::vector<std::string>& room_features)
+    : IqTask(parent, STR_SET, room_jid,
+             MakeRequest(room_name, room_features)),
+      room_jid_(room_jid) {
+}
+
+XmlElement* MucRoomConfigTask::MakeRequest(
+    const std::string& room_name,
+    const std::vector<std::string>& room_features) {
+  buzz::XmlElement* owner_query = new
+      buzz::XmlElement(buzz::QN_MUC_OWNER_QUERY, true);
+
+  buzz::XmlElement* x_form = new buzz::XmlElement(buzz::QN_XDATA_X, true);
+  x_form->SetAttr(buzz::QN_TYPE, buzz::STR_FORM);
+
+  buzz::XmlElement* roomname_field =
+      new buzz::XmlElement(buzz::QN_XDATA_FIELD, false);
+  roomname_field->SetAttr(buzz::QN_VAR, buzz::STR_MUC_ROOMCONFIG_ROOMNAME);
+  roomname_field->SetAttr(buzz::QN_TYPE, buzz::STR_TEXT_SINGLE);
+
+  buzz::XmlElement* roomname_value =
+      new buzz::XmlElement(buzz::QN_XDATA_VALUE, false);
+  roomname_value->SetBodyText(room_name);
+
+  roomname_field->AddElement(roomname_value);
+  x_form->AddElement(roomname_field);
+
+  buzz::XmlElement* features_field =
+      new buzz::XmlElement(buzz::QN_XDATA_FIELD, false);
+  features_field->SetAttr(buzz::QN_VAR, buzz::STR_MUC_ROOMCONFIG_FEATURES);
+  features_field->SetAttr(buzz::QN_TYPE, buzz::STR_LIST_MULTI);
+
+  for (std::vector<std::string>::const_iterator feature = room_features.begin();
+       feature != room_features.end(); ++feature) {
+    buzz::XmlElement* features_value =
+        new buzz::XmlElement(buzz::QN_XDATA_VALUE, false);
+    features_value->SetBodyText(*feature);
+    features_field->AddElement(features_value);
+  }
+
+  x_form->AddElement(features_field);
+  owner_query->AddElement(x_form);
+  return owner_query;
+}
+
+void MucRoomConfigTask::HandleResult(const XmlElement* element) {
+  SignalResult(this);
+}
+
+}  // namespace buzz
diff --git a/talk/xmpp/mucroomconfigtask.h b/talk/xmpp/mucroomconfigtask.h
new file mode 100644
index 0000000..ba0dbaa
--- /dev/null
+++ b/talk/xmpp/mucroomconfigtask.h
@@ -0,0 +1,64 @@
+/*
+ * libjingle
+ * Copyright 2011, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TALK_XMPP_MUCROOMCONFIGTASK_H_
+#define TALK_XMPP_MUCROOMCONFIGTASK_H_
+
+#include <string>
+#include "talk/xmpp/iqtask.h"
+
+namespace buzz {
+
+// This task configures the muc room for document sharing and other enterprise
+// specific goodies.
+class MucRoomConfigTask : public IqTask {
+ public:
+  MucRoomConfigTask(XmppTaskParentInterface* parent,
+                    const Jid& room_jid,
+                    const std::string& room_name,
+                    const std::vector<std::string>& room_features);
+
+  // Room configuration does not return any reasonable error
+  // values. The First config request configures the room, subseqent
+  // ones are just ignored by server and server returns empty
+  // response.
+  sigslot::signal1<MucRoomConfigTask*> SignalResult;
+
+  const Jid& room_jid() const { return room_jid_; }
+
+ protected:
+  virtual void HandleResult(const XmlElement* stanza);
+
+ private:
+  static XmlElement* MakeRequest(const std::string& room_name,
+                                 const std::vector<std::string>& room_features);
+  Jid room_jid_;
+};
+
+}  // namespace buzz
+
+#endif  // TALK_XMPP_MUCROOMCONFIGTASK_H_
diff --git a/talk/xmpp/mucroomlookuptask.cc b/talk/xmpp/mucroomlookuptask.cc
index e6a204a..278dc38 100644
--- a/talk/xmpp/mucroomlookuptask.cc
+++ b/talk/xmpp/mucroomlookuptask.cc
@@ -35,28 +35,30 @@
 namespace buzz {
 
 MucRoomLookupTask::MucRoomLookupTask(XmppTaskParentInterface* parent,
+                                     const Jid& lookup_server_jid,
                                      const std::string& room_name,
-                                     const std::string& organizer_domain)
-    : IqTask(parent, STR_SET, Jid(STR_MUC_LOOKUP_DOMAIN),
-             MakeRoomQuery(room_name, organizer_domain)) {
+                                     const std::string& room_domain)
+    : IqTask(parent, STR_SET, lookup_server_jid,
+             MakeNameQuery(room_name, room_domain)) {
 }
 
 MucRoomLookupTask::MucRoomLookupTask(XmppTaskParentInterface* parent,
+                                     const Jid& lookup_server_jid,
                                      const Jid& room_jid)
-    : IqTask(parent, STR_SET, Jid(STR_MUC_LOOKUP_DOMAIN),
+    : IqTask(parent, STR_SET, lookup_server_jid,
              MakeJidQuery(room_jid)) {
 }
 
-XmlElement* MucRoomLookupTask::MakeRoomQuery(const std::string& room_name,
-    const std::string& org_domain) {
-  XmlElement* room_elem = new XmlElement(QN_SEARCH_ROOM_NAME, false);
-  room_elem->SetBodyText(room_name);
+XmlElement* MucRoomLookupTask::MakeNameQuery(
+    const std::string& room_name, const std::string& room_domain) {
+  XmlElement* name_elem = new XmlElement(QN_SEARCH_ROOM_NAME, false);
+  name_elem->SetBodyText(room_name);
 
-  XmlElement* domain_elem = new XmlElement(QN_SEARCH_ORGANIZERS_DOMAIN, false);
-  domain_elem->SetBodyText(org_domain);
+  XmlElement* domain_elem = new XmlElement(QN_SEARCH_ROOM_DOMAIN, false);
+  domain_elem->SetBodyText(room_domain);
 
   XmlElement* query = new XmlElement(QN_SEARCH_QUERY, true);
-  query->AddElement(room_elem);
+  query->AddElement(name_elem);
   query->AddElement(domain_elem);
   return query;
 }
@@ -72,37 +74,37 @@
 
 void MucRoomLookupTask::HandleResult(const XmlElement* stanza) {
   const XmlElement* query_elem = stanza->FirstNamed(QN_SEARCH_QUERY);
-  if (query_elem != NULL) {
-    const XmlElement* item_elem =
-        query_elem->FirstNamed(QN_SEARCH_ITEM);
-    if (item_elem != NULL && item_elem->HasAttr(QN_JID)) {
-      MucRoomInfo room_info;
-      if (GetRoomInfoFromResponse(item_elem, &room_info)) {
-        SignalResult(room_info);
-        return;
-      }
-    }
+  if (query_elem == NULL) {
+    SignalError(this, NULL);
+    return;
   }
 
-  SignalError(NULL);
-}
+  const XmlElement* item_elem = query_elem->FirstNamed(QN_SEARCH_ITEM);
+  if (item_elem == NULL) {
+    SignalError(this, NULL);
+    return;
+  }
 
-bool MucRoomLookupTask::GetRoomInfoFromResponse(
-    const XmlElement* stanza, MucRoomInfo* info) {
+  MucRoomInfo room;
+  room.jid = Jid(item_elem->Attr(buzz::QN_JID));
+  if (!room.jid.IsValid()) {
+    SignalError(this, NULL);
+    return;
+  }
 
-  info->room_jid = Jid(stanza->Attr(buzz::QN_JID));
-  if (!info->room_jid.IsValid()) return false;
+  const XmlElement* room_name_elem =
+      item_elem->FirstNamed(QN_SEARCH_ROOM_NAME);
+  if (room_name_elem != NULL) {
+    room.name = room_name_elem->BodyText();
+  }
 
-  const XmlElement* room_name_elem = stanza->FirstNamed(QN_SEARCH_ROOM_NAME);
-  const XmlElement* org_domain_elem =
-      stanza->FirstNamed(QN_SEARCH_ORGANIZERS_DOMAIN);
+  const XmlElement* room_domain_elem =
+      item_elem->FirstNamed(QN_SEARCH_ROOM_DOMAIN);
+  if (room_domain_elem != NULL) {
+    room.domain = room_domain_elem->BodyText();
+  }
 
-  if (room_name_elem != NULL)
-    info->room_name = room_name_elem->BodyText();
-  if (org_domain_elem != NULL)
-    info->organizer_domain = org_domain_elem->BodyText();
-
-  return true;
+  SignalResult(this, room);
 }
 
 }  // namespace buzz
diff --git a/talk/xmpp/mucroomlookuptask.h b/talk/xmpp/mucroomlookuptask.h
index e8e6c76..ec5873c 100644
--- a/talk/xmpp/mucroomlookuptask.h
+++ b/talk/xmpp/mucroomlookuptask.h
@@ -34,28 +34,35 @@
 namespace buzz {
 
 struct MucRoomInfo {
-  Jid room_jid;
-  std::string room_name;
-  std::string organizer_domain;
+  Jid jid;
+  std::string name;
+  std::string domain;
+
+  std::string full_name() const {
+    return name + "@" + domain;
+  }
 };
 
 class MucRoomLookupTask : public IqTask {
  public:
   MucRoomLookupTask(XmppTaskParentInterface* parent,
+                    const Jid& lookup_jid,
                     const std::string& room_name,
-                    const std::string& organizer_domain);
+                    const std::string& room_domain);
   MucRoomLookupTask(XmppTaskParentInterface* parent,
+                    const Jid& lookup_jid,
                     const Jid& room_jid);
 
-  sigslot::signal1<const MucRoomInfo&> SignalResult;
+  sigslot::signal2<MucRoomLookupTask*,
+                   const MucRoomInfo&> SignalResult;
+
+ protected:
+  virtual void HandleResult(const XmlElement* element);
 
  private:
-  static XmlElement* MakeRoomQuery(const std::string& room_name,
-                                   const std::string& org_domain);
+  static XmlElement* MakeNameQuery(const std::string& room_name,
+                                   const std::string& room_domain);
   static XmlElement* MakeJidQuery(const Jid& room_jid);
-  virtual void HandleResult(const XmlElement* element);
-  static bool GetRoomInfoFromResponse(const XmlElement* stanza,
-                                      MucRoomInfo* info);
 };
 
 }  // namespace buzz