diff --git a/talk/app/webrtc/java/jni/peerconnection_jni.cc b/talk/app/webrtc/java/jni/peerconnection_jni.cc
index 52b6749..c31859d 100644
--- a/talk/app/webrtc/java/jni/peerconnection_jni.cc
+++ b/talk/app/webrtc/java/jni/peerconnection_jni.cc
@@ -1280,12 +1280,11 @@
 }
 
 JOW(jboolean, PeerConnectionFactory_nativeStartAecDump)(
-    JNIEnv* jni, jclass, jlong native_factory, jint file,
-    jint filesize_limit_bytes) {
+    JNIEnv* jni, jclass, jlong native_factory, jint file) {
 #if defined(ANDROID)
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
-  return factory->StartAecDump(file, filesize_limit_bytes);
+  return factory->StartAecDump(file);
 #else
   return false;
 #endif
diff --git a/talk/app/webrtc/java/src/org/webrtc/PeerConnectionFactory.java b/talk/app/webrtc/java/src/org/webrtc/PeerConnectionFactory.java
index e65c736..d759c69 100644
--- a/talk/app/webrtc/java/src/org/webrtc/PeerConnectionFactory.java
+++ b/talk/app/webrtc/java/src/org/webrtc/PeerConnectionFactory.java
@@ -143,8 +143,8 @@
   // Starts recording an AEC dump. Ownership of the file is transfered to the
   // native code. If an AEC dump is already in progress, it will be stopped and
   // a new one will start using the provided file.
-  public boolean startAecDump(int file_descriptor, int filesize_limit_bytes) {
-    return nativeStartAecDump(nativeFactory, file_descriptor, filesize_limit_bytes);
+  public boolean startAecDump(int file_descriptor) {
+    return nativeStartAecDump(nativeFactory, file_descriptor);
   }
 
   // Stops recording an AEC dump. If no AEC dump is currently being recorded,
@@ -250,8 +250,7 @@
   private static native long nativeCreateAudioTrack(
       long nativeFactory, String id, long nativeSource);
 
-  private static native boolean nativeStartAecDump(
-      long nativeFactory, int file_descriptor, int filesize_limit_bytes);
+  private static native boolean nativeStartAecDump(long nativeFactory, int file_descriptor);
 
   private static native void nativeStopAecDump(long nativeFactory);
 
diff --git a/talk/app/webrtc/peerconnectionfactory.cc b/talk/app/webrtc/peerconnectionfactory.cc
index 872bdb6..6d36c8b 100644
--- a/talk/app/webrtc/peerconnectionfactory.cc
+++ b/talk/app/webrtc/peerconnectionfactory.cc
@@ -232,10 +232,9 @@
   return VideoSourceProxy::Create(signaling_thread_, source);
 }
 
-bool PeerConnectionFactory::StartAecDump(rtc::PlatformFile file,
-                                         int64_t max_size_bytes) {
+bool PeerConnectionFactory::StartAecDump(rtc::PlatformFile file) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
-  return channel_manager_->StartAecDump(file, max_size_bytes);
+  return channel_manager_->StartAecDump(file);
 }
 
 void PeerConnectionFactory::StopAecDump() {
diff --git a/talk/app/webrtc/peerconnectionfactory.h b/talk/app/webrtc/peerconnectionfactory.h
index 6d2d972..cad89d4 100644
--- a/talk/app/webrtc/peerconnectionfactory.h
+++ b/talk/app/webrtc/peerconnectionfactory.h
@@ -93,7 +93,7 @@
       CreateAudioTrack(const std::string& id,
                        AudioSourceInterface* audio_source) override;
 
-  bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) override;
+  bool StartAecDump(rtc::PlatformFile file) override;
   void StopAecDump() override;
   bool StartRtcEventLog(rtc::PlatformFile file) override;
   void StopRtcEventLog() override;
diff --git a/talk/app/webrtc/peerconnectionfactoryproxy.h b/talk/app/webrtc/peerconnectionfactoryproxy.h
index f54ce5b..db34ea7 100644
--- a/talk/app/webrtc/peerconnectionfactoryproxy.h
+++ b/talk/app/webrtc/peerconnectionfactoryproxy.h
@@ -72,7 +72,7 @@
                 CreateVideoTrack, const std::string&,  VideoSourceInterface*)
   PROXY_METHOD2(rtc::scoped_refptr<AudioTrackInterface>,
                 CreateAudioTrack, const std::string&,  AudioSourceInterface*)
