diff --git a/talk/app/webrtc/localaudiosource.cc b/talk/app/webrtc/localaudiosource.cc
index 3dc5c6c34..2cd472a5a 100644
--- a/talk/app/webrtc/localaudiosource.cc
+++ b/talk/app/webrtc/localaudiosource.cc
@@ -54,6 +54,8 @@ const char MediaConstraintsInterface::kHighpassFilter[] =
 const char MediaConstraintsInterface::kTypingNoiseDetection[] =
     "googTypingNoiseDetection";
 const char MediaConstraintsInterface::kAudioMirroring[] = "googAudioMirroring";
+// TODO(perkj): Remove kInternalAecDump once its not used by Chrome.
+const char MediaConstraintsInterface::kInternalAecDump[] = "deprecatedAecDump";
 
 namespace {
 
@@ -127,6 +129,8 @@ void LocalAudioSource::Initialize(
     return;
   }
   options_.SetAll(audio_options);
+  if (options.enable_aec_dump)
+    options_.aec_dump.Set(true);
   source_state_ = kLive;
 }
 
diff --git a/talk/app/webrtc/mediaconstraintsinterface.h b/talk/app/webrtc/mediaconstraintsinterface.h
index 5cf2184f9..ba6b09be9 100644
--- a/talk/app/webrtc/mediaconstraintsinterface.h
+++ b/talk/app/webrtc/mediaconstraintsinterface.h
@@ -117,6 +117,13 @@ class MediaConstraintsInterface {
   // stripped by Chrome before passed down to Libjingle.
   static const char kInternalConstraintPrefix[];
 
+  // These constraints are for internal use only, representing Chrome command
+  // line flags. So they are prefixed with "internal" so JS values will be
+  // removed.
+  // Used by a local audio source.
+  // TODO(perkj): Remove once Chrome use PeerConnectionFactory::SetOptions.
+  static const char kInternalAecDump[];  // internalAecDump
+
  protected:
   // Dtor protected as objects shouldn't be deleted via this interface
   virtual ~MediaConstraintsInterface() {}
diff --git a/talk/app/webrtc/peerconnectionfactory.cc b/talk/app/webrtc/peerconnectionfactory.cc
index ee15b5d01..e8b8f6316 100644
--- a/talk/app/webrtc/peerconnectionfactory.cc
+++ b/talk/app/webrtc/peerconnectionfactory.cc
@@ -105,21 +105,12 @@ struct CreateVideoSourceParams : public talk_base::MessageData {
   scoped_refptr<webrtc::VideoSourceInterface> source;
 };
 
-struct StartAecDumpParams : public talk_base::MessageData {
-  explicit StartAecDumpParams(FILE* aec_dump_file)
-      : aec_dump_file(aec_dump_file) {
-  }
-  FILE* aec_dump_file;
-  bool result;
-};
-
 enum {
   MSG_INIT_FACTORY = 1,
   MSG_TERMINATE_FACTORY,
   MSG_CREATE_PEERCONNECTION,
   MSG_CREATE_AUDIOSOURCE,
   MSG_CREATE_VIDEOSOURCE,
-  MSG_START_AEC_DUMP,
 };
 
 }  // namespace
@@ -232,12 +223,6 @@ void PeerConnectionFactory::OnMessage(talk_base::Message* msg) {
       pdata->source = CreateVideoSource_s(pdata->capturer, pdata->constraints);
       break;
     }
-    case MSG_START_AEC_DUMP: {
-      StartAecDumpParams* pdata =
-          static_cast<StartAecDumpParams*>(msg->pdata);
-      pdata->result = StartAecDump_s(pdata->aec_dump_file);
-      break;
-    }
   }
 }
 
@@ -289,10 +274,6 @@ PeerConnectionFactory::CreateVideoSource_s(
   return VideoSourceProxy::Create(signaling_thread_, source);
 }
 
-bool PeerConnectionFactory::StartAecDump_s(FILE* file) {
-  return channel_manager_->StartAecDump(file);
-}
-
 scoped_refptr<PeerConnectionInterface>
 PeerConnectionFactory::CreatePeerConnection(
     const PeerConnectionInterface::IceServers& configuration,
@@ -380,12 +361,6 @@ scoped_refptr<AudioTrackInterface> PeerConnectionFactory::CreateAudioTrack(
   return AudioTrackProxy::Create(signaling_thread_, track);
 }
 
-bool PeerConnectionFactory::StartAecDump(FILE* file) {
-  StartAecDumpParams params(file);
-  signaling_thread_->Send(this, MSG_START_AEC_DUMP, &params);
-  return params.result;
-}
-
 cricket::ChannelManager* PeerConnectionFactory::channel_manager() {
   return channel_manager_.get();
 }
diff --git a/talk/app/webrtc/peerconnectionfactory.h b/talk/app/webrtc/peerconnectionfactory.h
index 63d37f03d..dff885dfe 100644
--- a/talk/app/webrtc/peerconnectionfactory.h
+++ b/talk/app/webrtc/peerconnectionfactory.h
@@ -78,8 +78,6 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface,
       CreateAudioTrack(const std::string& id,
                        AudioSourceInterface* audio_source);
 
-  virtual bool StartAecDump(FILE* file);
-
   virtual cricket::ChannelManager* channel_manager();
   virtual talk_base::Thread* signaling_thread();
   virtual talk_base::Thread* worker_thread();
@@ -95,6 +93,7 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface,
       cricket::WebRtcVideoDecoderFactory* video_decoder_factory);
   virtual ~PeerConnectionFactory();
 
+
  private:
   bool Initialize_s();
   void Terminate_s();
@@ -109,8 +108,6 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface,
       PortAllocatorFactoryInterface* allocator_factory,
       DTLSIdentityServiceInterface* dtls_identity_service,
       PeerConnectionObserver* observer);
-  bool StartAecDump_s(FILE* file);
-
   // Implements talk_base::MessageHandler.
   void OnMessage(talk_base::Message* msg);
 
