diff --git a/webrtc/modules/video_coding/main/source/receiver.cc b/webrtc/modules/video_coding/main/source/receiver.cc
index 45aa3dca7..20d9821cd 100644
--- a/webrtc/modules/video_coding/main/source/receiver.cc
+++ b/webrtc/modules/video_coding/main/source/receiver.cc
@@ -149,7 +149,7 @@ VCMEncodedFrame* VCMReceiver::FrameForDecoding(
   }
 
   // We have a frame - Set timing and render timestamp.
-  timing_->SetRequiredDelay(jitter_buffer_.EstimatedJitterMs());
+  timing_->SetJitterDelay(jitter_buffer_.EstimatedJitterMs());
   const int64_t now_ms = clock_->TimeInMilliseconds();
   timing_->UpdateCurrentDelay(frame_timestamp);
   next_render_time_ms = timing_->RenderTimeMs(frame_timestamp, now_ms);
@@ -332,7 +332,7 @@ int VCMReceiver::SetMinReceiverDelay(int desired_delay_ms) {
   jitter_buffer_.SetMaxJitterEstimate(desired_delay_ms > 0);
   max_video_delay_ms_ = desired_delay_ms + kMaxVideoDelayMs;
   // Initializing timing to the desired delay.
-  timing_->SetMinimumTotalDelay(desired_delay_ms);
+  timing_->set_min_playout_delay(desired_delay_ms);
   return 0;
 }
 
@@ -347,7 +347,7 @@ int VCMReceiver::RenderBufferSizeMs() {
   }
   // Update timing.
   const int64_t now_ms = clock_->TimeInMilliseconds();
-  timing_->SetRequiredDelay(jitter_buffer_.EstimatedJitterMs());
+  timing_->SetJitterDelay(jitter_buffer_.EstimatedJitterMs());
   // Get render timestamps.
   uint32_t render_start = timing_->RenderTimeMs(timestamp_start, now_ms);
   uint32_t render_end = timing_->RenderTimeMs(timestamp_end, now_ms);
diff --git a/webrtc/modules/video_coding/main/source/timing.cc b/webrtc/modules/video_coding/main/source/timing.cc
index d69655236..9ad8481fc 100644
--- a/webrtc/modules/video_coding/main/source/timing.cc
+++ b/webrtc/modules/video_coding/main/source/timing.cc
@@ -33,8 +33,8 @@ VCMTiming::VCMTiming(Clock* clock,
       ts_extrapolator_(),
       codec_timer_(),
       render_delay_ms_(kDefaultRenderDelayMs),
-      min_total_delay_ms_(0),
-      required_delay_ms_(0),
+      min_playout_delay_ms_(0),
+      jitter_delay_ms_(0),
       current_delay_ms_(0),
       prev_frame_timestamp_(0) {
   if (master_timing == NULL) {
@@ -57,8 +57,8 @@ void VCMTiming::Reset() {
   ts_extrapolator_->Reset();
   codec_timer_.Reset();
   render_delay_ms_ = kDefaultRenderDelayMs;
-  min_total_delay_ms_ = 0;
-  required_delay_ms_ = 0;
+  min_playout_delay_ms_ = 0;
+  jitter_delay_ms_ = 0;
   current_delay_ms_ = 0;
   prev_frame_timestamp_ = 0;
 }
@@ -67,28 +67,28 @@ void VCMTiming::ResetDecodeTime() {
   codec_timer_.Reset();
 }
 
-void VCMTiming::SetRenderDelay(uint32_t render_delay_ms) {
+void VCMTiming::set_render_delay(uint32_t render_delay_ms) {
   CriticalSectionScoped cs(crit_sect_);
   render_delay_ms_ = render_delay_ms;
 }
 
-void VCMTiming::SetMinimumTotalDelay(uint32_t min_total_delay_ms) {
+void VCMTiming::set_min_playout_delay(uint32_t min_playout_delay_ms) {
   CriticalSectionScoped cs(crit_sect_);
-  min_total_delay_ms_ = min_total_delay_ms;
+  min_playout_delay_ms_ = min_playout_delay_ms;
 }
 
-void VCMTiming::SetRequiredDelay(uint32_t required_delay_ms) {
+void VCMTiming::SetJitterDelay(uint32_t jitter_delay_ms) {
   CriticalSectionScoped cs(crit_sect_);
-  if (required_delay_ms != required_delay_ms_) {
+  if (jitter_delay_ms != jitter_delay_ms_) {
     if (master_) {
       WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding,
           VCMId(vcm_id_, timing_id_),
-          "Desired jitter buffer level: %u ms", required_delay_ms);
+          "Desired jitter buffer level: %u ms", jitter_delay_ms);
     }
-    required_delay_ms_ = required_delay_ms;
+    jitter_delay_ms_ = jitter_delay_ms;
     // When in initial state, set current delay to minimum delay.
     if (current_delay_ms_ == 0) {
-      current_delay_ms_ = required_delay_ms_;
+      current_delay_ms_ = jitter_delay_ms_;
     }
   }
 }
@@ -180,9 +180,9 @@ int64_t VCMTiming::RenderTimeMs(uint32_t frame_timestamp, int64_t now_ms)
   if (master_) {
     WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding, VCMId(vcm_id_,
         timing_id_), "Render frame %u at %u. Render delay %u",
-        "required delay %u, max decode time %u, min total delay %u",
+        "jitter delay %u, max decode time %u, playout delay %u",
         frame_timestamp, MaskWord64ToUWord32(render_time_ms), render_delay_ms_,
-        required_delay_ms_, MaxDecodeTimeMs(), min_total_delay_ms_);
+        jitter_delay_ms_, MaxDecodeTimeMs(), min_playout_delay_ms_);
   }
   return render_time_ms;
 }
@@ -200,8 +200,8 @@ int64_t VCMTiming::RenderTimeMsInternal(uint32_t frame_timestamp,
     estimated_complete_time_ms = now_ms;
   }
 
-  // Make sure that we have at least the total minimum delay.
-  uint32_t actual_delay = std::max(current_delay_ms_, min_total_delay_ms_);
+  // Make sure that we have at least the playout delay.
+  uint32_t actual_delay = std::max(current_delay_ms_, min_playout_delay_ms_);
   return estimated_complete_time_ms + actual_delay;
 }
 
@@ -253,8 +253,8 @@ uint32_t VCMTiming::TargetVideoDelay() const {
 }
 
 uint32_t VCMTiming::TargetDelayInternal() const {
-  return std::max(min_total_delay_ms_,
-      required_delay_ms_ + MaxDecodeTimeMs() + render_delay_ms_);
+  return std::max(min_playout_delay_ms_,
+      jitter_delay_ms_ + MaxDecodeTimeMs() + render_delay_ms_);
 }
 
 }  // namespace webrtc