-  PROXY_METHOD2(bool, StartAecDump, rtc::PlatformFile, int64_t)
+  PROXY_METHOD1(bool, StartAecDump, rtc::PlatformFile)
   PROXY_METHOD0(void, StopAecDump)
   PROXY_METHOD1(bool, StartRtcEventLog, rtc::PlatformFile)
   PROXY_METHOD0(void, StopRtcEventLog)
diff --git a/talk/app/webrtc/peerconnectioninterface.h b/talk/app/webrtc/peerconnectioninterface.h
index 475145a..4648176 100644
--- a/talk/app/webrtc/peerconnectioninterface.h
+++ b/talk/app/webrtc/peerconnectioninterface.h
@@ -640,11 +640,9 @@
   // 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. If the operation fails, the file will be closed.
-  // A maximum file size in bytes can be specified. When the file size limit is
-  // reached, logging is stopped automatically. If max_size_bytes is set to a
-  // value <= 0, no limit will be used, and logging will continue until the
-  // StopAecDump function is called.
-  virtual bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) = 0;
+  // TODO(grunell): Remove when Chromium has started to use AEC in each source.
+  // http://crbug.com/264611.
+  virtual bool StartAecDump(rtc::PlatformFile file) = 0;
 
   // Stops logging the AEC dump.
   virtual void StopAecDump() = 0;
diff --git a/talk/media/base/fakemediaengine.h b/talk/media/base/fakemediaengine.h
index 3f56512..f5b2174 100644
--- a/talk/media/base/fakemediaengine.h
+++ b/talk/media/base/fakemediaengine.h
@@ -762,9 +762,7 @@
 
   int GetInputLevel() { return 0; }
 
-  bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) {
-    return false;
-  }
+  bool StartAecDump(rtc::PlatformFile file) { return false; }
 
   void StopAecDump() {}
 
diff --git a/talk/media/base/mediaengine.h b/talk/media/base/mediaengine.h
index cd533c4..43b4de5 100644
--- a/talk/media/base/mediaengine.h
+++ b/talk/media/base/mediaengine.h
@@ -102,10 +102,8 @@
   virtual const std::vector<VideoCodec>& video_codecs() = 0;
   virtual RtpCapabilities GetVideoCapabilities() = 0;
 
-  // Starts AEC dump using existing file, a maximum file size in bytes can be
-  // specified. Logging is stopped just before the size limit is exceeded.
-  // If max_size_bytes is set to a value <= 0, no limit will be used.
-  virtual bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) = 0;
+  // Starts AEC dump using existing file.
+  virtual bool StartAecDump(rtc::PlatformFile file) = 0;
 
   // Stops recording AEC dump.
   virtual void StopAecDump() = 0;
@@ -187,8 +185,8 @@
     return video_.GetCapabilities();
   }
 