diff --git a/talk/app/webrtc/peerconnectioninterface.h b/talk/app/webrtc/peerconnectioninterface.h
index 01f1e1ccc..a127dad3a 100644
--- a/talk/app/webrtc/peerconnectioninterface.h
+++ b/talk/app/webrtc/peerconnectioninterface.h
@@ -393,9 +393,11 @@ class PeerConnectionFactoryInterface : public talk_base::RefCountInterface {
   class Options {
    public:
     Options() :
+      enable_aec_dump(false),
       disable_encryption(false),
       disable_sctp_data_channels(false) {
     }
+    bool enable_aec_dump;
     bool disable_encryption;
     bool disable_sctp_data_channels;
   };
@@ -440,12 +442,6 @@ class PeerConnectionFactoryInterface : public talk_base::RefCountInterface {
       CreateAudioTrack(const std::string& label,
                        AudioSourceInterface* source) = 0;
 
-  // Starts AEC dump using existing file. Takes ownership of |file| and passes
-  // it on to VoiceEngine (via other objects) immediately, which will take
-  // the ownerhip.
-  // TODO(grunell): Remove when Chromium has started to use AEC in each source.
-  virtual bool StartAecDump(FILE* file) = 0;
-
  protected:
   // Dtor and ctor protected as objects shouldn't be created or deleted via
   // this interface.
diff --git a/talk/base/asyncpacketsocket.h b/talk/base/asyncpacketsocket.h
index 29ab55ffc..3b4748f51 100644
--- a/talk/base/asyncpacketsocket.h
+++ b/talk/base/asyncpacketsocket.h
@@ -31,30 +31,9 @@
 #include "talk/base/dscp.h"
 #include "talk/base/sigslot.h"
 #include "talk/base/socket.h"
-#include "talk/base/timeutils.h"
 
 namespace talk_base {
 
-// This structure will have the information about when packet is actually
-// received by socket.
-struct PacketTime {
-  PacketTime() : timestamp(-1), not_before(-1) {}
-  PacketTime(int64 timestamp, int64 not_before)
-      : timestamp(timestamp), not_before(not_before) {
-  }
-
-  int64 timestamp;  // Receive time after socket delivers the data.
-  int64 not_before; // Earliest possible time the data could have arrived,
-                    // indicating the potential error in the |timestamp| value,
-                    // in case the system, is busy. For example, the time of
-                    // the last select() call.
-                    // If unknown, this value will be set to zero.
-};
-
-inline PacketTime CreatePacketTime(int64 not_before) {
-  return PacketTime(TimeMicros(), not_before);
-}
-
 // Provides the ability to receive packets asynchronously. Sends are not
 // buffered since it is acceptable to drop packets under high load.
 class AsyncPacketSocket : public sigslot::has_slots<> {
@@ -99,9 +78,8 @@ class AsyncPacketSocket : public sigslot::has_slots<> {
 
   // Emitted each time a packet is read. Used only for UDP and
   // connected TCP sockets.
-  sigslot::signal5<AsyncPacketSocket*, const char*, size_t,
-                   const SocketAddress&,
-                   const PacketTime&> SignalReadPacket;
+  sigslot::signal4<AsyncPacketSocket*, const char*, size_t,
+                   const SocketAddress&> SignalReadPacket;
 
   // Emitted when the socket is currently able to send.
   sigslot::signal1<AsyncPacketSocket*> SignalReadyToSend;
diff --git a/talk/base/asynctcpsocket.cc b/talk/base/asynctcpsocket.cc
index d2ae513fd..517e799c4 100644
--- a/talk/base/asynctcpsocket.cc
+++ b/talk/base/asynctcpsocket.cc
@@ -300,8 +300,7 @@ void AsyncTCPSocket::ProcessInput(char * data, size_t* len) {
     if (*len < kPacketLenSize + pkt_len)
       return;
 
-    SignalReadPacket(this, data + kPacketLenSize, pkt_len, remote_addr,
-                     CreatePacketTime(0));
+    SignalReadPacket(this, data + kPacketLenSize, pkt_len, remote_addr);
 
     *len -= kPacketLenSize + pkt_len;
     if (*len > 0) {
diff --git a/talk/base/asyncudpsocket.cc b/talk/base/asyncudpsocket.cc
index 50052630d..97e5dff98 100644
--- a/talk/base/asyncudpsocket.cc
+++ b/talk/base/asyncudpsocket.cc
@@ -128,8 +128,7 @@ void AsyncUDPSocket::OnReadEvent(AsyncSocket* socket) {
 
   // TODO: Make sure that we got all of the packet.
   // If we did not, then we should resize our buffer to be large enough.
-  SignalReadPacket(this, buf_, static_cast<size_t>(len), remote_addr,
-                   CreatePacketTime(0));
+  SignalReadPacket(this, buf_, (size_t)len, remote_addr);
 }
 
 void AsyncUDPSocket::OnWriteEvent(AsyncSocket* socket) {
diff --git a/talk/base/natserver.cc b/talk/base/natserver.cc
index 469804871..3ad378ca5 100644
--- a/talk/base/natserver.cc
+++ b/talk/base/natserver.cc
@@ -107,7 +107,7 @@ NATServer::~NATServer() {
 
 void NATServer::OnInternalPacket(
     AsyncPacketSocket* socket, const char* buf, size_t size,
-    const SocketAddress& addr, const PacketTime& packet_time) {
+    const SocketAddress& addr) {
 
   // Read the intended destination from the wire.
   SocketAddress dest_addr;
@@ -132,7 +132,7 @@ void NATServer::OnInternalPacket(
 
 void NATServer::OnExternalPacket(
     AsyncPacketSocket* socket, const char* buf, size_t size,
-    const SocketAddress& remote_addr, const PacketTime& packet_time) {
+    const SocketAddress& remote_addr) {
 
   SocketAddress local_addr = socket->GetLocalAddress();
 
diff --git a/talk/base/natserver.h b/talk/base/natserver.h
index 05d3475c9..ed3b0b642 100644
--- a/talk/base/natserver.h
+++ b/talk/base/natserver.h
@@ -79,11 +79,9 @@ class NATServer : public sigslot::has_slots<> {
 
   // Packets received on one of the networks.
   void OnInternalPacket(AsyncPacketSocket* socket, const char* buf,
-                        size_t size, const SocketAddress& addr,
-                        const PacketTime& packet_time);
+                        size_t size, const SocketAddress& addr);
   void OnExternalPacket(AsyncPacketSocket* socket, const char* buf,
-                        size_t size, const SocketAddress& remote_addr,
-                        const PacketTime& packet_time);
+                        size_t size, const SocketAddress& remote_addr);
 
  private:
   typedef std::set<SocketAddress, AddrCmp> AddressSet;
diff --git a/talk/base/sslstreamadapter_unittest.cc b/talk/base/sslstreamadapter_unittest.cc
index e7335be48..4b2fd6d84 100644
--- a/talk/base/sslstreamadapter_unittest.cc
+++ b/talk/base/sslstreamadapter_unittest.cc
@@ -762,7 +762,7 @@ TEST_F(SSLStreamAdapterTestDTLS,
 };
 
 // Test a handshake with small MTU
-TEST_F(SSLStreamAdapterTestDTLS, TestDTLSConnectWithSmallMtu) {
+TEST_F(SSLStreamAdapterTestDTLS, DISABLED_TestDTLSConnectWithSmallMtu) {
   MAYBE_SKIP_TEST(HaveDtls);
   SetMtu(700);
   SetHandshakeWait(20000);
diff --git a/talk/base/testclient.cc b/talk/base/testclient.cc
index 04d603099..1a1276131 100644
--- a/talk/base/testclient.cc
+++ b/talk/base/testclient.cc
@@ -135,8 +135,7 @@ bool TestClient::ready_to_send() const {
 }
 
 void TestClient::OnPacket(AsyncPacketSocket* socket, const char* buf,
-                          size_t size, const SocketAddress& remote_addr,
-                          const PacketTime& packet_time) {
+                          size_t size, const SocketAddress& remote_addr) {
   CritScope cs(&crit_);
   packets_->push_back(new Packet(remote_addr, buf, size));
 }
diff --git a/talk/base/testclient.h b/talk/base/testclient.h
index 87e32df1f..1e1780a29 100644
--- a/talk/base/testclient.h
+++ b/talk/base/testclient.h
@@ -94,8 +94,7 @@ class TestClient : public sigslot::has_slots<> {
   Socket::ConnState GetState();
   // Slot for packets read on the socket.
   void OnPacket(AsyncPacketSocket* socket, const char* buf, size_t len,
-                const SocketAddress& remote_addr,
-                const PacketTime& packet_time);
+                const SocketAddress& remote_addr);
   void OnReadyToSend(AsyncPacketSocket* socket);
 
   CriticalSection crit_;
diff --git a/talk/base/testechoserver.h b/talk/base/testechoserver.h
index 5c1045423..10466fa43 100644
--- a/talk/base/testechoserver.h
+++ b/talk/base/testechoserver.h
@@ -67,8 +67,7 @@ class TestEchoServer : public sigslot::has_slots<> {
     }
   }
   void OnPacket(AsyncPacketSocket* socket, const char* buf, size_t size,
-                const SocketAddress& remote_addr,
-                const PacketTime& packet_time) {
+                const SocketAddress& remote_addr) {
     socket->Send(buf, size, DSCP_NO_CHANGE);
   }
   void OnClose(AsyncPacketSocket* socket, int err) {
diff --git a/talk/base/thread_unittest.cc b/talk/base/thread_unittest.cc
index 896fbabc5..d6af17ac1 100644
--- a/talk/base/thread_unittest.cc
+++ b/talk/base/thread_unittest.cc
@@ -81,8 +81,7 @@ class SocketClient : public TestGenerator, public sigslot::has_slots<> {
   SocketAddress address() const { return socket_->GetLocalAddress(); }
 
   void OnPacket(AsyncPacketSocket* socket, const char* buf, size_t size,
-                const SocketAddress& remote_addr,
-                const PacketTime& packet_time) {
+                const SocketAddress& remote_addr) {
     EXPECT_EQ(size, sizeof(uint32));
     uint32 prev = reinterpret_cast<const uint32*>(buf)[0];
     uint32 result = Next(prev);
diff --git a/talk/base/timeutils.cc b/talk/base/timeutils.cc
index 54db3418b..66b9bf2c7 100644
--- a/talk/base/timeutils.cc
+++ b/talk/base/timeutils.cc
@@ -94,10 +94,6 @@ uint32 Time() {
   return static_cast<uint32>(TimeNanos() / kNumNanosecsPerMillisec);
 }
 
-uint64 TimeMicros() {
-  return static_cast<uint64>(TimeNanos() / kNumNanosecsPerMicrosec);
-}
-
 #if defined(WIN32)
 static const uint64 kFileTimeToUnixTimeEpochOffset = 116444736000000000ULL;
 
diff --git a/talk/base/timeutils.h b/talk/base/timeutils.h
index f13c3f2ef..545e86a12 100644
--- a/talk/base/timeutils.h
+++ b/talk/base/timeutils.h
@@ -42,8 +42,6 @@ static const int64 kNumMicrosecsPerMillisec = kNumMicrosecsPerSec /
     kNumMillisecsPerSec;
 static const int64 kNumNanosecsPerMillisec =  kNumNanosecsPerSec /
     kNumMillisecsPerSec;
-static const int64 kNumNanosecsPerMicrosec =  kNumNanosecsPerSec /
-    kNumMicrosecsPerSec;
 
 // January 1970, in NTP milliseconds.
 static const int64 kJan1970AsNtpMillisecs = INT64_C(2208988800000);
@@ -52,8 +50,6 @@ typedef uint32 TimeStamp;
 
 // Returns the current time in milliseconds.
 uint32 Time();
-// Returns the current time in microseconds.
-uint64 TimeMicros();
 // Returns the current time in nanoseconds.
 uint64 TimeNanos();
 
diff --git a/talk/base/virtualsocket_unittest.cc b/talk/base/virtualsocket_unittest.cc
index b31b8c8b0..7bbb5f0bc 100644
--- a/talk/base/virtualsocket_unittest.cc
+++ b/talk/base/virtualsocket_unittest.cc
@@ -97,8 +97,7 @@ struct Receiver : public MessageHandler, public sigslot::has_slots<> {
   }
 
   void OnReadPacket(AsyncPacketSocket* s, const char* data, size_t size,
-                    const SocketAddress& remote_addr,
-                    const PacketTime& packet_time) {
+                    const SocketAddress& remote_addr) {
     ASSERT_EQ(socket.get(), s);
     ASSERT_GE(size, 4U);
 
diff --git a/talk/build/isolate.gypi b/talk/build/isolate.gypi
index 83dd502a6..7b0ac1254 100644
--- a/talk/build/isolate.gypi
+++ b/talk/build/isolate.gypi
@@ -71,9 +71,9 @@
       'extension': 'isolate',
       'inputs': [
         # Files that are known to be involved in this step.
-        '<(DEPTH)/tools/swarm_client/isolate.py',
-        '<(DEPTH)/tools/swarm_client/run_isolated.py',
-        '<(DEPTH)/tools/swarm_client/googletest/run_test_cases.py',
+        '<(DEPTH)/tools/swarming_client/isolate.py',
+        '<(DEPTH)/tools/swarming_client/run_isolated.py',
+        '<(DEPTH)/tools/swarming_client/googletest/run_test_cases.py',
 
         # Disable file tracking by the build driver for now. This means the
         # project must have the proper build-time dependency for their runtime
@@ -94,7 +94,7 @@
         ["test_isolation_outdir==''", {
           'action': [
             'python',
-            '<(DEPTH)/tools/swarm_client/isolate.py',
+            '<(DEPTH)/tools/swarming_client/isolate.py',
             '<(test_isolation_mode)',
             # GYP will eliminate duplicate arguments so '<(PRODUCT_DIR)' cannot
             # be provided twice. To work around this behavior, append '/'.
@@ -114,7 +114,7 @@
         }, {
           'action': [
             'python',
-            '<(DEPTH)/tools/swarm_client/isolate.py',
+            '<(DEPTH)/tools/swarming_client/isolate.py',
             '<(test_isolation_mode)',
             '--outdir', '<(test_isolation_outdir)',
             # See comment above.
diff --git a/talk/examples/android/project.properties b/talk/examples/android/project.properties
index bc163b0b2..8459f9b81 100644
--- a/talk/examples/android/project.properties
+++ b/talk/examples/android/project.properties
@@ -11,6 +11,6 @@
 #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
 
 # Project target.
-target=android-17
+target=android-19
 
 java.compilerargs=-Xlint:all -Werror
diff --git a/talk/libjingle_media_unittest.isolate b/talk/libjingle_media_unittest.isolate
index 4c4ee314b..36b50b5f3 100644
--- a/talk/libjingle_media_unittest.isolate
+++ b/talk/libjingle_media_unittest.isolate
@@ -30,7 +30,6 @@
       'variables': {
         'command': [
           '../testing/test_env.py',
-          '../tools/swarm_client/googletest/run_test_cases.py',
           '<(PRODUCT_DIR)/libjingle_media_unittest<(EXECUTABLE_SUFFIX)',
         ],
         'isolate_dependency_tracked': [
@@ -39,7 +38,7 @@
           '<(PRODUCT_DIR)/libjingle_media_unittest<(EXECUTABLE_SUFFIX)',
         ],
         'isolate_dependency_untracked': [
-          '../tools/swarm_client/',
+          '../tools/swarming_client/',
         ],
       },
     }],
diff --git a/talk/libjingle_p2p_unittest.isolate b/talk/libjingle_p2p_unittest.isolate
index 848f234d2..b5ad4ff2d 100644
--- a/talk/libjingle_p2p_unittest.isolate
+++ b/talk/libjingle_p2p_unittest.isolate
@@ -30,7 +30,6 @@
       'variables': {
         'command': [
           '../testing/test_env.py',
-          '../tools/swarm_client/googletest/run_test_cases.py',
           '<(PRODUCT_DIR)/libjingle_p2p_unittest<(EXECUTABLE_SUFFIX)',
         ],
         'isolate_dependency_tracked': [
@@ -38,7 +37,7 @@
           '<(PRODUCT_DIR)/libjingle_p2p_unittest<(EXECUTABLE_SUFFIX)',
         ],
         'isolate_dependency_untracked': [
-          '../tools/swarm_client/',
+          '../tools/swarming_client/',
         ],
       },
     }],
diff --git a/talk/libjingle_peerconnection_unittest.isolate b/talk/libjingle_peerconnection_unittest.isolate
index 660ffd5e6..e7dd6878a 100644
--- a/talk/libjingle_peerconnection_unittest.isolate
+++ b/talk/libjingle_peerconnection_unittest.isolate
@@ -30,7 +30,6 @@
       'variables': {
         'command': [
           '../testing/test_env.py',
-          '../tools/swarm_client/googletest/run_test_cases.py',
           '<(PRODUCT_DIR)/libjingle_peerconnection_unittest<(EXECUTABLE_SUFFIX)',
         ],
         'isolate_dependency_tracked': [
@@ -38,7 +37,7 @@
           '<(PRODUCT_DIR)/libjingle_peerconnection_unittest<(EXECUTABLE_SUFFIX)',
         ],
         'isolate_dependency_untracked': [
-          '../tools/swarm_client/',
+          '../tools/swarming_client/',
         ],
       },
     }],
diff --git a/talk/libjingle_sound_unittest.isolate b/talk/libjingle_sound_unittest.isolate
index 6da7d881b..716633795 100644
--- a/talk/libjingle_sound_unittest.isolate
+++ b/talk/libjingle_sound_unittest.isolate
@@ -30,7 +30,6 @@
       'variables': {
         'command': [
           '../testing/test_env.py',
-          '../tools/swarm_client/googletest/run_test_cases.py',
           '<(PRODUCT_DIR)/libjingle_sound_unittest<(EXECUTABLE_SUFFIX)',
         ],
         'isolate_dependency_tracked': [
@@ -38,7 +37,7 @@
           '<(PRODUCT_DIR)/libjingle_sound_unittest<(EXECUTABLE_SUFFIX)',
         ],
         'isolate_dependency_untracked': [
-          '../tools/swarm_client/',
+          '../tools/swarming_client/',
         ],
       },
     }],
diff --git a/talk/libjingle_unittest.isolate b/talk/libjingle_unittest.isolate
index efb862544..e678af013 100644
--- a/talk/libjingle_unittest.isolate
+++ b/talk/libjingle_unittest.isolate
@@ -30,7 +30,6 @@
       'variables': {
         'command': [
           '../testing/test_env.py',
-          '../tools/swarm_client/googletest/run_test_cases.py',
           '<(PRODUCT_DIR)/libjingle_unittest<(EXECUTABLE_SUFFIX)',
         ],
         'isolate_dependency_tracked': [
@@ -38,7 +37,7 @@
           '<(PRODUCT_DIR)/libjingle_unittest<(EXECUTABLE_SUFFIX)',
         ],
         'isolate_dependency_untracked': [
-          '../tools/swarm_client/',
+          '../tools/swarming_client/',
         ],
       },
     }],
diff --git a/talk/media/base/fakemediaengine.h b/talk/media/base/fakemediaengine.h
index d71c66006..c44db68cd 100644
--- a/talk/media/base/fakemediaengine.h
+++ b/talk/media/base/fakemediaengine.h
@@ -191,12 +191,10 @@ template <class Base> class RtpHelper : public Base {
     return true;
   }
   void set_playout(bool playout) { playout_ = playout; }
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time) {
+  virtual void OnPacketReceived(talk_base::Buffer* packet) {
     rtp_packets_.push_back(std::string(packet->data(), packet->length()));
   }
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) {
+  virtual void OnRtcpReceived(talk_base::Buffer* packet) {
     rtcp_packets_.push_back(std::string(packet->data(), packet->length()));
   }
   virtual void OnReadyToSend(bool ready) {
@@ -778,8 +776,6 @@ class FakeVoiceEngine : public FakeBaseEngine {
 
   bool SetLocalMonitor(bool enable) { return true; }
 
-  bool StartAecDump(FILE* file) { return false; }
-
   bool RegisterProcessor(uint32 ssrc, VoiceProcessor* voice_processor,
                          MediaProcessorDirection direction) {
     if (direction == MPD_RX) {
diff --git a/talk/media/base/fakenetworkinterface.h b/talk/media/base/fakenetworkinterface.h
index eb0175b7f..37679eb60 100644
--- a/talk/media/base/fakenetworkinterface.h
+++ b/talk/media/base/fakenetworkinterface.h
@@ -201,11 +201,9 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
             msg->pdata);
     if (dest_) {
       if (msg->message_id == ST_RTP) {
-        dest_->OnPacketReceived(&msg_data->data(),
-                                talk_base::CreatePacketTime(0));
+        dest_->OnPacketReceived(&msg_data->data());
       } else {
-        dest_->OnRtcpReceived(&msg_data->data(),
-                              talk_base::CreatePacketTime(0));
+        dest_->OnRtcpReceived(&msg_data->data());
       }
     }
     delete msg_data;
diff --git a/talk/media/base/filemediaengine.cc b/talk/media/base/filemediaengine.cc
index dfec607d2..80e9729e6 100644
--- a/talk/media/base/filemediaengine.cc
+++ b/talk/media/base/filemediaengine.cc
@@ -315,8 +315,7 @@ bool FileVoiceChannel::RemoveSendStream(uint32 ssrc) {
   return true;
 }
 
-void FileVoiceChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+void FileVoiceChannel::OnPacketReceived(talk_base::Buffer* packet) {
   rtp_sender_receiver_->OnPacketReceived(packet);
 }
 
@@ -361,8 +360,7 @@ bool FileVideoChannel::RemoveSendStream(uint32 ssrc) {
   return true;
 }
 
-void FileVideoChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+void FileVideoChannel::OnPacketReceived(talk_base::Buffer* packet) {
   rtp_sender_receiver_->OnPacketReceived(packet);
 }
 
diff --git a/talk/media/base/filemediaengine.h b/talk/media/base/filemediaengine.h
index 843806b76..129af9cc4 100644
--- a/talk/media/base/filemediaengine.h
+++ b/talk/media/base/filemediaengine.h
@@ -133,7 +133,6 @@ class FileMediaEngine : public MediaEngineInterface {
   virtual bool FindVideoCodec(const VideoCodec& codec) { return true; }
   virtual void SetVoiceLogging(int min_sev, const char* filter) {}
   virtual void SetVideoLogging(int min_sev, const char* filter) {}
-  virtual bool StartAecDump(FILE* file) { return false; }
 
   virtual bool RegisterVideoProcessor(VideoProcessor* processor) {
     return true;
@@ -233,10 +232,8 @@ class FileVoiceChannel : public VoiceMediaChannel {
   virtual bool GetStats(VoiceMediaInfo* info) { return true; }
 
   // Implement pure virtual methods of MediaChannel.
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) {}
+  virtual void OnPacketReceived(talk_base::Buffer* packet);
+  virtual void OnRtcpReceived(talk_base::Buffer* packet) {}
   virtual void OnReadyToSend(bool ready) {}
   virtual bool AddSendStream(const StreamParams& sp);
   virtual bool RemoveSendStream(uint32 ssrc);
@@ -301,10 +298,8 @@ class FileVideoChannel : public VideoMediaChannel {
   virtual bool RequestIntraFrame() { return false; }
 
   // Implement pure virtual methods of MediaChannel.
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) {}
+  virtual void OnPacketReceived(talk_base::Buffer* packet);
+  virtual void OnRtcpReceived(talk_base::Buffer* packet) {}
   virtual void OnReadyToSend(bool ready) {}
   virtual bool AddSendStream(const StreamParams& sp);
   virtual bool RemoveSendStream(uint32 ssrc);
diff --git a/talk/media/base/filemediaengine_unittest.cc b/talk/media/base/filemediaengine_unittest.cc
index b1b021d09..7ba96a25d 100644
--- a/talk/media/base/filemediaengine_unittest.cc
+++ b/talk/media/base/filemediaengine_unittest.cc
@@ -63,7 +63,7 @@ class FileNetworkInterface : public MediaChannel::NetworkInterface {
     if (!packet) return false;
 
     if (media_channel_) {
-      media_channel_->OnPacketReceived(packet, talk_base::PacketTime());
+      media_channel_->OnPacketReceived(packet);
     }
     if (dump_writer_.get() &&
         talk_base::SR_SUCCESS != dump_writer_->WriteRtpPacket(
diff --git a/talk/media/base/hybridvideoengine.cc b/talk/media/base/hybridvideoengine.cc
index 6863311f2..a405f8d28 100644
--- a/talk/media/base/hybridvideoengine.cc
+++ b/talk/media/base/hybridvideoengine.cc
@@ -276,21 +276,19 @@ bool HybridVideoMediaChannel::GetStats(VideoMediaInfo* info) {
       active_channel_->GetStats(info);
 }
 
-void HybridVideoMediaChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+void HybridVideoMediaChannel::OnPacketReceived(talk_base::Buffer* packet) {
   // Eat packets until we have an active channel;
   if (active_channel_) {
-    active_channel_->OnPacketReceived(packet, packet_time);
+    active_channel_->OnPacketReceived(packet);
   } else {
     LOG(LS_INFO) << "HybridVideoChannel: Eating early RTP packet";
   }
 }
 
-void HybridVideoMediaChannel::OnRtcpReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+void HybridVideoMediaChannel::OnRtcpReceived(talk_base::Buffer* packet) {
   // Eat packets until we have an active channel;
   if (active_channel_) {
-    active_channel_->OnRtcpReceived(packet, packet_time);
+    active_channel_->OnRtcpReceived(packet);
   } else {
     LOG(LS_INFO) << "HybridVideoChannel: Eating early RTCP packet";
   }
diff --git a/talk/media/base/hybridvideoengine.h b/talk/media/base/hybridvideoengine.h
index a49a1aa2c..ab62cc7e8 100644
--- a/talk/media/base/hybridvideoengine.h
+++ b/talk/media/base/hybridvideoengine.h
@@ -87,10 +87,8 @@ class HybridVideoMediaChannel : public VideoMediaChannel {
 
   virtual bool GetStats(VideoMediaInfo* info);
 
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time);
+  virtual void OnPacketReceived(talk_base::Buffer* packet);
+  virtual void OnRtcpReceived(talk_base::Buffer* packet);
   virtual void OnReadyToSend(bool ready);
 
   virtual void UpdateAspectRatio(int ratio_w, int ratio_h);
diff --git a/talk/media/base/mediachannel.h b/talk/media/base/mediachannel.h
index 94ae03f8d..9e1ea9db8 100644
--- a/talk/media/base/mediachannel.h
+++ b/talk/media/base/mediachannel.h
@@ -509,11 +509,9 @@ class MediaChannel : public sigslot::has_slots<> {
   }
 
   // Called when a RTP packet is received.
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time) = 0;
+  virtual void OnPacketReceived(talk_base::Buffer* packet) = 0;
   // Called when a RTCP packet is received.
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) = 0;
+  virtual void OnRtcpReceived(talk_base::Buffer* packet) = 0;
   // Called when the socket's ability to send has changed.
   virtual void OnReadyToSend(bool ready) = 0;
   // Creates a new outgoing media stream with SSRCs and CNAME as described
@@ -1133,15 +1131,25 @@ class DataMediaChannel : public MediaChannel {
 
   virtual ~DataMediaChannel() {}
 
+  virtual bool SetSendBandwidth(bool autobw, int bps) = 0;
   virtual bool SetSendCodecs(const std::vector<DataCodec>& codecs) = 0;
   virtual bool SetRecvCodecs(const std::vector<DataCodec>& codecs) = 0;
-
+  virtual bool SetRecvRtpHeaderExtensions(
+      const std::vector<RtpHeaderExtension>& extensions) = 0;
+  virtual bool SetSendRtpHeaderExtensions(
+      const std::vector<RtpHeaderExtension>& extensions) = 0;
+  virtual bool AddSendStream(const StreamParams& sp) = 0;
+  virtual bool RemoveSendStream(uint32 ssrc) = 0;
+  virtual bool AddRecvStream(const StreamParams& sp) = 0;
+  virtual bool RemoveRecvStream(uint32 ssrc) = 0;
   virtual bool MuteStream(uint32 ssrc, bool on) { return false; }
   // TODO(pthatcher): Implement this.
   virtual bool GetStats(DataMediaInfo* info) { return true; }
 
   virtual bool SetSend(bool send) = 0;
   virtual bool SetReceive(bool receive) = 0;
+  virtual void OnPacketReceived(talk_base::Buffer* packet) = 0;
+  virtual void OnRtcpReceived(talk_base::Buffer* packet) = 0;
 
   virtual bool SendData(
       const SendDataParams& params,
diff --git a/talk/media/base/mediaengine.h b/talk/media/base/mediaengine.h
index c04df9f8c..f9165728d 100644
--- a/talk/media/base/mediaengine.h
+++ b/talk/media/base/mediaengine.h
@@ -135,9 +135,6 @@ class MediaEngineInterface {
   virtual void SetVoiceLogging(int min_sev, const char* filter) = 0;
   virtual void SetVideoLogging(int min_sev, const char* filter) = 0;
 
-  // Starts AEC dump using existing file.
-  virtual bool StartAecDump(FILE* file) = 0;
-
   // Voice processors for effects.
   virtual bool RegisterVoiceProcessor(uint32 ssrc,
                                       VoiceProcessor* video_processor,
@@ -256,10 +253,6 @@ class CompositeMediaEngine : public MediaEngineInterface {
     video_.SetLogging(min_sev, filter);
   }
 
-  virtual bool StartAecDump(FILE* file) {
-    return voice_.StartAecDump(file);
-  }
-
   virtual bool RegisterVoiceProcessor(uint32 ssrc,
                                       VoiceProcessor* processor,
                                       MediaProcessorDirection direction) {
diff --git a/talk/media/base/rtpdataengine.cc b/talk/media/base/rtpdataengine.cc
index 0f84c836f..3a9228ad9 100644
--- a/talk/media/base/rtpdataengine.cc
+++ b/talk/media/base/rtpdataengine.cc
@@ -230,8 +230,7 @@ bool RtpDataMediaChannel::RemoveRecvStream(uint32 ssrc) {
   return true;
 }
 
-void RtpDataMediaChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+void RtpDataMediaChannel::OnPacketReceived(talk_base::Buffer* packet) {
   RtpHeader header;
   if (!GetRtpHeader(packet->data(), packet->length(), &header)) {
     // Don't want to log for every corrupt packet.
diff --git a/talk/media/base/rtpdataengine.h b/talk/media/base/rtpdataengine.h
index 59e658953..bc7b667ea 100644
--- a/talk/media/base/rtpdataengine.h
+++ b/talk/media/base/rtpdataengine.h
@@ -115,10 +115,8 @@ class RtpDataMediaChannel : public DataMediaChannel {
     receiving_ = receive;
     return true;
   }
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) {}
+  virtual void OnPacketReceived(talk_base::Buffer* packet);
+  virtual void OnRtcpReceived(talk_base::Buffer* packet) {}
   virtual void OnReadyToSend(bool ready) {}
   virtual bool SendData(
     const SendDataParams& params,
diff --git a/talk/media/base/rtpdataengine_unittest.cc b/talk/media/base/rtpdataengine_unittest.cc
index a86ab3b31..bc4681897 100644
--- a/talk/media/base/rtpdataengine_unittest.cc
+++ b/talk/media/base/rtpdataengine_unittest.cc
@@ -423,13 +423,13 @@ TEST_F(RtpDataMediaChannelTest, ReceiveData) {
   talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   // SetReceived not called.
-  dmc->OnPacketReceived(&packet, talk_base::PacketTime());
+  dmc->OnPacketReceived(&packet);
   EXPECT_FALSE(HasReceivedData());
 
   dmc->SetReceive(true);
 
   // Unknown payload id
-  dmc->OnPacketReceived(&packet, talk_base::PacketTime());
+  dmc->OnPacketReceived(&packet);
   EXPECT_FALSE(HasReceivedData());
 
   cricket::DataCodec codec;
@@ -440,7 +440,7 @@ TEST_F(RtpDataMediaChannelTest, ReceiveData) {
   ASSERT_TRUE(dmc->SetRecvCodecs(codecs));
 
   // Unknown stream
-  dmc->OnPacketReceived(&packet, talk_base::PacketTime());
+  dmc->OnPacketReceived(&packet);
   EXPECT_FALSE(HasReceivedData());
 
   cricket::StreamParams stream;
@@ -448,7 +448,7 @@ TEST_F(RtpDataMediaChannelTest, ReceiveData) {
   ASSERT_TRUE(dmc->AddRecvStream(stream));
 
   // Finally works!
-  dmc->OnPacketReceived(&packet, talk_base::PacketTime());
+  dmc->OnPacketReceived(&packet);
   EXPECT_TRUE(HasReceivedData());
   EXPECT_EQ("abcde", GetReceivedData());
   EXPECT_EQ(5U, GetReceivedDataLen());
@@ -463,6 +463,6 @@ TEST_F(RtpDataMediaChannelTest, InvalidRtpPackets) {
   talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   // Too short
-  dmc->OnPacketReceived(&packet, talk_base::PacketTime());
+  dmc->OnPacketReceived(&packet);
   EXPECT_FALSE(HasReceivedData());
 }
diff --git a/talk/media/base/videoengine_unittest.h b/talk/media/base/videoengine_unittest.h
index d9266f2c4..95d8f6c98 100644
--- a/talk/media/base/videoengine_unittest.h
+++ b/talk/media/base/videoengine_unittest.h
@@ -981,7 +981,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
-    channel_->OnPacketReceived(&packet1, talk_base::PacketTime());
+    channel_->OnPacketReceived(&packet1);
     SetRendererAsDefault();
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
diff --git a/talk/media/sctp/sctpdataengine.cc b/talk/media/sctp/sctpdataengine.cc
index 653273bd2..2b86001f1 100644
--- a/talk/media/sctp/sctpdataengine.cc
+++ b/talk/media/sctp/sctpdataengine.cc
@@ -542,8 +542,7 @@ bool SctpDataMediaChannel::SendData(
 }
 
 // Called by network interface when a packet has been received.
-void SctpDataMediaChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+void SctpDataMediaChannel::OnPacketReceived(talk_base::Buffer* packet) {
   LOG(LS_VERBOSE) << debug_name_ << "->OnPacketReceived(...): " << " length="
                   << packet->length() << ", sending: " << sending_;
   // Only give receiving packets to usrsctp after if connected. This enables two
diff --git a/talk/media/sctp/sctpdataengine.h b/talk/media/sctp/sctpdataengine.h
index 4d05cf36e..d09b152b4 100644
--- a/talk/media/sctp/sctpdataengine.h
+++ b/talk/media/sctp/sctpdataengine.h
@@ -149,8 +149,7 @@ class SctpDataMediaChannel : public DataMediaChannel,
                         const talk_base::Buffer& payload,
                         SendDataResult* result = NULL);
   // A packet is received from the network interface. Posted to OnMessage.
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
+  virtual void OnPacketReceived(talk_base::Buffer* packet);
 
   // Exposed to allow Post call from c-callbacks.
   talk_base::Thread* worker_thread() const { return worker_thread_; }
@@ -171,8 +170,7 @@ class SctpDataMediaChannel : public DataMediaChannel,
       const std::vector<RtpHeaderExtension>& extensions) { return true; }
   virtual bool SetSendCodecs(const std::vector<DataCodec>& codecs);
   virtual bool SetRecvCodecs(const std::vector<DataCodec>& codecs);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) {}
+  virtual void OnRtcpReceived(talk_base::Buffer* packet) {}
   virtual void OnReadyToSend(bool ready) {}
 
   // Helper for debugging.
diff --git a/talk/media/sctp/sctpdataengine_unittest.cc b/talk/media/sctp/sctpdataengine_unittest.cc
index b4ad6ce33..cab60b03f 100644
--- a/talk/media/sctp/sctpdataengine_unittest.cc
+++ b/talk/media/sctp/sctpdataengine_unittest.cc
@@ -84,7 +84,7 @@ class SctpFakeNetworkInterface : public cricket::MediaChannel::NetworkInterface,
         static_cast<talk_base::TypedMessageData<talk_base::Buffer*>*>(
             msg->pdata)->data();
     if (dest_) {
-      dest_->OnPacketReceived(buffer, talk_base::PacketTime());
+      dest_->OnPacketReceived(buffer);
     }
     delete buffer;
   }
diff --git a/talk/media/webrtc/fakewebrtcvideoengine.h b/talk/media/webrtc/fakewebrtcvideoengine.h
index 070c7317e..850451b29 100644
--- a/talk/media/webrtc/fakewebrtcvideoengine.h
+++ b/talk/media/webrtc/fakewebrtcvideoengine.h
@@ -339,12 +339,14 @@ class FakeWebRtcVideoEngine
   };
   class Capturer : public webrtc::ViEExternalCapture {
    public:
-    Capturer() : channel_id_(-1), denoising_(false), last_capture_time_(0) { }
+    Capturer() : channel_id_(-1), denoising_(false),
+                 last_capture_time_(0), incoming_frame_num_(0) { }
     int channel_id() const { return channel_id_; }
     void set_channel_id(int channel_id) { channel_id_ = channel_id; }
     bool denoising() const { return denoising_; }
     void set_denoising(bool denoising) { denoising_ = denoising; }
-    int64 last_capture_time() { return last_capture_time_; }
+    int64 last_capture_time() const { return last_capture_time_; }
+    int incoming_frame_num() const { return incoming_frame_num_; }
 
     // From ViEExternalCapture
     virtual int IncomingFrame(unsigned char* videoFrame,
@@ -359,6 +361,7 @@ class FakeWebRtcVideoEngine
         const webrtc::ViEVideoFrameI420& video_frame,
         unsigned long long captureTime) {
       last_capture_time_ = captureTime;
+      ++incoming_frame_num_;
       return 0;
     }
 
@@ -366,6 +369,7 @@ class FakeWebRtcVideoEngine
     int channel_id_;
     bool denoising_;
     int64 last_capture_time_;
+    int incoming_frame_num_;
   };
 
   FakeWebRtcVideoEngine(const cricket::VideoCodec* const* codecs,
@@ -408,6 +412,16 @@ class FakeWebRtcVideoEngine
 
   int GetLastCapturer() const { return last_capturer_; }
   int GetNumCapturers() const { return static_cast<int>(capturers_.size()); }
+  int GetIncomingFrameNum(int channel_id) const {
+    for (std::map<int, Capturer*>::const_iterator iter = capturers_.begin();
+         iter != capturers_.end(); ++iter) {
+      Capturer* capturer = iter->second;
+      if (capturer->channel_id() == channel_id) {
+        return capturer->incoming_frame_num();
+      }
+    }
+    return -1;
+  }
   void set_fail_alloc_capturer(bool fail_alloc_capturer) {
     fail_alloc_capturer_ = fail_alloc_capturer;
   }
@@ -813,12 +827,7 @@ class FakeWebRtcVideoEngine
   }
   WEBRTC_STUB(RegisterSendTransport, (const int, webrtc::Transport&));
   WEBRTC_STUB(DeregisterSendTransport, (const int));
-#ifdef USE_WEBRTC_DEV_BRANCH
-  WEBRTC_STUB(ReceivedRTPPacket, (const int, const void*, const int,
-      const webrtc::PacketTime&));
-#else
   WEBRTC_STUB(ReceivedRTPPacket, (const int, const void*, const int));
-#endif
   WEBRTC_STUB(ReceivedRTCPPacket, (const int, const void*, const int));
   // Not using WEBRTC_STUB due to bool return value
   virtual bool IsIPv6Enabled(int channel) { return true; }
diff --git a/talk/media/webrtc/webrtcvideoengine.cc b/talk/media/webrtc/webrtcvideoengine.cc
index 1c1ccc38f..d6fabdb26 100644
--- a/talk/media/webrtc/webrtcvideoengine.cc
+++ b/talk/media/webrtc/webrtcvideoengine.cc
@@ -2118,18 +2118,6 @@ bool WebRtcVideoMediaChannel::GetSendChannelKey(uint32 local_ssrc,
   return true;
 }
 
-WebRtcVideoChannelSendInfo* WebRtcVideoMediaChannel::GetSendChannel(
-    VideoCapturer* video_capturer) {
-  for (SendChannelMap::iterator iter = send_channels_.begin();
-       iter != send_channels_.end(); ++iter) {
-    WebRtcVideoChannelSendInfo* send_channel = iter->second;
-    if (send_channel->video_capturer() == video_capturer) {
-      return send_channel;
-    }
-  }
-  return NULL;
-}
-
 WebRtcVideoChannelSendInfo* WebRtcVideoMediaChannel::GetSendChannel(
     uint32 local_ssrc) {
   uint32 key;
@@ -2492,8 +2480,7 @@ bool WebRtcVideoMediaChannel::RequestIntraFrame() {
   return false;
 }
 
-void WebRtcVideoMediaChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+void WebRtcVideoMediaChannel::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.
@@ -2508,16 +2495,10 @@ void WebRtcVideoMediaChannel::OnPacketReceived(
   engine()->vie()->network()->ReceivedRTPPacket(
       which_channel,
       packet->data(),
-#ifdef USE_WEBRTC_DEV_BRANCH
-      static_cast<int>(packet->length()),
-      webrtc::PacketTime(packet_time.timestamp, packet_time.not_before));
-#else
       static_cast<int>(packet->length()));
-#endif
 }
 
-void WebRtcVideoMediaChannel::OnRtcpReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+void WebRtcVideoMediaChannel::OnRtcpReceived(talk_base::Buffer* packet) {
 // Sending channels need all RTCP packets with feedback information.
 // Even sender reports can contain attached report blocks.
 // Receiving channels need sender reports in order to create
@@ -2865,20 +2846,23 @@ bool WebRtcVideoMediaChannel::GetRenderer(uint32 ssrc,
   return true;
 }
 
-// TODO(zhurunz): Add unittests to test this function.
-// TODO(thorcarpenter): This is broken. One capturer registered on two ssrc
-// will not send any video to the second ssrc send channel. We should remove
-// GetSendChannel(capturer) and pass in an ssrc here.
 void WebRtcVideoMediaChannel::SendFrame(VideoCapturer* capturer,
                                         const VideoFrame* frame) {
-  // If there's send channel registers to the |capturer|, then only send the
-  // frame to that channel and return. Otherwise send the frame to the default
-  // channel, which currently taking frames from the engine.
-  WebRtcVideoChannelSendInfo* send_channel = GetSendChannel(capturer);
-  if (send_channel) {
-    SendFrame(send_channel, frame, capturer->IsScreencast());
+  // If the |capturer| is registered to any send channel, then send the frame
+  // to those send channels.
+  bool capturer_is_channel_owned = false;
+  for (SendChannelMap::iterator iter = send_channels_.begin();
+       iter != send_channels_.end(); ++iter) {
+    WebRtcVideoChannelSendInfo* send_channel = iter->second;
+    if (send_channel->video_capturer() == capturer) {
+      SendFrame(send_channel, frame, capturer->IsScreencast());
+      capturer_is_channel_owned = true;
+    }
+  }
+  if (capturer_is_channel_owned) {
     return;
   }
+
   // TODO(hellner): Remove below for loop once the captured frame no longer
   // come from the engine, i.e. the engine no longer owns a capturer.
   for (SendChannelMap::iterator iter = send_channels_.begin();
diff --git a/talk/media/webrtc/webrtcvideoengine.h b/talk/media/webrtc/webrtcvideoengine.h
index 627846178..d5f0e57b2 100644
--- a/talk/media/webrtc/webrtcvideoengine.h
+++ b/talk/media/webrtc/webrtcvideoengine.h
@@ -266,10 +266,8 @@ class WebRtcVideoMediaChannel : public talk_base::MessageHandler,
   virtual bool SendIntraFrame();
   virtual bool RequestIntraFrame();
 
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time);
+  virtual void OnPacketReceived(talk_base::Buffer* packet);
+  virtual void OnRtcpReceived(talk_base::Buffer* packet);
   virtual void OnReadyToSend(bool ready);
   virtual bool MuteStream(uint32 ssrc, bool on);
   virtual bool SetRecvRtpHeaderExtensions(
@@ -366,7 +364,6 @@ class WebRtcVideoMediaChannel : public talk_base::MessageHandler,
   // If the local ssrc correspond to that of the default channel the key is 0.
   // For all other channels the returned key will be the same as the local ssrc.
   bool GetSendChannelKey(uint32 local_ssrc, uint32* key);
-  WebRtcVideoChannelSendInfo* GetSendChannel(VideoCapturer* video_capturer);
   WebRtcVideoChannelSendInfo* GetSendChannel(uint32 local_ssrc);
   // Creates a new unique key that can be used for inserting a new send channel
   // into |send_channels_|
diff --git a/talk/media/webrtc/webrtcvideoengine_unittest.cc b/talk/media/webrtc/webrtcvideoengine_unittest.cc
index 2b83cceea..93ca9adc5 100644
--- a/talk/media/webrtc/webrtcvideoengine_unittest.cc
+++ b/talk/media/webrtc/webrtcvideoengine_unittest.cc
@@ -1216,6 +1216,41 @@ TEST_F(WebRtcVideoEngineTestFake, SetOptionsWithDenoising) {
   EXPECT_FALSE(vie_.GetCaptureDenoising(capture_id));
 }
 
+TEST_F(WebRtcVideoEngineTestFake, MultipleSendStreamsWithOneCapturer) {
+  EXPECT_TRUE(SetupEngine());
+  cricket::FakeVideoCapturer capturer;
+  for (unsigned int i = 0; i < sizeof(kSsrcs2)/sizeof(kSsrcs2[0]); ++i) {
+    EXPECT_TRUE(channel_->AddSendStream(
+        cricket::StreamParams::CreateLegacy(kSsrcs2[i])));
+    // Register the capturer to the ssrc.
+    EXPECT_TRUE(channel_->SetCapturer(kSsrcs2[i], &capturer));
+  }
+
+  const int channel0 = vie_.GetChannelFromLocalSsrc(kSsrcs2[0]);
+  ASSERT_NE(-1, channel0);
+  const int channel1 = vie_.GetChannelFromLocalSsrc(kSsrcs2[1]);
+  ASSERT_NE(-1, channel1);
+  ASSERT_NE(channel0, channel1);
+
+  std::vector<cricket::VideoCodec> codecs;
+  codecs.push_back(kVP8Codec);
+  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+
+  cricket::WebRtcVideoFrame frame;
+  const size_t pixel_width = 1;
+  const size_t pixel_height = 1;
+  const int64 elapsed_time = 0;
+  const int64 time_stamp = 0;
+  EXPECT_TRUE(frame.InitToBlack(kVP8Codec.width, kVP8Codec.height,
+                                pixel_width, pixel_height,
+                                elapsed_time, time_stamp));
+  channel_->SendFrame(&capturer, &frame);
+
+  // Both channels should have received the frame.
+  EXPECT_EQ(1, vie_.GetIncomingFrameNum(channel0));
+  EXPECT_EQ(1, vie_.GetIncomingFrameNum(channel1));
+}
+
 
 // Disabled since its flaky: b/11288120
 TEST_F(WebRtcVideoEngineTestFake, DISABLED_SendReceiveBitratesStats) {
diff --git a/talk/media/webrtc/webrtcvoiceengine.cc b/talk/media/webrtc/webrtcvoiceengine.cc
index 2aa6b8ce9..745a1e072 100644
--- a/talk/media/webrtc/webrtcvoiceengine.cc
+++ b/talk/media/webrtc/webrtcvoiceengine.cc
@@ -1433,22 +1433,6 @@ bool WebRtcVoiceEngine::SetAudioDeviceModule(webrtc::AudioDeviceModule* adm,
   return true;
 }
 
-bool WebRtcVoiceEngine::StartAecDump(FILE* file) {
-#ifdef USE_WEBRTC_DEV_BRANCH
-  StopAecDump();
-  if (voe_wrapper_->processing()->StartDebugRecording(file) !=
-      webrtc::AudioProcessing::kNoError) {
-    LOG_RTCERR1(StartDebugRecording, "FILE*");
-    fclose(file);
-    return false;
-  }
-  is_dumping_aec_ = true;
-  return true;
-#else
-  return false;
-#endif
-}
-
 bool WebRtcVoiceEngine::RegisterProcessor(
     uint32 ssrc,
     VoiceProcessor* voice_processor,
@@ -1606,7 +1590,7 @@ void WebRtcVoiceEngine::StartAecDump(const std::string& filename) {
     // Start dumping AEC when we are not dumping.
     if (voe_wrapper_->processing()->StartDebugRecording(
         filename.c_str()) != webrtc::AudioProcessing::kNoError) {
-      LOG_RTCERR1(StartDebugRecording, filename.c_str());
+      LOG_RTCERR0(StartDebugRecording);
     } else {
       is_dumping_aec_ = true;
     }
@@ -2837,8 +2821,7 @@ bool WebRtcVoiceMediaChannel::InsertDtmf(uint32 ssrc, int event,
   return true;
 }
 
-void WebRtcVoiceMediaChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+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.
@@ -2871,8 +2854,7 @@ void WebRtcVoiceMediaChannel::OnPacketReceived(
       static_cast<unsigned int>(packet->length()));
 }
 
-void WebRtcVoiceMediaChannel::OnRtcpReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+void WebRtcVoiceMediaChannel::OnRtcpReceived(talk_base::Buffer* packet) {
   // Sending channels need all RTCP packets with feedback information.
   // Even sender reports can contain attached report blocks.
   // Receiving channels need sender reports in order to create
diff --git a/talk/media/webrtc/webrtcvoiceengine.h b/talk/media/webrtc/webrtcvoiceengine.h
index adf485366..29807ef30 100644
--- a/talk/media/webrtc/webrtcvoiceengine.h
+++ b/talk/media/webrtc/webrtcvoiceengine.h
@@ -174,9 +174,6 @@ class WebRtcVoiceEngine
   bool SetAudioDeviceModule(webrtc::AudioDeviceModule* adm,
                             webrtc::AudioDeviceModule* adm_sc);
 
-  // Starts AEC dump using existing file.
-  bool StartAecDump(FILE* file);
-
   // Check whether the supplied trace should be ignored.
   bool ShouldIgnoreTrace(const std::string& trace);
 
@@ -359,10 +356,8 @@ class WebRtcVoiceMediaChannel
   virtual bool CanInsertDtmf();
   virtual bool InsertDtmf(uint32 ssrc, int event, int duration, int flags);
 
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time);
+  virtual void OnPacketReceived(talk_base::Buffer* packet);
+  virtual void OnRtcpReceived(talk_base::Buffer* packet);
   virtual void OnReadyToSend(bool ready) {}
   virtual bool MuteStream(uint32 ssrc, bool on);
   virtual bool SetSendBandwidth(bool autobw, int bps);
diff --git a/talk/media/webrtc/webrtcvoiceengine_unittest.cc b/talk/media/webrtc/webrtcvoiceengine_unittest.cc
index 9bb681a89..4c3ba2ae1 100644
--- a/talk/media/webrtc/webrtcvoiceengine_unittest.cc
+++ b/talk/media/webrtc/webrtcvoiceengine_unittest.cc
@@ -139,7 +139,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
   }
   void DeliverPacket(const void* data, int len) {
     talk_base::Buffer packet(data, len);
-    channel_->OnPacketReceived(&packet, talk_base::PacketTime());
+    channel_->OnPacketReceived(&packet);
   }
   virtual void TearDown() {
     delete soundclip_;
diff --git a/talk/p2p/base/asyncstuntcpsocket.cc b/talk/p2p/base/asyncstuntcpsocket.cc
index 67178f498..ec00c0482 100644
--- a/talk/p2p/base/asyncstuntcpsocket.cc
+++ b/talk/p2p/base/asyncstuntcpsocket.cc
@@ -126,8 +126,7 @@ void AsyncStunTCPSocket::ProcessInput(char* data, size_t* len) {
       return;
     }
 
-    SignalReadPacket(this, data, expected_pkt_len, remote_addr,
-                     talk_base::CreatePacketTime(0));
+    SignalReadPacket(this, data, expected_pkt_len, remote_addr);
 
     *len -= actual_length;
     if (*len > 0) {
diff --git a/talk/p2p/base/asyncstuntcpsocket_unittest.cc b/talk/p2p/base/asyncstuntcpsocket_unittest.cc
index c6a7b1b6f..7cb380b0a 100644
--- a/talk/p2p/base/asyncstuntcpsocket_unittest.cc
+++ b/talk/p2p/base/asyncstuntcpsocket_unittest.cc
@@ -109,8 +109,7 @@ class AsyncStunTCPSocketTest : public testing::Test,
   }
 
   void OnReadPacket(talk_base::AsyncPacketSocket* socket, const char* data,
-                    size_t len, const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time) {
+                    size_t len, const talk_base::SocketAddress& remote_addr) {
     recv_packets_.push_back(std::string(data, len));
   }
 
diff --git a/talk/p2p/base/dtlstransportchannel.cc b/talk/p2p/base/dtlstransportchannel.cc
index 472299959..7412e5e45 100644
--- a/talk/p2p/base/dtlstransportchannel.cc
+++ b/talk/p2p/base/dtlstransportchannel.cc
@@ -446,9 +446,9 @@ void DtlsTransportChannelWrapper::OnWritableState(TransportChannel* channel) {
   }
 }
 
-void DtlsTransportChannelWrapper::OnReadPacket(
-    TransportChannel* channel, const char* data, size_t size,
-    const talk_base::PacketTime& packet_time, int flags) {
+void DtlsTransportChannelWrapper::OnReadPacket(TransportChannel* channel,
+                                               const char* data, size_t size,
+                                               int flags) {
   ASSERT(talk_base::Thread::Current() == worker_thread_);
   ASSERT(channel == channel_);
   ASSERT(flags == 0);
@@ -456,7 +456,7 @@ void DtlsTransportChannelWrapper::OnReadPacket(
   switch (dtls_state_) {
     case STATE_NONE:
       // We are not doing DTLS
-      SignalReadPacket(this, data, size, packet_time, 0);
+      SignalReadPacket(this, data, size, 0);
       break;
 
     case STATE_OFFERED:
@@ -500,7 +500,7 @@ void DtlsTransportChannelWrapper::OnReadPacket(
         ASSERT(!srtp_ciphers_.empty());
 
         // Signal this upwards as a bypass packet.
-        SignalReadPacket(this, data, size, packet_time, PF_SRTP_BYPASS);
+        SignalReadPacket(this, data, size, PF_SRTP_BYPASS);
       }
       break;
     case STATE_CLOSED:
@@ -535,7 +535,7 @@ void DtlsTransportChannelWrapper::OnDtlsEvent(talk_base::StreamInterface* dtls,
     char buf[kMaxDtlsPacketLen];
     size_t read;
     if (dtls_->Read(buf, sizeof(buf), &read, NULL) == talk_base::SR_SUCCESS) {
-      SignalReadPacket(this, buf, read, talk_base::CreatePacketTime(0), 0);
+      SignalReadPacket(this, buf, read, 0);
     }
   }
   if (sig & talk_base::SE_CLOSE) {
diff --git a/talk/p2p/base/dtlstransportchannel.h b/talk/p2p/base/dtlstransportchannel.h
index d6b734674..29d97a297 100644
--- a/talk/p2p/base/dtlstransportchannel.h
+++ b/talk/p2p/base/dtlstransportchannel.h
@@ -225,7 +225,7 @@ class DtlsTransportChannelWrapper : public TransportChannelImpl {
   void OnReadableState(TransportChannel* channel);
   void OnWritableState(TransportChannel* channel);
   void OnReadPacket(TransportChannel* channel, const char* data, size_t size,
-                    const talk_base::PacketTime& packet_time, int flags);
+                    int flags);
   void OnReadyToSend(TransportChannel* channel);
   void OnDtlsEvent(talk_base::StreamInterface* stream_, int sig, int err);
   bool SetupDtls();
diff --git a/talk/p2p/base/dtlstransportchannel_unittest.cc b/talk/p2p/base/dtlstransportchannel_unittest.cc
index 1fd82d710..c6e2804ae 100644
--- a/talk/p2p/base/dtlstransportchannel_unittest.cc
+++ b/talk/p2p/base/dtlstransportchannel_unittest.cc
@@ -307,7 +307,6 @@ class DtlsTestClient : public sigslot::has_slots<> {
 
   void OnTransportChannelReadPacket(cricket::TransportChannel* channel,
                                     const char* data, size_t size,
-                                    const talk_base::PacketTime& packet_time,
                                     int flags) {
     uint32 packet_num = 0;
     ASSERT_TRUE(VerifyPacket(data, size, &packet_num));
@@ -321,7 +320,6 @@ class DtlsTestClient : public sigslot::has_slots<> {
   // Hook into the raw packet stream to make sure DTLS packets are encrypted.
   void OnFakeTransportChannelReadPacket(cricket::TransportChannel* channel,
                                         const char* data, size_t size,
-                                        const talk_base::PacketTime& time,
                                         int flags) {
     // Flags shouldn't be set on the underlying TransportChannel packets.
     ASSERT_EQ(0, flags);
diff --git a/talk/p2p/base/fakesession.h b/talk/p2p/base/fakesession.h
index 2615f50df..6a8ab4bde 100644
--- a/talk/p2p/base/fakesession.h
+++ b/talk/p2p/base/fakesession.h
@@ -204,8 +204,7 @@ class FakeTransportChannel : public TransportChannelImpl,
     PacketMessageData* data = static_cast<PacketMessageData*>(
         msg->pdata);
     dest_->SignalReadPacket(dest_, data->packet.data(),
-                            data->packet.length(),
-                            talk_base::CreatePacketTime(0), 0);
+                            data->packet.length(), 0);
     delete data;
   }
 
diff --git a/talk/p2p/base/p2ptransportchannel.cc b/talk/p2p/base/p2ptransportchannel.cc
index 38cc35445..e8f53ada5 100644
--- a/talk/p2p/base/p2ptransportchannel.cc
+++ b/talk/p2p/base/p2ptransportchannel.cc
@@ -1227,9 +1227,8 @@ void P2PTransportChannel::OnPortDestroyed(PortInterface* port) {
 }
 
 // We data is available, let listeners know
-void P2PTransportChannel::OnReadPacket(
-    Connection *connection, const char *data, size_t len,
-    const talk_base::PacketTime& packet_time) {
+void P2PTransportChannel::OnReadPacket(Connection *connection, const char *data,
+                                       size_t len) {
   ASSERT(worker_thread_ == talk_base::Thread::Current());
 
   // Do not deliver, if packet doesn't belong to the correct transport channel.
@@ -1237,7 +1236,7 @@ void P2PTransportChannel::OnReadPacket(
     return;
 
   // Let the client know of an incoming packet
-  SignalReadPacket(this, data, len, packet_time, 0);
+  SignalReadPacket(this, data, len, 0);
 }
 
 void P2PTransportChannel::OnReadyToSend(Connection* connection) {
diff --git a/talk/p2p/base/p2ptransportchannel.h b/talk/p2p/base/p2ptransportchannel.h
index 6f287f369..63ec6aa28 100644
--- a/talk/p2p/base/p2ptransportchannel.h
+++ b/talk/p2p/base/p2ptransportchannel.h
@@ -40,7 +40,6 @@
 #include <map>
 #include <vector>
 #include <string>
-#include "talk/base/asyncpacketsocket.h"
 #include "talk/base/sigslot.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/portinterface.h"
@@ -208,9 +207,8 @@ class P2PTransportChannel : public TransportChannelImpl,
   void OnPortDestroyed(PortInterface* port);
   void OnRoleConflict(PortInterface* port);
 
-  void OnConnectionStateChange(Connection* connection);
-  void OnReadPacket(Connection *connection, const char *data, size_t len,
-                    const talk_base::PacketTime& packet_time);
+  void OnConnectionStateChange(Connection *connection);
+  void OnReadPacket(Connection *connection, const char *data, size_t len);
   void OnReadyToSend(Connection* connection);
   void OnConnectionDestroyed(Connection *connection);
 
diff --git a/talk/p2p/base/p2ptransportchannel_unittest.cc b/talk/p2p/base/p2ptransportchannel_unittest.cc
index 3c24ded63..07cfeaafc 100644
--- a/talk/p2p/base/p2ptransportchannel_unittest.cc
+++ b/talk/p2p/base/p2ptransportchannel_unittest.cc
@@ -613,8 +613,7 @@ class P2PTransportChannelTestBase : public testing::Test,
     rch->OnCandidate(c);
   }
   void OnReadPacket(cricket::TransportChannel* channel, const char* data,
-                    size_t len, const talk_base::PacketTime& packet_time,
-                    int flags) {
+                    size_t len, int flags) {
     std::list<std::string>& packets = GetPacketList(channel);
     packets.push_front(std::string(data, len));
   }
diff --git a/talk/p2p/base/port.cc b/talk/p2p/base/port.cc
index 24ef4271f..7d5238697 100644
--- a/talk/p2p/base/port.cc
+++ b/talk/p2p/base/port.cc
@@ -924,8 +924,7 @@ void Connection::OnSendStunPacket(const void* data, size_t size,
   }
 }
 
-void Connection::OnReadPacket(
-  const char* data, size_t size, const talk_base::PacketTime& packet_time) {
+void Connection::OnReadPacket(const char* data, size_t size) {
   talk_base::scoped_ptr<IceMessage> msg;
   std::string remote_ufrag;
   const talk_base::SocketAddress& addr(remote_candidate_.address());
@@ -939,7 +938,7 @@ void Connection::OnReadPacket(
 
       last_data_received_ = talk_base::Time();
       recv_rate_tracker_.Update(size);
-      SignalReadPacket(this, data, size, packet_time);
+      SignalReadPacket(this, data, size);
 
       // If timed out sending writability checks, start up again
       if (!pruned_ && (write_state_ == STATE_WRITE_TIMEOUT)) {
diff --git a/talk/p2p/base/port.h b/talk/p2p/base/port.h
index 9ea3f0c37..ab7fdedc0 100644
--- a/talk/p2p/base/port.h
+++ b/talk/p2p/base/port.h
@@ -32,7 +32,6 @@
 #include <vector>
 #include <map>
 
-#include "talk/base/asyncpacketsocket.h"
 #include "talk/base/network.h"
 #include "talk/base/proxyinfo.h"
 #include "talk/base/ratetracker.h"
@@ -46,6 +45,10 @@
 #include "talk/p2p/base/stunrequest.h"
 #include "talk/p2p/base/transport.h"
 
+namespace talk_base {
+class AsyncPacketSocket;
+}
+
 namespace cricket {
 
 class Connection;
@@ -237,8 +240,7 @@ class Port : public PortInterface, public talk_base::MessageHandler,
   // TODO(mallinath) - Make it pure virtual.
   virtual bool HandleIncomingPacket(
       talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-      const talk_base::SocketAddress& remote_addr,
-      const talk_base::PacketTime& packet_time) {
+      const talk_base::SocketAddress& remote_addr) {
     ASSERT(false);
     return false;
   }
@@ -468,14 +470,12 @@ class Connection : public talk_base::MessageHandler,
   // Error if Send() returns < 0
   virtual int GetError() = 0;
 
-  sigslot::signal4<Connection*, const char*, size_t,
-                   const talk_base::PacketTime&> SignalReadPacket;
+  sigslot::signal3<Connection*, const char*, size_t> SignalReadPacket;
 
   sigslot::signal1<Connection*> SignalReadyToSend;
 
   // Called when a packet is received on this connection.
-  void OnReadPacket(const char* data, size_t size,
-                    const talk_base::PacketTime& packet_time);
+  void OnReadPacket(const char* data, size_t size);
 
   // Called when the socket is currently able to send.
   void OnReadyToSend();
diff --git a/talk/p2p/base/port_unittest.cc b/talk/p2p/base/port_unittest.cc
index 1122d8aea..a5271555e 100644
--- a/talk/p2p/base/port_unittest.cc
+++ b/talk/p2p/base/port_unittest.cc
@@ -1049,8 +1049,7 @@ TEST_F(PortTest, TestLoopbackCallAsIce) {
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   conn->OnReadPacket(lport->last_stun_buf()->Data(),
-                     lport->last_stun_buf()->Length(),
-                     talk_base::PacketTime());
+                     lport->last_stun_buf()->Length());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
@@ -1083,7 +1082,7 @@ TEST_F(PortTest, TestLoopbackCallAsIce) {
   lport->Reset();
   talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
   WriteStunMessage(modified_req.get(), buf.get());
-  conn1->OnReadPacket(buf->Data(), buf->Length(), talk_base::PacketTime());
+  conn1->OnReadPacket(buf->Data(), buf->Length());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
@@ -1121,8 +1120,7 @@ TEST_F(PortTest, TestIceRoleConflict) {
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
   lconn->OnReadPacket(rport->last_stun_buf()->Data(),
-                      rport->last_stun_buf()->Length(),
-                      talk_base::PacketTime());
+                      rport->last_stun_buf()->Length());
 
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
@@ -1904,8 +1902,7 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
   lconn->OnReadPacket(rport->last_stun_buf()->Data(),
-                      rport->last_stun_buf()->Length(),
-                      talk_base::PacketTime());
+                      rport->last_stun_buf()->Length());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
   uint32 last_ping_received1 = lconn->last_ping_received();
@@ -1913,7 +1910,7 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
   // Adding a delay of 100ms.
   talk_base::Thread::Current()->ProcessMessages(100);
   // Pinging lconn using stun indication message.
-  lconn->OnReadPacket(buf->Data(), buf->Length(), talk_base::PacketTime());
+  lconn->OnReadPacket(buf->Data(), buf->Length());
   uint32 last_ping_received2 = lconn->last_ping_received();
   EXPECT_GT(last_ping_received2, last_ping_received1);
 }
@@ -2275,8 +2272,7 @@ TEST_F(PortTest, TestIceLiteConnectivity) {
 
   // Feeding the respone message from litemode to the full mode connection.
   ch1.conn()->OnReadPacket(ice_lite_port->last_stun_buf()->Data(),
-                           ice_lite_port->last_stun_buf()->Length(),
-                           talk_base::PacketTime());
+                           ice_lite_port->last_stun_buf()->Length());
   // Verifying full mode connection becomes writable from the response.
   EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                  kTimeout);
diff --git a/talk/p2p/base/rawtransportchannel.cc b/talk/p2p/base/rawtransportchannel.cc
index 2baef4245..ec225029b 100644
--- a/talk/p2p/base/rawtransportchannel.cc
+++ b/talk/p2p/base/rawtransportchannel.cc
@@ -257,7 +257,7 @@ void RawTransportChannel::OnReadPacket(
     PortInterface* port, const char* data, size_t size,
     const talk_base::SocketAddress& addr) {
   ASSERT(port_ == port);
-  SignalReadPacket(this, data, size, talk_base::CreatePacketTime(0), 0);
+  SignalReadPacket(this, data, size, 0);
 }
 
 void RawTransportChannel::OnMessage(talk_base::Message* msg) {
diff --git a/talk/p2p/base/relayport.cc b/talk/p2p/base/relayport.cc
index ddfca7114..ff8c07c55 100644
--- a/talk/p2p/base/relayport.cc
+++ b/talk/p2p/base/relayport.cc
@@ -155,11 +155,10 @@ class RelayEntry : public talk_base::MessageHandler,
   void OnSocketClose(talk_base::AsyncPacketSocket* socket, int error);
 
   // Called when a packet is received on this socket.
-  void OnReadPacket(
-    talk_base::AsyncPacketSocket* socket,
-    const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time);
+  void OnReadPacket(talk_base::AsyncPacketSocket* socket,
+                    const char* data, size_t size,
+                    const talk_base::SocketAddress& remote_addr);
+
   // Called when the socket is currently able to send.
   void OnReadyToSend(talk_base::AsyncPacketSocket* socket);
 
@@ -394,11 +393,9 @@ int RelayPort::GetError() {
 
 void RelayPort::OnReadPacket(
     const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    ProtocolType proto,
-    const talk_base::PacketTime& packet_time) {
+    const talk_base::SocketAddress& remote_addr, ProtocolType proto) {
   if (Connection* conn = GetConnection(remote_addr)) {
-    conn->OnReadPacket(data, size, packet_time);
+    conn->OnReadPacket(data, size);
   } else {
     Port::OnReadPacket(data, size, remote_addr, proto);
   }
@@ -685,11 +682,9 @@ void RelayEntry::OnSocketClose(talk_base::AsyncPacketSocket* socket,
   HandleConnectFailure(socket);
 }
 
-void RelayEntry::OnReadPacket(
-    talk_base::AsyncPacketSocket* socket,
-    const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+void RelayEntry::OnReadPacket(talk_base::AsyncPacketSocket* socket,
+                              const char* data, size_t size,
+                              const talk_base::SocketAddress& remote_addr) {
   // ASSERT(remote_addr == port_->server_addr());
   // TODO: are we worried about this?
 
@@ -703,7 +698,7 @@ void RelayEntry::OnReadPacket(
   // by the server,  The actual remote address is the one we recorded.
   if (!port_->HasMagicCookie(data, size)) {
     if (locked_) {
-      port_->OnReadPacket(data, size, ext_addr_, PROTO_UDP, packet_time);
+      port_->OnReadPacket(data, size, ext_addr_, PROTO_UDP);
     } else {
       LOG(WARNING) << "Dropping packet: entry not locked";
     }
@@ -756,7 +751,7 @@ void RelayEntry::OnReadPacket(
 
   // Process the actual data and remote address in the normal manner.
   port_->OnReadPacket(data_attr->bytes(), data_attr->length(), remote_addr2,
-                      PROTO_UDP, packet_time);
+                      PROTO_UDP);
 }
 
 void RelayEntry::OnReadyToSend(talk_base::AsyncPacketSocket* socket) {
diff --git a/talk/p2p/base/relayport.h b/talk/p2p/base/relayport.h
index 08df12f9d..c15e7e010 100644
--- a/talk/p2p/base/relayport.h
+++ b/talk/p2p/base/relayport.h
@@ -99,8 +99,7 @@ class RelayPort : public Port {
   // Dispatches the given packet to the port or connection as appropriate.
   void OnReadPacket(const char* data, size_t size,
                     const talk_base::SocketAddress& remote_addr,
-                    ProtocolType proto,
-                    const talk_base::PacketTime& packet_time);
+                    ProtocolType proto);
 
  private:
   friend class RelayEntry;
diff --git a/talk/p2p/base/relayport_unittest.cc b/talk/p2p/base/relayport_unittest.cc
index bd00af86d..ced8c589b 100644
--- a/talk/p2p/base/relayport_unittest.cc
+++ b/talk/p2p/base/relayport_unittest.cc
@@ -78,8 +78,7 @@ class RelayPortTest : public testing::Test,
 
   void OnReadPacket(talk_base::AsyncPacketSocket* socket,
                     const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time) {
+                    const talk_base::SocketAddress& remote_addr) {
     received_packet_count_[socket]++;
   }
 
diff --git a/talk/p2p/base/relayserver.cc b/talk/p2p/base/relayserver.cc
index c2619c03f..c2cf472d3 100644
--- a/talk/p2p/base/relayserver.cc
+++ b/talk/p2p/base/relayserver.cc
@@ -198,8 +198,7 @@ void RelayServer::OnReadEvent(talk_base::AsyncSocket* socket) {
 
 void RelayServer::OnInternalPacket(
     talk_base::AsyncPacketSocket* socket, const char* bytes, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+    const talk_base::SocketAddress& remote_addr) {
 
   // Get the address of the connection we just received on.
   talk_base::SocketAddressPair ap(remote_addr, socket->GetLocalAddress());
@@ -243,8 +242,7 @@ void RelayServer::OnInternalPacket(
 
 void RelayServer::OnExternalPacket(
     talk_base::AsyncPacketSocket* socket, const char* bytes, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+    const talk_base::SocketAddress& remote_addr) {
 
   // Get the address of the connection we just received on.
   talk_base::SocketAddressPair ap(remote_addr, socket->GetLocalAddress());
diff --git a/talk/p2p/base/relayserver.h b/talk/p2p/base/relayserver.h
index 922a25622..f3bee7eca 100644
--- a/talk/p2p/base/relayserver.h
+++ b/talk/p2p/base/relayserver.h
@@ -104,12 +104,10 @@ class RelayServer : public talk_base::MessageHandler,
   // Called when a packet is received by the server on one of its sockets.
   void OnInternalPacket(talk_base::AsyncPacketSocket* socket,
                         const char* bytes, size_t size,
-                        const talk_base::SocketAddress& remote_addr,
-                        const talk_base::PacketTime& packet_time);
+                        const talk_base::SocketAddress& remote_addr);
   void OnExternalPacket(talk_base::AsyncPacketSocket* socket,
                         const char* bytes, size_t size,
-                        const talk_base::SocketAddress& remote_addr,
-                        const talk_base::PacketTime& packet_time);
+                        const talk_base::SocketAddress& remote_addr);
 
   void OnReadEvent(talk_base::AsyncSocket* socket);
 
diff --git a/talk/p2p/base/session_unittest.cc b/talk/p2p/base/session_unittest.cc
index ab4620f87..b64e73742 100644
--- a/talk/p2p/base/session_unittest.cc
+++ b/talk/p2p/base/session_unittest.cc
@@ -814,7 +814,7 @@ struct ChannelHandler : sigslot::has_slots<> {
   }
 
   void OnReadPacket(cricket::TransportChannel* p, const char* buf,
-                    size_t size, const talk_base::PacketTime& time, int flags) {
+                    size_t size, int flags) {
     if (memcmp(buf, name.c_str(), name.size()) != 0)
       return;  // drop packet if packet doesn't belong to this channel. This
                // can happen when transport channels are muxed together.
diff --git a/talk/p2p/base/stunport.cc b/talk/p2p/base/stunport.cc
index 913f9af5f..283eade4e 100644
--- a/talk/p2p/base/stunport.cc
+++ b/talk/p2p/base/stunport.cc
@@ -254,10 +254,9 @@ void UDPPort::OnLocalAddressReady(talk_base::AsyncPacketSocket* socket,
   MaybePrepareStunCandidate();
 }
 
-void UDPPort::OnReadPacket(
-  talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-  const talk_base::SocketAddress& remote_addr,
-  const talk_base::PacketTime& packet_time) {
+void UDPPort::OnReadPacket(talk_base::AsyncPacketSocket* socket,
+                           const char* data, size_t size,
+                           const talk_base::SocketAddress& remote_addr) {
   ASSERT(socket == socket_);
 
   // Look for a response from the STUN server.
@@ -270,7 +269,7 @@ void UDPPort::OnReadPacket(
   }
 
   if (Connection* conn = GetConnection(remote_addr)) {
-    conn->OnReadPacket(data, size, packet_time);
+    conn->OnReadPacket(data, size);
   } else {
     Port::OnReadPacket(data, size, remote_addr, PROTO_UDP);
   }
diff --git a/talk/p2p/base/stunport.h b/talk/p2p/base/stunport.h
index a8b89c3be..8f7255658 100644
--- a/talk/p2p/base/stunport.h
+++ b/talk/p2p/base/stunport.h
@@ -97,10 +97,9 @@ class UDPPort : public Port {
 
   virtual bool HandleIncomingPacket(
       talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-      const talk_base::SocketAddress& remote_addr,
-      const talk_base::PacketTime& packet_time) {
+      const talk_base::SocketAddress& remote_addr) {
     // All packets given to UDP port will be consumed.
-    OnReadPacket(socket, data, size, remote_addr, packet_time);
+    OnReadPacket(socket, data, size, remote_addr);
     return true;
   }
 
@@ -132,9 +131,7 @@ class UDPPort : public Port {
                            const talk_base::SocketAddress& address);
   void OnReadPacket(talk_base::AsyncPacketSocket* socket,
                     const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time);
-
+                    const talk_base::SocketAddress& remote_addr);
   void OnReadyToSend(talk_base::AsyncPacketSocket* socket);
 
   // This method will send STUN binding request if STUN server address is set.
diff --git a/talk/p2p/base/stunport_unittest.cc b/talk/p2p/base/stunport_unittest.cc
index 2a98a9fdb..12b32dbc4 100644
--- a/talk/p2p/base/stunport_unittest.cc
+++ b/talk/p2p/base/stunport_unittest.cc
@@ -99,16 +99,13 @@ class StunPortTest : public testing::Test,
   }
 
   void OnReadPacket(talk_base::AsyncPacketSocket* socket, const char* data,
-                    size_t size, const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time) {
-    stun_port_->HandleIncomingPacket(
-        socket, data, size, remote_addr, talk_base::PacketTime());
+                    size_t size, const talk_base::SocketAddress& remote_addr) {
+    stun_port_->HandleIncomingPacket(socket, data, size, remote_addr);
   }
 
   void SendData(const char* data, size_t len) {
     stun_port_->HandleIncomingPacket(
-        socket_.get(), data, len, talk_base::SocketAddress("22.22.22.22", 0),
-        talk_base::PacketTime());
+        socket_.get(), data, len, talk_base::SocketAddress("22.22.22.22", 0));
   }
 
  protected:
diff --git a/talk/p2p/base/stunserver.cc b/talk/p2p/base/stunserver.cc
index 062be2068..80719b4aa 100644
--- a/talk/p2p/base/stunserver.cc
+++ b/talk/p2p/base/stunserver.cc
@@ -42,8 +42,7 @@ StunServer::~StunServer() {
 
 void StunServer::OnPacket(
     talk_base::AsyncPacketSocket* socket, const char* buf, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+    const talk_base::SocketAddress& remote_addr) {
   // Parse the STUN message; eat any messages that fail to parse.
   talk_base::ByteBuffer bbuf(buf, size);
   StunMessage msg;
diff --git a/talk/p2p/base/stunserver.h b/talk/p2p/base/stunserver.h
index c5d12e1d1..6e51ad184 100644
--- a/talk/p2p/base/stunserver.h
+++ b/talk/p2p/base/stunserver.h
@@ -47,8 +47,7 @@ class StunServer : public sigslot::has_slots<> {
   // Slot for AsyncSocket.PacketRead:
   void OnPacket(
       talk_base::AsyncPacketSocket* socket, const char* buf, size_t size,
-      const talk_base::SocketAddress& remote_addr,
-      const talk_base::PacketTime& packet_time);
+      const talk_base::SocketAddress& remote_addr);
 
   // Handlers for the different types of STUN/TURN requests:
   void OnBindingRequest(StunMessage* msg,
diff --git a/talk/p2p/base/tcpport.cc b/talk/p2p/base/tcpport.cc
index 2cca82f19..11334c622 100644
--- a/talk/p2p/base/tcpport.cc
+++ b/talk/p2p/base/tcpport.cc
@@ -218,8 +218,7 @@ talk_base::AsyncPacketSocket* TCPPort::GetIncoming(
 
 void TCPPort::OnReadPacket(talk_base::AsyncPacketSocket* socket,
                            const char* data, size_t size,
-                           const talk_base::SocketAddress& remote_addr,
-                           const talk_base::PacketTime& packet_time) {
+                           const talk_base::SocketAddress& remote_addr) {
   Port::OnReadPacket(data, size, remote_addr, PROTO_TCP);
 }
 
@@ -311,12 +310,11 @@ void TCPConnection::OnClose(talk_base::AsyncPacketSocket* socket, int error) {
   set_write_state(STATE_WRITE_TIMEOUT);
 }
 
-void TCPConnection::OnReadPacket(
-  talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-  const talk_base::SocketAddress& remote_addr,
-  const talk_base::PacketTime& packet_time) {
+void TCPConnection::OnReadPacket(talk_base::AsyncPacketSocket* socket,
+                                 const char* data, size_t size,
+                                 const talk_base::SocketAddress& remote_addr) {
   ASSERT(socket == socket_);
-  Connection::OnReadPacket(data, size, packet_time);
+  Connection::OnReadPacket(data, size);
 }
 
 void TCPConnection::OnReadyToSend(talk_base::AsyncPacketSocket* socket) {
diff --git a/talk/p2p/base/tcpport.h b/talk/p2p/base/tcpport.h
index 77b177a2d..599d3c66b 100644
--- a/talk/p2p/base/tcpport.h
+++ b/talk/p2p/base/tcpport.h
@@ -102,8 +102,7 @@ class TCPPort : public Port {
   // Receives packet signal from the local TCP Socket.
   void OnReadPacket(talk_base::AsyncPacketSocket* socket,
                     const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time);
+                    const talk_base::SocketAddress& remote_addr);
 
   void OnReadyToSend(talk_base::AsyncPacketSocket* socket);
 
@@ -138,8 +137,7 @@ class TCPConnection : public Connection {
   void OnClose(talk_base::AsyncPacketSocket* socket, int error);
   void OnReadPacket(talk_base::AsyncPacketSocket* socket,
                     const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time);
+                    const talk_base::SocketAddress& remote_addr);
   void OnReadyToSend(talk_base::AsyncPacketSocket* socket);
 
   talk_base::AsyncPacketSocket* socket_;
diff --git a/talk/p2p/base/transportchannel.h b/talk/p2p/base/transportchannel.h
index 47ba990f3..c48e1a542 100644
--- a/talk/p2p/base/transportchannel.h
+++ b/talk/p2p/base/transportchannel.h
@@ -31,7 +31,6 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/asyncpacketsocket.h"
 #include "talk/base/basictypes.h"
 #include "talk/base/dscp.h"
 #include "talk/base/sigslot.h"
@@ -123,8 +122,8 @@ class TransportChannel : public sigslot::has_slots<> {
       size_t result_len) = 0;
 
   // Signalled each time a packet is received on this channel.
-  sigslot::signal5<TransportChannel*, const char*,
-                   size_t, const talk_base::PacketTime&, int> SignalReadPacket;
+  sigslot::signal4<TransportChannel*, const char*,
+                   size_t, int> SignalReadPacket;
 
   // This signal occurs when there is a change in the way that packets are
   // being routed, i.e. to a different remote location. The candidate
diff --git a/talk/p2p/base/transportchannelproxy.cc b/talk/p2p/base/transportchannelproxy.cc
index 0d8cace2a..9a10603e7 100644
--- a/talk/p2p/base/transportchannelproxy.cc
+++ b/talk/p2p/base/transportchannelproxy.cc
@@ -234,12 +234,12 @@ void TransportChannelProxy::OnWritableState(TransportChannel* channel) {
   // Note: SignalWritableState fired by set_readable.
 }
 
-void TransportChannelProxy::OnReadPacket(
-    TransportChannel* channel, const char* data, size_t size,
-    const talk_base::PacketTime& packet_time, int flags) {
+void TransportChannelProxy::OnReadPacket(TransportChannel* channel,
+                                         const char* data, size_t size,
+                                         int flags) {
   ASSERT(talk_base::Thread::Current() == worker_thread_);
   ASSERT(channel == impl_);
-  SignalReadPacket(this, data, size, packet_time, flags);
+  SignalReadPacket(this, data, size, flags);
 }
 
 void TransportChannelProxy::OnReadyToSend(TransportChannel* channel) {
diff --git a/talk/p2p/base/transportchannelproxy.h b/talk/p2p/base/transportchannelproxy.h
index 196d0f6cf..3559ed588 100644
--- a/talk/p2p/base/transportchannelproxy.h
+++ b/talk/p2p/base/transportchannelproxy.h
@@ -90,7 +90,7 @@ class TransportChannelProxy : public TransportChannel,
   void OnReadableState(TransportChannel* channel);
   void OnWritableState(TransportChannel* channel);
   void OnReadPacket(TransportChannel* channel, const char* data, size_t size,
-                    const talk_base::PacketTime& packet_time, int flags);
+                    int flags);
   void OnReadyToSend(TransportChannel* channel);
   void OnRouteChange(TransportChannel* channel, const Candidate& candidate);
 
diff --git a/talk/p2p/base/turnport.cc b/talk/p2p/base/turnport.cc
index 01d7f9c89..92f62c8e8 100644
--- a/talk/p2p/base/turnport.cc
+++ b/talk/p2p/base/turnport.cc
@@ -356,10 +356,9 @@ int TurnPort::SendTo(const void* data, size_t size,
   return static_cast<int>(size);
 }
 
-void TurnPort::OnReadPacket(
-    talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+void TurnPort::OnReadPacket(talk_base::AsyncPacketSocket* socket,
+                           const char* data, size_t size,
+                           const talk_base::SocketAddress& remote_addr) {
   ASSERT(socket == socket_.get());
   ASSERT(remote_addr == server_address_.address);
 
@@ -374,9 +373,9 @@ void TurnPort::OnReadPacket(
   // a response to a previous request.
   uint16 msg_type = talk_base::GetBE16(data);
   if (IsTurnChannelData(msg_type)) {
-    HandleChannelData(msg_type, data, size, packet_time);
+    HandleChannelData(msg_type, data, size);
   } else if (msg_type == TURN_DATA_INDICATION) {
-    HandleDataIndication(data, size, packet_time);
+    HandleDataIndication(data, size);
   } else {
     // This must be a response for one of our requests.
     // Check success responses, but not errors, for MESSAGE-INTEGRITY.
@@ -461,8 +460,7 @@ void TurnPort::OnAllocateRequestTimeout() {
   OnAllocateError();
 }
 
-void TurnPort::HandleDataIndication(const char* data, size_t size,
-                                    const talk_base::PacketTime& packet_time) {
+void TurnPort::HandleDataIndication(const char* data, size_t size) {
   // Read in the message, and process according to RFC5766, Section 10.4.
   talk_base::ByteBuffer buf(data, size);
   TurnMessage msg;
@@ -497,13 +495,11 @@ void TurnPort::HandleDataIndication(const char* data, size_t size,
     return;
   }
 
-  DispatchPacket(data_attr->bytes(), data_attr->length(), ext_addr,
-                 PROTO_UDP, packet_time);
+  DispatchPacket(data_attr->bytes(), data_attr->length(), ext_addr, PROTO_UDP);
 }
 
 void TurnPort::HandleChannelData(int channel_id, const char* data,
-                                 size_t size,
-                                 const talk_base::PacketTime& packet_time) {
+                                 size_t size) {
   // Read the message, and process according to RFC5766, Section 11.6.
   //    0                   1                   2                   3
   //    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -535,14 +531,13 @@ void TurnPort::HandleChannelData(int channel_id, const char* data,
   }
 
   DispatchPacket(data + TURN_CHANNEL_HEADER_SIZE, len, entry->address(),
-                 PROTO_UDP, packet_time);
+                 PROTO_UDP);
 }
 
 void TurnPort::DispatchPacket(const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    ProtocolType proto, const talk_base::PacketTime& packet_time) {
+    const talk_base::SocketAddress& remote_addr, ProtocolType proto) {
   if (Connection* conn = GetConnection(remote_addr)) {
-    conn->OnReadPacket(data, size, packet_time);
+    conn->OnReadPacket(data, size);
   } else {
     Port::OnReadPacket(data, size, remote_addr, proto);
   }
diff --git a/talk/p2p/base/turnport.h b/talk/p2p/base/turnport.h
index e380a8912..e5c03da12 100644
--- a/talk/p2p/base/turnport.h
+++ b/talk/p2p/base/turnport.h
@@ -32,11 +32,11 @@
 #include <string>
 #include <list>
 
-#include "talk/base/asyncpacketsocket.h"
 #include "talk/p2p/base/port.h"
 #include "talk/p2p/client/basicportallocator.h"
 
 namespace talk_base {
+class AsyncPacketSocket;
 class AsyncResolver;
 class SignalThread;
 }
@@ -79,10 +79,9 @@ class TurnPort : public Port {
   virtual int SetOption(talk_base::Socket::Option opt, int value);
   virtual int GetOption(talk_base::Socket::Option opt, int* value);
   virtual int GetError();
-  virtual void OnReadPacket(
-      talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-      const talk_base::SocketAddress& remote_addr,
-      const talk_base::PacketTime& packet_time);
+  virtual void OnReadPacket(talk_base::AsyncPacketSocket* socket,
+                            const char* data, size_t size,
+                            const talk_base::SocketAddress& remote_addr);
   virtual void OnReadyToSend(talk_base::AsyncPacketSocket* socket);
 
   void OnSocketConnect(talk_base::AsyncPacketSocket* socket);
@@ -135,13 +134,10 @@ class TurnPort : public Port {
   void OnAllocateError();
   void OnAllocateRequestTimeout();
 
-  void HandleDataIndication(const char* data, size_t size,
-                            const talk_base::PacketTime& packet_time);
-  void HandleChannelData(int channel_id, const char* data, size_t size,
-                         const talk_base::PacketTime& packet_time);
+  void HandleDataIndication(const char* data, size_t size);
+  void HandleChannelData(int channel_id, const char* data, size_t size);
   void DispatchPacket(const char* data, size_t size,
-      const talk_base::SocketAddress& remote_addr,
-      ProtocolType proto, const talk_base::PacketTime& packet_time);
+      const talk_base::SocketAddress& remote_addr, ProtocolType proto);
 
   bool ScheduleRefresh(int lifetime);
   void SendRequest(StunRequest* request, int delay);
diff --git a/talk/p2p/base/turnport_unittest.cc b/talk/p2p/base/turnport_unittest.cc
index d559894ac..11e221358 100644
--- a/talk/p2p/base/turnport_unittest.cc
+++ b/talk/p2p/base/turnport_unittest.cc
@@ -118,15 +118,13 @@ class TurnPortTest : public testing::Test,
       turn_create_permission_success_ = true;
     }
   }
-  void OnTurnReadPacket(Connection* conn, const char* data, size_t size,
-                        const talk_base::PacketTime& packet_time) {
+  void OnTurnReadPacket(Connection* conn, const char* data, size_t size) {
     turn_packets_.push_back(talk_base::Buffer(data, size));
   }
   void OnUdpPortComplete(Port* port) {
     udp_ready_ = true;
   }
-  void OnUdpReadPacket(Connection* conn, const char* data, size_t size,
-                       const talk_base::PacketTime& packet_time) {
+  void OnUdpReadPacket(Connection* conn, const char* data, size_t size) {
     udp_packets_.push_back(talk_base::Buffer(data, size));
   }
 
diff --git a/talk/p2p/base/turnserver.cc b/talk/p2p/base/turnserver.cc
index 0bd903abe..17ecf3507 100644
--- a/talk/p2p/base/turnserver.cc
+++ b/talk/p2p/base/turnserver.cc
@@ -109,8 +109,7 @@ class TurnServer::Allocation : public talk_base::MessageHandler,
 
   void OnExternalPacket(talk_base::AsyncPacketSocket* socket,
                         const char* data, size_t size,
-                        const talk_base::SocketAddress& addr,
-                        const talk_base::PacketTime& packet_time);
+                        const talk_base::SocketAddress& addr);
 
   static int ComputeLifetime(const TurnMessage* msg);
   bool HasPermission(const talk_base::IPAddress& addr);
@@ -281,8 +280,7 @@ void TurnServer::OnInternalSocketClose(talk_base::AsyncPacketSocket* socket,
 
 void TurnServer::OnInternalPacket(talk_base::AsyncPacketSocket* socket,
                                   const char* data, size_t size,
-                                  const talk_base::SocketAddress& addr,
-                                  const talk_base::PacketTime& packet_time) {
+                                  const talk_base::SocketAddress& addr) {
   // Fail if the packet is too small to even contain a channel header.
   if (size < TURN_CHANNEL_HEADER_SIZE) {
    return;
@@ -840,8 +838,7 @@ void TurnServer::Allocation::HandleChannelData(const char* data, size_t size) {
 void TurnServer::Allocation::OnExternalPacket(
     talk_base::AsyncPacketSocket* socket,
     const char* data, size_t size,
-    const talk_base::SocketAddress& addr,
-    const talk_base::PacketTime& packet_time) {
+    const talk_base::SocketAddress& addr) {
   ASSERT(external_socket_.get() == socket);
   Channel* channel = FindChannel(addr);
   if (channel) {
diff --git a/talk/p2p/base/turnserver.h b/talk/p2p/base/turnserver.h
index 2c33cdb4b..56ce2fcb0 100644
--- a/talk/p2p/base/turnserver.h
+++ b/talk/p2p/base/turnserver.h
@@ -33,13 +33,13 @@
 #include <set>
 #include <string>
 
-#include "talk/base/asyncpacketsocket.h"
 #include "talk/base/messagequeue.h"
 #include "talk/base/sigslot.h"
 #include "talk/base/socketaddress.h"
 #include "talk/p2p/base/portinterface.h"
 
 namespace talk_base {
+class AsyncPacketSocket;
 class ByteBuffer;
 class PacketSocketFactory;
 class Thread;
@@ -123,8 +123,7 @@ class TurnServer : public sigslot::has_slots<> {
   typedef std::map<Connection, Allocation*> AllocationMap;
 
   void OnInternalPacket(talk_base::AsyncPacketSocket* socket, const char* data,
-                        size_t size, const talk_base::SocketAddress& address,
-                        const talk_base::PacketTime& packet_time);
+                        size_t size, const talk_base::SocketAddress& address);
 
   void OnNewInternalConnection(talk_base::AsyncSocket* socket);
 
diff --git a/talk/p2p/client/basicportallocator.cc b/talk/p2p/client/basicportallocator.cc
index dbc2e3342..a5310b70a 100644
--- a/talk/p2p/client/basicportallocator.cc
+++ b/talk/p2p/client/basicportallocator.cc
@@ -149,9 +149,7 @@ class AllocationSequence : public talk_base::MessageHandler,
 
   void OnReadPacket(talk_base::AsyncPacketSocket* socket,
                     const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time);
-
+                    const talk_base::SocketAddress& remote_addr);
   void OnPortDestroyed(PortInterface* port);
 
   BasicPortAllocatorSession* session_;
@@ -1026,15 +1024,13 @@ void AllocationSequence::CreateTurnPort(const RelayServerConfig& config) {
 
 void AllocationSequence::OnReadPacket(
     talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+    const talk_base::SocketAddress& remote_addr) {
   ASSERT(socket == udp_socket_.get());
   for (std::deque<Port*>::iterator iter = ports.begin();
        iter != ports.end(); ++iter) {
     // We have only one port in the queue.
     // TODO(mallinath) - Add shared socket support to Relay and Turn ports.
-    if ((*iter)->HandleIncomingPacket(
-        socket, data, size, remote_addr, packet_time)) {
+    if ((*iter)->HandleIncomingPacket(socket, data, size, remote_addr)) {
       break;
     }
   }
diff --git a/talk/session/media/channel.cc b/talk/session/media/channel.cc
index 9a8559a5b..8579db204 100644
--- a/talk/session/media/channel.cc
+++ b/talk/session/media/channel.cc
@@ -610,9 +610,7 @@ void BaseChannel::OnWritableState(TransportChannel* channel) {
 }
 
 void BaseChannel::OnChannelRead(TransportChannel* channel,
-                                const char* data, size_t len,
-                                const talk_base::PacketTime& packet_time,
-                                int flags) {
+                                const char* data, size_t len, int flags) {
   // OnChannelRead gets called from P2PSocket; now pass data to MediaEngine
   ASSERT(worker_thread_ == talk_base::Thread::Current());
 
@@ -620,7 +618,7 @@ void BaseChannel::OnChannelRead(TransportChannel* channel,
   // transport. We feed RTP traffic into the demuxer to determine if it is RTCP.
   bool rtcp = PacketIsRtcp(channel, data, len);
   talk_base::Buffer packet(data, len);
-  HandlePacket(rtcp, &packet, packet_time);
+  HandlePacket(rtcp, &packet);
 }
 
 void BaseChannel::OnReadyToSend(TransportChannel* channel) {
@@ -776,8 +774,7 @@ bool BaseChannel::WantsPacket(bool rtcp, talk_base::Buffer* packet) {
   return true;
 }
 
-void BaseChannel::HandlePacket(bool rtcp, talk_base::Buffer* packet,
-                               const talk_base::PacketTime& packet_time) {
+void BaseChannel::HandlePacket(bool rtcp, talk_base::Buffer* packet) {
   if (!WantsPacket(rtcp, packet)) {
     return;
   }
@@ -846,9 +843,9 @@ void BaseChannel::HandlePacket(bool rtcp, talk_base::Buffer* packet,
 
   // Push it down to the media channel.
   if (!rtcp) {
-    media_channel_->OnPacketReceived(packet, packet_time);
+    media_channel_->OnPacketReceived(packet);
   } else {
-    media_channel_->OnRtcpReceived(packet, packet_time);
+    media_channel_->OnRtcpReceived(packet);
   }
 }
 
@@ -1648,10 +1645,8 @@ void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) {
 }
 
 void VoiceChannel::OnChannelRead(TransportChannel* channel,
-                                 const char* data, size_t len,
-                                 const talk_base::PacketTime& packet_time,
-                                int flags) {
-  BaseChannel::OnChannelRead(channel, data, len, packet_time, flags);
+                                 const char* data, size_t len, int flags) {
+  BaseChannel::OnChannelRead(channel, data, len, flags);
 
   // Set a flag when we've received an RTP packet. If we're waiting for early
   // media, this will disable the timeout.
diff --git a/talk/session/media/channel.h b/talk/session/media/channel.h
index d297ee4b8..27a81a6d5 100644
--- a/talk/session/media/channel.h
+++ b/talk/session/media/channel.h
@@ -265,11 +265,8 @@ class BaseChannel
 
   // From TransportChannel
   void OnWritableState(TransportChannel* channel);
-  virtual void OnChannelRead(TransportChannel* channel,
-                             const char* data,
-                             size_t len,
-                             const talk_base::PacketTime& packet_time,
-                             int flags);
+  virtual void OnChannelRead(TransportChannel* channel, const char* data,
+                             size_t len, int flags);
   void OnReadyToSend(TransportChannel* channel);
 
   bool PacketIsRtcp(const TransportChannel* channel, const char* data,
@@ -277,8 +274,7 @@ class BaseChannel
   bool SendPacket(bool rtcp, talk_base::Buffer* packet,
                   talk_base::DiffServCodePoint dscp);
   virtual bool WantsPacket(bool rtcp, talk_base::Buffer* packet);
-  void HandlePacket(bool rtcp, talk_base::Buffer* packet,
-                    const talk_base::PacketTime& packet_time);
+  void HandlePacket(bool rtcp, talk_base::Buffer* packet);
 
   // Apply the new local/remote session description.
   void OnNewLocalDescription(BaseSession* session, ContentAction action);
@@ -445,9 +441,7 @@ class VoiceChannel : public BaseChannel {
  private:
   // overrides from BaseChannel
   virtual void OnChannelRead(TransportChannel* channel,
-                             const char* data, size_t len,
-                             const talk_base::PacketTime& packet_time,
-                             int flags);
+                             const char* data, size_t len, int flags);
   virtual void ChangeState();
   virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
   virtual bool SetLocalContent_w(const MediaContentDescription* content,
diff --git a/talk/session/media/channel_unittest.cc b/talk/session/media/channel_unittest.cc
index 48a9bdef5..02739079d 100644
--- a/talk/session/media/channel_unittest.cc
+++ b/talk/session/media/channel_unittest.cc
@@ -1775,7 +1775,7 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
         channel2_->transport_channel();
     transport_channel->SignalReadPacket(
         transport_channel, reinterpret_cast<const char*>(kBadPacket),
-        sizeof(kBadPacket), talk_base::PacketTime(), 0);
+        sizeof(kBadPacket), 0);
     EXPECT_EQ_WAIT(T::MediaChannel::ERROR_PLAY_SRTP_ERROR, error_, 500);
   }
 
diff --git a/talk/session/media/channelmanager.cc b/talk/session/media/channelmanager.cc
index 4d5d8fc7f..d4fcc79df 100644
--- a/talk/session/media/channelmanager.cc
+++ b/talk/session/media/channelmanager.cc
@@ -947,9 +947,4 @@ bool ChannelManager::SetAudioOptions(const AudioOptions& options) {
   return true;
 }
 
-bool ChannelManager::StartAecDump(FILE* file) {
-  return worker_thread_->Invoke<bool>(
-      Bind(&MediaEngineInterface::StartAecDump, media_engine_.get(), file));
-}
-
 }  // namespace cricket
diff --git a/talk/session/media/channelmanager.h b/talk/session/media/channelmanager.h
index f19d3d082..fdb8f7336 100644
--- a/talk/session/media/channelmanager.h
+++ b/talk/session/media/channelmanager.h
@@ -214,9 +214,6 @@ class ChannelManager : public talk_base::MessageHandler,
   void SetVideoCaptureDeviceMaxFormat(const std::string& usb_id,
                                       const VideoFormat& max_format);
 
-  // Starts AEC dump using existing file.
-  bool StartAecDump(FILE* file);
-
   sigslot::repeater0<> SignalDevicesChange;
   sigslot::signal2<VideoCapturer*, CaptureState> SignalVideoCaptureStateChange;
 
diff --git a/talk/session/tunnel/pseudotcpchannel.cc b/talk/session/tunnel/pseudotcpchannel.cc
index ee88797c1..92e9e0ea5 100644
--- a/talk/session/tunnel/pseudotcpchannel.cc
+++ b/talk/session/tunnel/pseudotcpchannel.cc
@@ -340,9 +340,7 @@ void PseudoTcpChannel::OnChannelWritableState(TransportChannel* channel) {
 }
 
 void PseudoTcpChannel::OnChannelRead(TransportChannel* channel,
-                                     const char* data, size_t size,
-                                     const talk_base::PacketTime& packet_time,
-                                     int flags) {
+                                     const char* data, size_t size, int flags) {
   //LOG_F(LS_VERBOSE) << "(" << size << ")";
   ASSERT(worker_thread_->IsCurrent());
   CritScope lock(&cs_);
diff --git a/talk/session/tunnel/pseudotcpchannel.h b/talk/session/tunnel/pseudotcpchannel.h
index 31cd9a18b..a540699a5 100644
--- a/talk/session/tunnel/pseudotcpchannel.h
+++ b/talk/session/tunnel/pseudotcpchannel.h
@@ -111,7 +111,7 @@ class PseudoTcpChannel
   // Worker thread methods
   void OnChannelWritableState(TransportChannel* channel);
   void OnChannelRead(TransportChannel* channel, const char* data, size_t size,
-                     const talk_base::PacketTime& packet_time, int flags);
+                     int flags);
   void OnChannelConnectionChanged(TransportChannel* channel,
                                   const Candidate& candidate);
 
diff --git a/webrtc/common_types.h b/webrtc/common_types.h
index 82f45d8f1..55ba5525f 100644
--- a/webrtc/common_types.h
+++ b/webrtc/common_types.h
@@ -677,22 +677,6 @@ struct OverUseDetectorOptions {
   double initial_threshold;
 };
 
-// This structure will have the information about when packet is actually
-// received by socket.
-struct PacketTime {
-  PacketTime() : timestamp(-1), max_error_us(-1) {}
-  PacketTime(int64_t timestamp, int64_t max_error_us)
-      : timestamp(timestamp), max_error_us(max_error_us) {
-  }
-
-  int64_t timestamp;    // Receive time after socket delivers the data.
-  int64_t max_error_us; // Earliest possible time the data could have arrived,
-                        // indicating the potential error in the |timestamp|
-                        // value,in case the system is busy.
-                        // For example, the time of the last select() call.
-                        // If unknown, this value will be set to zero.
-};
-
 }  // namespace webrtc
 
 #endif  // WEBRTC_COMMON_TYPES_H_
diff --git a/webrtc/test/channel_transport/channel_transport.cc b/webrtc/test/channel_transport/channel_transport.cc
index 2bf02e95d..9500c9030 100644
--- a/webrtc/test/channel_transport/channel_transport.cc
+++ b/webrtc/test/channel_transport/channel_transport.cc
@@ -105,8 +105,7 @@ void VideoChannelTransport::IncomingRTPPacket(
     const int32_t packet_length,
     const char* /*from_ip*/,
     const uint16_t /*from_port*/) {
-  vie_network_->ReceivedRTPPacket(
-      channel_, incoming_rtp_packet, packet_length, PacketTime());
+  vie_network_->ReceivedRTPPacket(channel_, incoming_rtp_packet, packet_length);
 }
 
 void VideoChannelTransport::IncomingRTCPPacket(
diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc
index 151ce83d2..b6aac0be4 100644
--- a/webrtc/video/video_receive_stream.cc
+++ b/webrtc/video/video_receive_stream.cc
@@ -161,8 +161,7 @@ bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
 
 bool VideoReceiveStream::DeliverRtp(const uint8_t* packet, size_t length) {
   return network_->ReceivedRTPPacket(
-             channel_, packet, static_cast<int>(length),
-             PacketTime()) == 0;
+             channel_, packet, static_cast<int>(length)) == 0;
 }
 
 int32_t VideoReceiveStream::RenderFrame(const uint32_t stream_id,
diff --git a/webrtc/video_engine/include/vie_network.h b/webrtc/video_engine/include/vie_network.h
index 4a9e6ce20..e1c6bb2c5 100644
--- a/webrtc/video_engine/include/vie_network.h
+++ b/webrtc/video_engine/include/vie_network.h
@@ -65,8 +65,7 @@ class WEBRTC_DLLEXPORT ViENetwork {
   // the RTP header and payload.
   virtual int ReceivedRTPPacket(const int video_channel,
                                 const void* data,
-                                const int length,
-                                const PacketTime& packet_time) = 0;
+                                const int length) = 0;
 
   // When using external transport for a channel, received RTCP packets should
   // be passed to VideoEngine using this function.
diff --git a/webrtc/video_engine/test/libvietest/testbed/tb_external_transport.cc b/webrtc/video_engine/test/libvietest/testbed/tb_external_transport.cc
index 566a01a06..f26c1e1e9 100644
--- a/webrtc/video_engine/test/libvietest/testbed/tb_external_transport.cc
+++ b/webrtc/video_engine/test/libvietest/testbed/tb_external_transport.cc
@@ -458,8 +458,7 @@ bool TbExternalTransport::ViEExternalTransportProcess()
             }
             _vieNetwork.ReceivedRTPPacket(destination_channel,
                                           packet->packetBuffer,
-                                          packet->length,
-                                          webrtc::PacketTime());
+                                          packet->length);
             delete packet;
             packet = NULL;
         }
diff --git a/webrtc/video_engine/vie_channel.cc b/webrtc/video_engine/vie_channel.cc
index 810f66bdd..b6d9be1dd 100644
--- a/webrtc/video_engine/vie_channel.cc
+++ b/webrtc/video_engine/vie_channel.cc
@@ -1612,16 +1612,14 @@ int32_t ViEChannel::DeregisterSendTransport() {
 }
 
 int32_t ViEChannel::ReceivedRTPPacket(
-    const void* rtp_packet, const int32_t rtp_packet_length,
-    const PacketTime& packet_time) {
+    const void* rtp_packet, const int32_t rtp_packet_length) {
   {
     CriticalSectionScoped cs(callback_cs_.get());
     if (!external_transport_) {
       return -1;
     }
   }
-  return vie_receiver_.ReceivedRTPPacket(
-      rtp_packet, rtp_packet_length, packet_time);
+  return vie_receiver_.ReceivedRTPPacket(rtp_packet, rtp_packet_length);
 }
 
 int32_t ViEChannel::ReceivedRTCPPacket(
diff --git a/webrtc/video_engine/vie_channel.h b/webrtc/video_engine/vie_channel.h
index 29b146492..0ee677eb5 100644
--- a/webrtc/video_engine/vie_channel.h
+++ b/webrtc/video_engine/vie_channel.h
@@ -262,8 +262,7 @@ class ViEChannel
 
   // Incoming packet from external transport.
   int32_t ReceivedRTPPacket(const void* rtp_packet,
-                            const int32_t rtp_packet_length,
-                            const PacketTime& packet_time);
+                            const int32_t rtp_packet_length);
 
   // Incoming packet from external transport.
   int32_t ReceivedRTCPPacket(const void* rtcp_packet,
diff --git a/webrtc/video_engine/vie_network_impl.cc b/webrtc/video_engine/vie_network_impl.cc
index 9965f9edd..0afd2fe8c 100644
--- a/webrtc/video_engine/vie_network_impl.cc
+++ b/webrtc/video_engine/vie_network_impl.cc
@@ -141,8 +141,7 @@ int ViENetworkImpl::DeregisterSendTransport(const int video_channel) {
 }
 
 int ViENetworkImpl::ReceivedRTPPacket(const int video_channel, const void* data,
-                                      const int length,
-                                      const PacketTime& packet_time) {
+                                      const int length) {
   WEBRTC_TRACE(kTraceApiCall, kTraceVideo,
                ViEId(shared_data_->instance_id(), video_channel),
                "%s(channel: %d, data: -, length: %d)", __FUNCTION__,
@@ -157,7 +156,7 @@ int ViENetworkImpl::ReceivedRTPPacket(const int video_channel, const void* data,
     shared_data_->SetLastError(kViENetworkInvalidChannelId);
     return -1;
   }
-  return vie_channel->ReceivedRTPPacket(data, length, packet_time);
+  return vie_channel->ReceivedRTPPacket(data, length);
 }
 
 int ViENetworkImpl::ReceivedRTCPPacket(const int video_channel,
diff --git a/webrtc/video_engine/vie_network_impl.h b/webrtc/video_engine/vie_network_impl.h
index 4aa39981b..d49c2febb 100644
--- a/webrtc/video_engine/vie_network_impl.h
+++ b/webrtc/video_engine/vie_network_impl.h
@@ -32,8 +32,7 @@ class ViENetworkImpl
   virtual int DeregisterSendTransport(const int video_channel);
   virtual int ReceivedRTPPacket(const int video_channel,
                                 const void* data,
-                                const int length,
-                                const PacketTime& packet_time);
+                                const int length);
   virtual int ReceivedRTCPPacket(const int video_channel,
                                  const void* data,
                                  const int length);
diff --git a/webrtc/video_engine/vie_receiver.cc b/webrtc/video_engine/vie_receiver.cc
index 2946c4a08..0f13aaf8c 100644
--- a/webrtc/video_engine/vie_receiver.cc
+++ b/webrtc/video_engine/vie_receiver.cc
@@ -177,10 +177,9 @@ bool ViEReceiver::SetReceiveAbsoluteSendTimeStatus(bool enable, int id) {
 }
 
 int ViEReceiver::ReceivedRTPPacket(const void* rtp_packet,
-                                   int rtp_packet_length,
-                                   const PacketTime& packet_time) {
+                                   int rtp_packet_length) {
   return InsertRTPPacket(static_cast<const int8_t*>(rtp_packet),
-                         rtp_packet_length, packet_time);
+                         rtp_packet_length);
 }
 
 int ViEReceiver::ReceivedRTCPPacket(const void* rtcp_packet,
@@ -212,8 +211,7 @@ bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
 }
 
 int ViEReceiver::InsertRTPPacket(const int8_t* rtp_packet,
-                                 int rtp_packet_length,
-                                 const PacketTime& packet_time) {
+                                 int rtp_packet_length) {
   // TODO(mflodman) Change decrypt to get rid of this cast.
   int8_t* tmp_ptr = const_cast<int8_t*>(rtp_packet);
   unsigned char* received_packet = reinterpret_cast<unsigned char*>(tmp_ptr);
@@ -258,13 +256,7 @@ int ViEReceiver::InsertRTPPacket(const int8_t* rtp_packet,
     return -1;
   }
   int payload_length = received_packet_length - header.headerLength;
-  int64_t arrival_time_ms;
-  if (packet_time.timestamp != -1)
-    arrival_time_ms = (packet_time.timestamp + 500) / 1000;
-  else
-    arrival_time_ms = TickTime::MillisecondTimestamp();
-
-  remote_bitrate_estimator_->IncomingPacket(arrival_time_ms,
+  remote_bitrate_estimator_->IncomingPacket(TickTime::MillisecondTimestamp(),
                                             payload_length, header);
   header.payload_type_frequency = kVideoPayloadTypeFrequency;
 
diff --git a/webrtc/video_engine/vie_receiver.h b/webrtc/video_engine/vie_receiver.h
index 6f480cbb4..c71467b83 100644
--- a/webrtc/video_engine/vie_receiver.h
+++ b/webrtc/video_engine/vie_receiver.h
@@ -18,7 +18,6 @@
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
 #include "webrtc/typedefs.h"
-#include "webrtc/video_engine/include/vie_network.h"
 #include "webrtc/video_engine/vie_defines.h"
 
 namespace webrtc {
@@ -71,8 +70,7 @@ class ViEReceiver : public RtpData {
   int StopRTPDump();
 
   // Receives packets from external transport.
-  int ReceivedRTPPacket(const void* rtp_packet, int rtp_packet_length,
-                        const PacketTime& packet_time);
+  int ReceivedRTPPacket(const void* rtp_packet, int rtp_packet_length);
   int ReceivedRTCPPacket(const void* rtcp_packet, int rtcp_packet_length);
   virtual bool OnRecoveredPacket(const uint8_t* packet,
                                  int packet_length) OVERRIDE;
@@ -88,8 +86,7 @@ class ViEReceiver : public RtpData {
   ReceiveStatistics* GetReceiveStatistics() const;
 
  private:
-  int InsertRTPPacket(const int8_t* rtp_packet, int rtp_packet_length,
-                      const PacketTime& packet_time);
+  int InsertRTPPacket(const int8_t* rtp_packet, int rtp_packet_length);
   bool ReceivePacket(const uint8_t* packet, int packet_length,
                      const RTPHeader& header, bool in_order);
   // Parses and handles for instance RTX and RED headers.