diff --git a/webrtc/modules/video_coding/main/source/timing.h b/webrtc/modules/video_coding/main/source/timing.h
index 068e03a0f..3148a7a3c 100644
--- a/webrtc/modules/video_coding/main/source/timing.h
+++ b/webrtc/modules/video_coding/main/source/timing.h
@@ -34,15 +34,15 @@ class VCMTiming {
   void Reset();
   void ResetDecodeTime();
 
-  // The amount of time needed to render an image. Defaults to 10 ms.
-  void SetRenderDelay(uint32_t render_delay_ms);
+  // Set the amount of time needed to render an image. Defaults to 10 ms.
+  void set_render_delay(uint32_t render_delay_ms);
 
-  // The minimum time the video must be delayed on the receiver to
+  // Set the minimum time the video must be delayed on the receiver to
   // get the desired jitter buffer level.
-  void SetRequiredDelay(uint32_t required_delay_ms);
+  void SetJitterDelay(uint32_t required_delay_ms);
 
-  // Minimum total delay required to sync video with audio.
-  void SetMinimumTotalDelay(uint32_t min_total_delay_ms);
+  // Set the minimum playout delay required to sync video with audio.
+  void set_min_playout_delay(uint32_t min_playout_delay);
 
   // Increases or decreases the current delay to get closer to the target delay.
   // Calculates how long it has been since the previous call to this function,
@@ -99,8 +99,8 @@ class VCMTiming {
   VCMTimestampExtrapolator* ts_extrapolator_;
   VCMCodecTimer codec_timer_;
   uint32_t render_delay_ms_;
-  uint32_t min_total_delay_ms_;
-  uint32_t required_delay_ms_;
+  uint32_t min_playout_delay_ms_;
+  uint32_t jitter_delay_ms_;
   uint32_t current_delay_ms_;
   uint32_t prev_frame_timestamp_;
 };
diff --git a/webrtc/modules/video_coding/main/source/timing_unittest.cc b/webrtc/modules/video_coding/main/source/timing_unittest.cc
index d6716908f..806aac855 100644
--- a/webrtc/modules/video_coding/main/source/timing_unittest.cc
+++ b/webrtc/modules/video_coding/main/source/timing_unittest.cc
@@ -39,9 +39,9 @@ TEST(ReceiverTiming, Tests) {
 
   timing.IncomingTimestamp(timeStamp, clock.TimeInMilliseconds());
   jitterDelayMs = 20;
-  timing.SetRequiredDelay(jitterDelayMs);
+  timing.SetJitterDelay(jitterDelayMs);
   timing.UpdateCurrentDelay(timeStamp);
-  timing.SetRenderDelay(0);
+  timing.set_render_delay(0);
   waitTime = timing.MaxWaitingTime(
       timing.RenderTimeMs(timeStamp, clock.TimeInMilliseconds()),
       clock.TimeInMilliseconds());
@@ -52,7 +52,7 @@ TEST(ReceiverTiming, Tests) {
   jitterDelayMs += VCMTiming::kDelayMaxChangeMsPerS + 10;
   timeStamp += 90000;
   clock.AdvanceTimeMilliseconds(1000);
-  timing.SetRequiredDelay(jitterDelayMs);
+  timing.SetJitterDelay(jitterDelayMs);
   timing.UpdateCurrentDelay(timeStamp);
   waitTime = timing.MaxWaitingTime(timing.RenderTimeMs(
       timeStamp, clock.TimeInMilliseconds()), clock.TimeInMilliseconds());
@@ -91,7 +91,7 @@ TEST(ReceiverTiming, Tests) {
     timing.IncomingTimestamp(timeStamp, clock.TimeInMilliseconds());
   }
   maxDecodeTimeMs = 10;
-  timing.SetRequiredDelay(jitterDelayMs);
+  timing.SetJitterDelay(jitterDelayMs);
   clock.AdvanceTimeMilliseconds(1000);
   timeStamp += 90000;
   timing.UpdateCurrentDelay(timeStamp);
@@ -101,12 +101,12 @@ TEST(ReceiverTiming, Tests) {
   EXPECT_EQ(waitTime, jitterDelayMs);
 
   uint32_t minTotalDelayMs = 200;
-  timing.SetMinimumTotalDelay(minTotalDelayMs);
+  timing.set_min_playout_delay(minTotalDelayMs);
   clock.AdvanceTimeMilliseconds(5000);
   timeStamp += 5*90000;
   timing.UpdateCurrentDelay(timeStamp);
   const int kRenderDelayMs = 10;
-  timing.SetRenderDelay(kRenderDelayMs);
+  timing.set_render_delay(kRenderDelayMs);
   waitTime = timing.MaxWaitingTime(
       timing.RenderTimeMs(timeStamp, clock.TimeInMilliseconds()),
       clock.TimeInMilliseconds());
@@ -116,8 +116,8 @@ TEST(ReceiverTiming, Tests) {
   // The total video delay should be equal to the min total delay.
   EXPECT_EQ(minTotalDelayMs, timing.TargetVideoDelay());
 
-  // Reset min total delay.
-  timing.SetMinimumTotalDelay(0);
+  // Reset playout delay.
+  timing.set_min_playout_delay(0);
   clock.AdvanceTimeMilliseconds(5000);
   timeStamp += 5*90000;
   timing.UpdateCurrentDelay(timeStamp);
diff --git a/webrtc/modules/video_coding/main/source/video_coding_impl.cc b/webrtc/modules/video_coding/main/source/video_coding_impl.cc
index 67dcb2cce..55e4288ff 100644
--- a/webrtc/modules/video_coding/main/source/video_coding_impl.cc
+++ b/webrtc/modules/video_coding/main/source/video_coding_impl.cc
@@ -1292,7 +1292,7 @@ VideoCodingModuleImpl::IncomingPacket(const uint8_t* incomingPayload,
 int32_t
 VideoCodingModuleImpl::SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs)
 {
-    _timing.SetMinimumTotalDelay(minPlayoutDelayMs);
+    _timing.set_min_playout_delay(minPlayoutDelayMs);
     return VCM_OK;
 }
 
@@ -1301,7 +1301,7 @@ VideoCodingModuleImpl::SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs)
 int32_t
 VideoCodingModuleImpl::SetRenderDelay(uint32_t timeMS)
 {
-    _timing.SetRenderDelay(timeMS);
+    _timing.set_render_delay(timeMS);
     return VCM_OK;
 }