-  virtual bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) {
-    return voice_.StartAecDump(file, max_size_bytes);
+  virtual bool StartAecDump(rtc::PlatformFile file) {
+    return voice_.StartAecDump(file);
   }
 
   virtual void StopAecDump() {
diff --git a/talk/media/webrtc/fakewebrtcvoiceengine.h b/talk/media/webrtc/fakewebrtcvoiceengine.h
index debaa6e..bf22a29 100644
--- a/talk/media/webrtc/fakewebrtcvoiceengine.h
+++ b/talk/media/webrtc/fakewebrtcvoiceengine.h
@@ -113,9 +113,8 @@
   WEBRTC_VOID_STUB(set_stream_key_pressed, (bool key_pressed));
   WEBRTC_VOID_STUB(set_delay_offset_ms, (int offset));
   WEBRTC_STUB_CONST(delay_offset_ms, ());
-  WEBRTC_STUB(StartDebugRecording,
-              (const char filename[kMaxFilenameSize], int64_t max_size_bytes));
-  WEBRTC_STUB(StartDebugRecording, (FILE * handle, int64_t max_size_bytes));
+  WEBRTC_STUB(StartDebugRecording, (const char filename[kMaxFilenameSize]));
+  WEBRTC_STUB(StartDebugRecording, (FILE* handle));
   WEBRTC_STUB(StopDebugRecording, ());
   WEBRTC_VOID_STUB(UpdateHistogramsOnCallEnd, ());
   webrtc::EchoCancellation* echo_cancellation() const override { return NULL; }
diff --git a/talk/media/webrtc/webrtcvoiceengine.cc b/talk/media/webrtc/webrtcvoiceengine.cc
index 38b6c54..9eee2af 100644
--- a/talk/media/webrtc/webrtcvoiceengine.cc
+++ b/talk/media/webrtc/webrtcvoiceengine.cc
@@ -1011,8 +1011,7 @@
   return true;
 }
 
-bool WebRtcVoiceEngine::StartAecDump(rtc::PlatformFile file,
-                                     int64_t max_size_bytes) {
+bool WebRtcVoiceEngine::StartAecDump(rtc::PlatformFile file) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   FILE* aec_dump_file_stream = rtc::FdopenPlatformFileForWriting(file);
   if (!aec_dump_file_stream) {
@@ -1022,8 +1021,7 @@
     return false;
   }
   StopAecDump();
-  if (voe_wrapper_->base()->audio_processing()->StartDebugRecording(
-          aec_dump_file_stream, max_size_bytes) !=
+  if (voe_wrapper_->processing()->StartDebugRecording(aec_dump_file_stream) !=
       webrtc::AudioProcessing::kNoError) {
     LOG_RTCERR0(StartDebugRecording);
     fclose(aec_dump_file_stream);
@@ -1037,8 +1035,8 @@
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   if (!is_dumping_aec_) {
     // Start dumping AEC when we are not dumping.
-    if (voe_wrapper_->base()->audio_processing()->StartDebugRecording(
-            filename.c_str(), -1) != webrtc::AudioProcessing::kNoError) {
+    if (voe_wrapper_->processing()->StartDebugRecording(
+        filename.c_str()) != webrtc::AudioProcessing::kNoError) {
       LOG_RTCERR1(StartDebugRecording, filename.c_str());
     } else {
       is_dumping_aec_ = true;
@@ -1050,7 +1048,7 @@
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   if (is_dumping_aec_) {
     // Stop dumping AEC when we are dumping.
-    if (voe_wrapper_->base()->audio_processing()->StopDebugRecording() !=
+    if (voe_wrapper_->processing()->StopDebugRecording() !=
         webrtc::AudioProcessing::kNoError) {
       LOG_RTCERR0(StopDebugRecording);
     }
diff --git a/talk/media/webrtc/webrtcvoiceengine.h b/talk/media/webrtc/webrtcvoiceengine.h
index ce3bdf3..0f2f59e 100644
--- a/talk/media/webrtc/webrtcvoiceengine.h
+++ b/talk/media/webrtc/webrtcvoiceengine.h
@@ -94,11 +94,8 @@
   // Set the external ADM. This can only be called before Init.
   bool SetAudioDeviceModule(webrtc::AudioDeviceModule* adm);
 
-  // Starts AEC dump using an existing file. A maximum file size in bytes can be
-  // specified. When the maximum file size is reached, logging is stopped and
-  // the file is closed. If max_size_bytes is set to <= 0, no limit will be
-  // used.
-  bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes);
+  // Starts AEC dump using existing file.
+  bool StartAecDump(rtc::PlatformFile file);
 
   // Stops AEC dump.
   void StopAecDump();
diff --git a/talk/session/media/channelmanager.cc b/talk/session/media/channelmanager.cc
index bd89a41..e7a4b8b 100644
--- a/talk/session/media/channelmanager.cc
+++ b/talk/session/media/channelmanager.cc
@@ -550,11 +550,9 @@
   }
 }
 
-bool ChannelManager::StartAecDump(rtc::PlatformFile file,
-                                  int64_t max_size_bytes) {
-  return worker_thread_->Invoke<bool>(Bind(&MediaEngineInterface::StartAecDump,
-                                           media_engine_.get(), file,
-                                           max_size_bytes));
+bool ChannelManager::StartAecDump(rtc::PlatformFile file) {
+  return worker_thread_->Invoke<bool>(
+      Bind(&MediaEngineInterface::StartAecDump, media_engine_.get(), file));
 }
 
 void ChannelManager::StopAecDump() {
diff --git a/talk/session/media/channelmanager.h b/talk/session/media/channelmanager.h
index f69bf9a..2bc516b 100644
--- a/talk/session/media/channelmanager.h
+++ b/talk/session/media/channelmanager.h
@@ -162,10 +162,8 @@
 
   // The operations below occur on the main thread.
 
-  // Starts AEC dump using existing file, with a specified maximum file size in
-  // bytes. When the limit is reached, logging will stop and the file will be
-  // closed. If max_size_bytes is set to <= 0, no limit will be used.
-  bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes);
+  // Starts AEC dump using existing file.
+  bool StartAecDump(rtc::PlatformFile file);
 
   // Stops recording AEC dump.
   void StopAecDump();
diff --git a/webrtc/examples/androidapp/src/org/appspot/apprtc/PeerConnectionClient.java b/webrtc/examples/androidapp/src/org/appspot/apprtc/PeerConnectionClient.java
index ce607e9..523c0e0 100644
--- a/webrtc/examples/androidapp/src/org/appspot/apprtc/PeerConnectionClient.java
+++ b/webrtc/examples/androidapp/src/org/appspot/apprtc/PeerConnectionClient.java
@@ -496,7 +496,7 @@
                 ParcelFileDescriptor.MODE_READ_WRITE |
                 ParcelFileDescriptor.MODE_CREATE |
                 ParcelFileDescriptor.MODE_TRUNCATE);
-        factory.startAecDump(aecDumpFileDescriptor.getFd(), -1);
+        factory.startAecDump(aecDumpFileDescriptor.getFd());
       } catch(IOException e) {
         Log.e(TAG, "Can not open aecdump file", e);
       }
diff --git a/webrtc/modules/audio_processing/audio_processing_impl.cc b/webrtc/modules/audio_processing/audio_processing_impl.cc
index b79b4f0..a332945 100644
--- a/webrtc/modules/audio_processing/audio_processing_impl.cc
+++ b/webrtc/modules/audio_processing/audio_processing_impl.cc
@@ -632,7 +632,6 @@
     for (int i = 0; i < formats_.api_format.output_stream().num_channels(); ++i)
       msg->add_output_channel(dest[i], channel_size);
     RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                          &debug_dump_.num_bytes_left_for_log_,
                                           &crit_debug_, &debug_dump_.capture));
   }
 #endif
@@ -720,7 +719,6 @@
         sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
     msg->set_output_data(frame->data_, data_size);
     RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                          &debug_dump_.num_bytes_left_for_log_,
                                           &crit_debug_, &debug_dump_.capture));
   }
 #endif
@@ -888,7 +886,6 @@
          i < formats_.api_format.reverse_input_stream().num_channels(); ++i)
       msg->add_channel(src[i], channel_size);
     RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                          &debug_dump_.num_bytes_left_for_log_,
                                           &crit_debug_, &debug_dump_.render));
   }
 #endif
@@ -957,7 +954,6 @@
         sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
     msg->set_data(frame->data_, data_size);
     RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                          &debug_dump_.num_bytes_left_for_log_,
                                           &crit_debug_, &debug_dump_.render));
   }
 #endif
@@ -1043,8 +1039,7 @@
 }
 
 int AudioProcessingImpl::StartDebugRecording(
-    const char filename[AudioProcessing::kMaxFilenameSize],
-    int64_t max_log_size_bytes) {
+    const char filename[AudioProcessing::kMaxFilenameSize]) {
   // Run in a single-threaded manner.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
@@ -1055,7 +1050,6 @@
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  debug_dump_.num_bytes_left_for_log_ = max_log_size_bytes;
   // Stop any ongoing recording.
   if (debug_dump_.debug_file->Open()) {
     if (debug_dump_.debug_file->CloseFile() == -1) {
@@ -1076,8 +1070,7 @@
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
-int AudioProcessingImpl::StartDebugRecording(FILE* handle,
-                                             int64_t max_log_size_bytes) {
+int AudioProcessingImpl::StartDebugRecording(FILE* handle) {
   // Run in a single-threaded manner.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
@@ -1087,8 +1080,6 @@
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  debug_dump_.num_bytes_left_for_log_ = max_log_size_bytes;
-
   // Stop any ongoing recording.
   if (debug_dump_.debug_file->Open()) {
     if (debug_dump_.debug_file->CloseFile() == -1) {
@@ -1114,7 +1105,7 @@
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
   FILE* stream = rtc::FdopenPlatformFileForWriting(handle);
-  return StartDebugRecording(stream, -1);
+  return StartDebugRecording(stream);
 }
 
 int AudioProcessingImpl::StopDebugRecording() {
@@ -1409,7 +1400,6 @@
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 int AudioProcessingImpl::WriteMessageToDebugFile(
     FileWrapper* debug_file,
-    int64_t* filesize_limit_bytes,
     rtc::CriticalSection* crit_debug,
     ApmDebugDumpThreadState* debug_state) {
   int32_t size = debug_state->event_msg->ByteSize();
@@ -1427,19 +1417,7 @@
 
   {
     // Ensure atomic writes of the message.
-    rtc::CritScope cs_debug(crit_debug);
-
-    RTC_DCHECK(debug_file->Open());
-    // Update the byte counter.
-    if (*filesize_limit_bytes >= 0) {
-      *filesize_limit_bytes -=
-          (sizeof(int32_t) + debug_state->event_str.length());
-      if (*filesize_limit_bytes < 0) {
-        // Not enough bytes are left to write this message, so stop logging.
-        debug_file->CloseFile();
-        return kNoError;
-      }
-    }
+    rtc::CritScope cs_capture(crit_debug);
     // Write message preceded by its size.
     if (!debug_file->Write(&size, sizeof(int32_t))) {
       return kFileError;
@@ -1474,7 +1452,6 @@
   // debug_dump_.capture.event_msg.
 
   RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                        &debug_dump_.num_bytes_left_for_log_,
                                         &crit_debug_, &debug_dump_.capture));
   return kNoError;
 }
@@ -1527,7 +1504,6 @@
   debug_dump_.capture.event_msg->mutable_config()->CopyFrom(config);
 
   RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
-                                        &debug_dump_.num_bytes_left_for_log_,
                                         &crit_debug_, &debug_dump_.capture));
   return kNoError;
 }
diff --git a/webrtc/modules/audio_processing/audio_processing_impl.h b/webrtc/modules/audio_processing/audio_processing_impl.h
index b720bbf..3506ac4 100644
--- a/webrtc/modules/audio_processing/audio_processing_impl.h
+++ b/webrtc/modules/audio_processing/audio_processing_impl.h
@@ -57,9 +57,8 @@
   int Initialize(const ProcessingConfig& processing_config) override;
   void SetExtraOptions(const Config& config) override;
   void UpdateHistogramsOnCallEnd() override;
-  int StartDebugRecording(const char filename[kMaxFilenameSize],
-                          int64_t max_log_size_bytes) override;
-  int StartDebugRecording(FILE* handle, int64_t max_log_size_bytes) override;
+  int StartDebugRecording(const char filename[kMaxFilenameSize]) override;
+  int StartDebugRecording(FILE* handle) override;
   int StartDebugRecordingForPlatformFile(rtc::PlatformFile handle) override;
   int StopDebugRecording() override;
 
@@ -144,9 +143,6 @@
 
   struct ApmDebugDumpState {
     ApmDebugDumpState() : debug_file(FileWrapper::Create()) {}
-    // Number of bytes that can still be written to the log before the maximum
-    // size is reached. A value of <= 0 indicates that no limit is used.
-    int64_t num_bytes_left_for_log_ = -1;
     rtc::scoped_ptr<FileWrapper> debug_file;
     ApmDebugDumpThreadState render;
     ApmDebugDumpThreadState capture;
@@ -225,7 +221,6 @@
   // TODO(andrew): make this more graceful. Ideally we would split this stuff
   // out into a separate class with an "enabled" and "disabled" implementation.
   static int WriteMessageToDebugFile(FileWrapper* debug_file,
-                                     int64_t* filesize_limit_bytes,
                                      rtc::CriticalSection* crit_debug,
                                      ApmDebugDumpThreadState* debug_state);
   int WriteInitMessage() EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
diff --git a/webrtc/modules/audio_processing/include/audio_processing.h b/webrtc/modules/audio_processing/include/audio_processing.h
index c96f23a..5fcc4d4 100644
--- a/webrtc/modules/audio_processing/include/audio_processing.h
+++ b/webrtc/modules/audio_processing/include/audio_processing.h
@@ -408,22 +408,13 @@
   // Starts recording debugging information to a file specified by |filename|,
   // a NULL-terminated string. If there is an ongoing recording, the old file
   // will be closed, and recording will continue in the newly specified file.
-  // An already existing file will be overwritten without warning. A maximum
-  // file size (in bytes) for the log can be specified. The logging is stopped
-  // once the limit has been reached. If max_log_size_bytes is set to a value
-  // <= 0, no limit will be used.
+  // An already existing file will be overwritten without warning.
   static const size_t kMaxFilenameSize = 1024;
-  virtual int StartDebugRecording(const char filename[kMaxFilenameSize],
-                                  int64_t max_log_size_bytes) = 0;
+  virtual int StartDebugRecording(const char filename[kMaxFilenameSize]) = 0;
 
   // Same as above but uses an existing file handle. Takes ownership
   // of |handle| and closes it at StopDebugRecording().
-  virtual int StartDebugRecording(FILE* handle, int64_t max_log_size_bytes) = 0;
-
-  // TODO(ivoc): Remove this function after Chromium switches to the one above.
-  virtual int StartDebugRecording(FILE* handle) {
-    return StartDebugRecording(handle, -1);
-  }
+  virtual int StartDebugRecording(FILE* handle) = 0;
 
   // Same as above but uses an existing PlatformFile handle. Takes ownership
   // of |handle| and closes it at StopDebugRecording().
diff --git a/webrtc/modules/audio_processing/include/mock_audio_processing.h b/webrtc/modules/audio_processing/include/mock_audio_processing.h
index 3aea406..4ff52ba 100644
--- a/webrtc/modules/audio_processing/include/mock_audio_processing.h
+++ b/webrtc/modules/audio_processing/include/mock_audio_processing.h
@@ -250,11 +250,10 @@
       void(int offset));
   MOCK_CONST_METHOD0(delay_offset_ms,
       int());
-  MOCK_METHOD2(StartDebugRecording,
-               int(const char filename[kMaxFilenameSize],
-                   int64_t max_log_size_bytes));
-  MOCK_METHOD2(StartDebugRecording,
-               int(FILE* handle, int64_t max_log_size_bytes));
+  MOCK_METHOD1(StartDebugRecording,
+      int(const char filename[kMaxFilenameSize]));
+  MOCK_METHOD1(StartDebugRecording,
+      int(FILE* handle));
   MOCK_METHOD0(StopDebugRecording,
       int());
   MOCK_METHOD0(UpdateHistogramsOnCallEnd, void());
diff --git a/webrtc/modules/audio_processing/test/audio_processing_unittest.cc b/webrtc/modules/audio_processing/test/audio_processing_unittest.cc
index b6b94f0..eff791d 100644
--- a/webrtc/modules/audio_processing/test/audio_processing_unittest.cc
+++ b/webrtc/modules/audio_processing/test/audio_processing_unittest.cc
@@ -388,8 +388,7 @@
   int AnalyzeReverseStreamChooser(Format format);
   void ProcessDebugDump(const std::string& in_filename,
                         const std::string& out_filename,
-                        Format format,
-                        int max_size_bytes);
+                        Format format);
   void VerifyDebugDumpTest(Format format);
 
   const std::string output_path_;
@@ -1712,8 +1711,7 @@
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 void ApmTest::ProcessDebugDump(const std::string& in_filename,
                                const std::string& out_filename,
-                               Format format,
-                               int max_size_bytes) {
+                               Format format) {
   FILE* in_file = fopen(in_filename.c_str(), "rb");
   ASSERT_TRUE(in_file != NULL);
   audioproc::Event event_msg;
@@ -1741,8 +1739,7 @@
       if (first_init) {
         // StartDebugRecording() writes an additional init message. Don't start
         // recording until after the first init to avoid the extra message.
-        EXPECT_NOERR(
-            apm_->StartDebugRecording(out_filename.c_str(), max_size_bytes));
+        EXPECT_NOERR(apm_->StartDebugRecording(out_filename.c_str()));
         first_init = false;
       }
 
@@ -1815,54 +1812,34 @@
       test::OutputPath(), std::string("ref") + format_string + "_aecdump");
   const std::string out_filename = test::TempFilename(
       test::OutputPath(), std::string("out") + format_string + "_aecdump");
-  const std::string limited_filename = test::TempFilename(
-      test::OutputPath(), std::string("limited") + format_string + "_aecdump");
-  const size_t logging_limit_bytes = 100000;
-  // We expect at least this many bytes in the created logfile.
-  const size_t logging_expected_bytes = 95000;
   EnableAllComponents();
-  ProcessDebugDump(in_filename, ref_filename, format, -1);
-  ProcessDebugDump(ref_filename, out_filename, format, -1);
-  ProcessDebugDump(ref_filename, limited_filename, format, logging_limit_bytes);
+  ProcessDebugDump(in_filename, ref_filename, format);
+  ProcessDebugDump(ref_filename, out_filename, format);
 
   FILE* ref_file = fopen(ref_filename.c_str(), "rb");
   FILE* out_file = fopen(out_filename.c_str(), "rb");
-  FILE* limited_file = fopen(limited_filename.c_str(), "rb");
   ASSERT_TRUE(ref_file != NULL);
   ASSERT_TRUE(out_file != NULL);
-  ASSERT_TRUE(limited_file != NULL);
   rtc::scoped_ptr<uint8_t[]> ref_bytes;
   rtc::scoped_ptr<uint8_t[]> out_bytes;
-  rtc::scoped_ptr<uint8_t[]> limited_bytes;
 
   size_t ref_size = ReadMessageBytesFromFile(ref_file, &ref_bytes);
   size_t out_size = ReadMessageBytesFromFile(out_file, &out_bytes);
-  size_t limited_size = ReadMessageBytesFromFile(limited_file, &limited_bytes);
   size_t bytes_read = 0;
-  size_t bytes_read_limited = 0;
   while (ref_size > 0 && out_size > 0) {
     bytes_read += ref_size;
-    bytes_read_limited += limited_size;
     EXPECT_EQ(ref_size, out_size);
-    EXPECT_GE(ref_size, limited_size);
     EXPECT_EQ(0, memcmp(ref_bytes.get(), out_bytes.get(), ref_size));
-    EXPECT_EQ(0, memcmp(ref_bytes.get(), limited_bytes.get(), limited_size));
     ref_size = ReadMessageBytesFromFile(ref_file, &ref_bytes);
     out_size = ReadMessageBytesFromFile(out_file, &out_bytes);
-    limited_size = ReadMessageBytesFromFile(limited_file, &limited_bytes);
   }
   EXPECT_GT(bytes_read, 0u);
-  EXPECT_GT(bytes_read_limited, logging_expected_bytes);
-  EXPECT_LE(bytes_read_limited, logging_limit_bytes);
   EXPECT_NE(0, feof(ref_file));
   EXPECT_NE(0, feof(out_file));
-  EXPECT_NE(0, feof(limited_file));
   ASSERT_EQ(0, fclose(ref_file));
   ASSERT_EQ(0, fclose(out_file));
-  ASSERT_EQ(0, fclose(limited_file));
   remove(ref_filename.c_str());
   remove(out_filename.c_str());
-  remove(limited_filename.c_str());
 }
 
 TEST_F(ApmTest, VerifyDebugDumpInt) {
@@ -1879,13 +1856,13 @@
   const std::string filename =
       test::TempFilename(test::OutputPath(), "debug_aec");
   EXPECT_EQ(apm_->kNullPointerError,
-            apm_->StartDebugRecording(static_cast<const char*>(NULL), -1));
+            apm_->StartDebugRecording(static_cast<const char*>(NULL)));
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // Stopping without having started should be OK.
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
-  EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(filename.c_str(), -1));
+  EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(filename.c_str()));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_EQ(apm_->kNoError, apm_->AnalyzeReverseStream(revframe_));
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
@@ -1899,7 +1876,7 @@
   ASSERT_EQ(0, remove(filename.c_str()));
 #else
   EXPECT_EQ(apm_->kUnsupportedFunctionError,
-            apm_->StartDebugRecording(filename.c_str(), -1));
+            apm_->StartDebugRecording(filename.c_str()));
   EXPECT_EQ(apm_->kUnsupportedFunctionError, apm_->StopDebugRecording());
 
   // Verify the file has NOT been written.
@@ -1910,7 +1887,7 @@
 // TODO(andrew): expand test to verify output.
 TEST_F(ApmTest, DebugDumpFromFileHandle) {
   FILE* fid = NULL;
-  EXPECT_EQ(apm_->kNullPointerError, apm_->StartDebugRecording(fid, -1));
+  EXPECT_EQ(apm_->kNullPointerError, apm_->StartDebugRecording(fid));
   const std::string filename =
       test::TempFilename(test::OutputPath(), "debug_aec");
   fid = fopen(filename.c_str(), "w");
@@ -1920,7 +1897,7 @@
   // Stopping without having started should be OK.
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
-  EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(fid, -1));
+  EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(fid));
   EXPECT_EQ(apm_->kNoError, apm_->AnalyzeReverseStream(revframe_));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
@@ -1934,7 +1911,7 @@
   ASSERT_EQ(0, remove(filename.c_str()));
 #else
   EXPECT_EQ(apm_->kUnsupportedFunctionError,
-            apm_->StartDebugRecording(fid, -1));
+            apm_->StartDebugRecording(fid));
   EXPECT_EQ(apm_->kUnsupportedFunctionError, apm_->StopDebugRecording());
 
   ASSERT_EQ(0, fclose(fid));
diff --git a/webrtc/modules/audio_processing/test/debug_dump_test.cc b/webrtc/modules/audio_processing/test/debug_dump_test.cc
index 6aa310c..d2dd9c8 100644
--- a/webrtc/modules/audio_processing/test/debug_dump_test.cc
+++ b/webrtc/modules/audio_processing/test/debug_dump_test.cc
@@ -181,7 +181,7 @@
 }
 
 void DebugDumpGenerator::StartRecording() {
-  apm_->StartDebugRecording(dump_file_name_.c_str(), -1);
+  apm_->StartDebugRecording(dump_file_name_.c_str());
 }
 
 void DebugDumpGenerator::Process(size_t num_blocks) {
diff --git a/webrtc/modules/audio_processing/test/process_test.cc b/webrtc/modules/audio_processing/test/process_test.cc
index f54eab3..ae6b4dc 100644
--- a/webrtc/modules/audio_processing/test/process_test.cc
+++ b/webrtc/modules/audio_processing/test/process_test.cc
@@ -434,7 +434,7 @@
     } else if (strcmp(argv[i], "--debug_file") == 0) {
       i++;
       ASSERT_LT(i, argc) << "Specify filename after --debug_file";
-      ASSERT_EQ(apm->kNoError, apm->StartDebugRecording(argv[i], -1));
+      ASSERT_EQ(apm->kNoError, apm->StartDebugRecording(argv[i]));
     } else {
       FAIL() << "Unrecognized argument " << argv[i];
     }
diff --git a/webrtc/voice_engine/voe_audio_processing_impl.cc b/webrtc/voice_engine/voe_audio_processing_impl.cc
index 4479fe0..c957263 100644
--- a/webrtc/voice_engine/voe_audio_processing_impl.cc
+++ b/webrtc/voice_engine/voe_audio_processing_impl.cc
@@ -924,7 +924,7 @@
     return -1;
   }
 
-  return _shared->audio_processing()->StartDebugRecording(fileNameUTF8, -1);
+  return _shared->audio_processing()->StartDebugRecording(fileNameUTF8);
 }
 
 int VoEAudioProcessingImpl::StartDebugRecording(FILE* file_handle) {
@@ -935,7 +935,7 @@
     return -1;
   }
 
-  return _shared->audio_processing()->StartDebugRecording(file_handle, -1);
+  return _shared->audio_processing()->StartDebugRecording(file_handle);
 }
 
 int VoEAudioProcessingImpl::StopDebugRecording() {