diff --git a/webrtc/api/android/java/src/org/webrtc/VideoRenderer.java b/webrtc/api/android/java/src/org/webrtc/VideoRenderer.java
index 3a6a16771b..8ee4d27e7a 100644
--- a/webrtc/api/android/java/src/org/webrtc/VideoRenderer.java
+++ b/webrtc/api/android/java/src/org/webrtc/VideoRenderer.java
@@ -20,7 +20,7 @@ import java.nio.ByteBuffer;
  */
 public class VideoRenderer {
   /**
-   * Java version of webrtc::VideoFrame. Frames are only constructed from native code and test
+   * Java version of cricket::VideoFrame. Frames are only constructed from native code and test
    * code.
    */
   public static class I420Frame {
diff --git a/webrtc/api/android/jni/peerconnection_jni.cc b/webrtc/api/android/jni/peerconnection_jni.cc
index 7012fc355a..e76444e8f3 100644
--- a/webrtc/api/android/jni/peerconnection_jni.cc
+++ b/webrtc/api/android/jni/peerconnection_jni.cc
@@ -733,7 +733,7 @@ class StatsObserverWrapper : public StatsObserver {
 // Wrapper dispatching rtc::VideoSinkInterface to a Java VideoRenderer
 // instance.
 class JavaVideoRendererWrapper
-    : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+    : public rtc::VideoSinkInterface<cricket::VideoFrame> {
  public:
   JavaVideoRendererWrapper(JNIEnv* jni, jobject j_callbacks)
       : j_callbacks_(jni, j_callbacks),
@@ -753,7 +753,7 @@ class JavaVideoRendererWrapper
 
   virtual ~JavaVideoRendererWrapper() {}
 
-  void OnFrame(const webrtc::VideoFrame& video_frame) override {
+  void OnFrame(const cricket::VideoFrame& video_frame) override {
     ScopedLocalRefFrame local_ref_frame(jni());
     jobject j_frame =
         (video_frame.video_frame_buffer()->native_handle() != nullptr)
@@ -769,12 +769,13 @@ class JavaVideoRendererWrapper
   // Make a shallow copy of |frame| to be used with Java. The callee has
   // ownership of the frame, and the frame should be released with
   // VideoRenderer.releaseNativeFrame().
-  static jlong javaShallowCopy(const webrtc::VideoFrame* frame) {
-    return jlongFromPointer(new webrtc::VideoFrame(*frame));
+  static jlong javaShallowCopy(const cricket::VideoFrame* frame) {
+    return jlongFromPointer(new cricket::WebRtcVideoFrame(
+        frame->video_frame_buffer(), frame->rotation(), frame->timestamp_us()));
   }
 
   // Return a VideoRenderer.I420Frame referring to the data in |frame|.
-  jobject CricketToJavaI420Frame(const webrtc::VideoFrame* frame) {
+  jobject CricketToJavaI420Frame(const cricket::VideoFrame* frame) {
     jintArray strides = jni()->NewIntArray(3);
     jint* strides_array = jni()->GetIntArrayElements(strides, NULL);
     strides_array[0] = frame->video_frame_buffer()->StrideY();
@@ -805,7 +806,7 @@ class JavaVideoRendererWrapper
   }
 
   // Return a VideoRenderer.I420Frame referring texture object in |frame|.
-  jobject CricketToJavaTextureFrame(const webrtc::VideoFrame* frame) {
+  jobject CricketToJavaTextureFrame(const cricket::VideoFrame* frame) {
     NativeHandleImpl* handle = reinterpret_cast<NativeHandleImpl*>(
         frame->video_frame_buffer()->native_handle());
     jfloatArray sampling_matrix = handle->sampling_matrix.ToJava(jni());
@@ -950,7 +951,7 @@ JOW(void, VideoRenderer_freeWrappedVideoRenderer)(JNIEnv*, jclass, jlong j_p) {
 
 JOW(void, VideoRenderer_releaseNativeFrame)(
     JNIEnv* jni, jclass, jlong j_frame_ptr) {
-  delete reinterpret_cast<const webrtc::VideoFrame*>(j_frame_ptr);
+  delete reinterpret_cast<const cricket::VideoFrame*>(j_frame_ptr);
 }
 
 JOW(void, MediaStreamTrack_free)(JNIEnv*, jclass, jlong j_p) {
@@ -2122,7 +2123,7 @@ JOW(void, VideoTrack_nativeAddRenderer)(
   LOG(LS_INFO) << "VideoTrack::nativeAddRenderer";
   reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)
       ->AddOrUpdateSink(
-          reinterpret_cast<rtc::VideoSinkInterface<webrtc::VideoFrame>*>(
+          reinterpret_cast<rtc::VideoSinkInterface<cricket::VideoFrame>*>(
               j_renderer_pointer),
           rtc::VideoSinkWants());
 }
@@ -2132,7 +2133,7 @@ JOW(void, VideoTrack_nativeRemoveRenderer)(
     jlong j_video_track_pointer, jlong j_renderer_pointer) {
   reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)
       ->RemoveSink(
-          reinterpret_cast<rtc::VideoSinkInterface<webrtc::VideoFrame>*>(
+          reinterpret_cast<rtc::VideoSinkInterface<cricket::VideoFrame>*>(
               j_renderer_pointer));
 }
 
diff --git a/webrtc/api/androidvideotracksource.cc b/webrtc/api/androidvideotracksource.cc
index 947311a83e..9242e5faf9 100644
--- a/webrtc/api/androidvideotracksource.cc
+++ b/webrtc/api/androidvideotracksource.cc
@@ -95,8 +95,9 @@ void AndroidVideoTrackSource::OnByteBufferFrameCaptured(const void* frame_data,
       buffer->MutableDataU(), buffer->StrideU(),
       buffer->width(), buffer->height());
 
-  OnFrame(VideoFrame(buffer, static_cast<webrtc::VideoRotation>(rotation),
-                     translated_camera_time_us));
+  OnFrame(cricket::WebRtcVideoFrame(
+              buffer, static_cast<webrtc::VideoRotation>(rotation),
+              translated_camera_time_us));
 }
 
 void AndroidVideoTrackSource::OnTextureFrameCaptured(
@@ -146,13 +147,13 @@ void AndroidVideoTrackSource::OnTextureFrameCaptured(
     matrix.Rotate(static_cast<webrtc::VideoRotation>(rotation));
   }
 
-  OnFrame(VideoFrame(
-      surface_texture_helper_->CreateTextureFrame(
-          adapted_width, adapted_height,
-          webrtc_jni::NativeHandleImpl(handle.oes_texture_id, matrix)),
-      do_rotate ? webrtc::kVideoRotation_0
-                : static_cast<webrtc::VideoRotation>(rotation),
-      translated_camera_time_us));
+  OnFrame(cricket::WebRtcVideoFrame(
+              surface_texture_helper_->CreateTextureFrame(
+                  adapted_width, adapted_height,
+                  webrtc_jni::NativeHandleImpl(handle.oes_texture_id, matrix)),
+              do_rotate ? webrtc::kVideoRotation_0
+                        : static_cast<webrtc::VideoRotation>(rotation),
+              translated_camera_time_us));
 }
 
 void AndroidVideoTrackSource::OnOutputFormatRequest(int width,
diff --git a/webrtc/api/mediastreaminterface.h b/webrtc/api/mediastreaminterface.h
index baebad7b69..f813dda646 100644
--- a/webrtc/api/mediastreaminterface.h
+++ b/webrtc/api/mediastreaminterface.h
@@ -25,9 +25,9 @@
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/media/base/mediachannel.h"
+#include "webrtc/media/base/videoframe.h"
 #include "webrtc/media/base/videosinkinterface.h"
 #include "webrtc/media/base/videosourceinterface.h"
-#include "webrtc/video_frame.h"
 
 namespace webrtc {
 
@@ -98,7 +98,7 @@ class MediaStreamTrackInterface : public rtc::RefCountInterface,
 // The same source can be used in multiple VideoTracks.
 class VideoTrackSourceInterface
     : public MediaSourceInterface,
-      public rtc::VideoSourceInterface<VideoFrame> {
+      public rtc::VideoSourceInterface<cricket::VideoFrame> {
  public:
   struct Stats {
     // Original size of captured frame, before video adaptation.
@@ -131,12 +131,13 @@ class VideoTrackSourceInterface
 
 class VideoTrackInterface
     : public MediaStreamTrackInterface,
-      public rtc::VideoSourceInterface<VideoFrame> {
+      public rtc::VideoSourceInterface<cricket::VideoFrame> {
  public:
   // Register a video sink for this track.
-  void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
+  void AddOrUpdateSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override{};
-  void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override{};
+  void RemoveSink(
+      rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override{};
 
   virtual VideoTrackSourceInterface* GetSource() const = 0;
 
diff --git a/webrtc/api/mediastreamtrackproxy.h b/webrtc/api/mediastreamtrackproxy.h
index 206a467c80..12fdc36b36 100644
--- a/webrtc/api/mediastreamtrackproxy.h
+++ b/webrtc/api/mediastreamtrackproxy.h
@@ -42,10 +42,12 @@ BEGIN_PROXY_MAP(VideoTrack)
   PROXY_CONSTMETHOD0(bool, enabled)
   PROXY_METHOD1(bool, set_enabled, bool)
   PROXY_WORKER_METHOD2(void,
-                       AddOrUpdateSink,
-                       rtc::VideoSinkInterface<VideoFrame>*,
-                       const rtc::VideoSinkWants&)
-  PROXY_WORKER_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
+                AddOrUpdateSink,
+                rtc::VideoSinkInterface<cricket::VideoFrame>*,
+                const rtc::VideoSinkWants&)
+  PROXY_WORKER_METHOD1(void,
+                       RemoveSink,
+                       rtc::VideoSinkInterface<cricket::VideoFrame>*)
   PROXY_CONSTMETHOD0(VideoTrackSourceInterface*, GetSource)
 
   PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
diff --git a/webrtc/api/videocapturertracksource_unittest.cc b/webrtc/api/videocapturertracksource_unittest.cc
index a0350d999d..67c249827b 100644
--- a/webrtc/api/videocapturertracksource_unittest.cc
+++ b/webrtc/api/videocapturertracksource_unittest.cc
@@ -18,6 +18,7 @@
 #include "webrtc/media/base/fakemediaengine.h"
 #include "webrtc/media/base/fakevideocapturer.h"
 #include "webrtc/media/base/fakevideorenderer.h"
+#include "webrtc/media/engine/webrtcvideoframe.h"
 
 using webrtc::FakeConstraints;
 using webrtc::VideoCapturerTrackSource;
diff --git a/webrtc/api/videosourceproxy.h b/webrtc/api/videosourceproxy.h
index eaec17bbb1..0c181611ee 100644
--- a/webrtc/api/videosourceproxy.h
+++ b/webrtc/api/videosourceproxy.h
@@ -28,9 +28,11 @@ BEGIN_PROXY_MAP(VideoTrackSource)
   PROXY_METHOD1(bool, GetStats, Stats*)
   PROXY_WORKER_METHOD2(void,
                        AddOrUpdateSink,
-                       rtc::VideoSinkInterface<VideoFrame>*,
+                       rtc::VideoSinkInterface<cricket::VideoFrame>*,
                        const rtc::VideoSinkWants&)
-  PROXY_WORKER_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
+  PROXY_WORKER_METHOD1(void,
+                       RemoveSink,
+                       rtc::VideoSinkInterface<cricket::VideoFrame>*)
   PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
   PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*)
 END_PROXY()
diff --git a/webrtc/api/videotrack.cc b/webrtc/api/videotrack.cc
index b47a32044f..234b4cf7ae 100644
--- a/webrtc/api/videotrack.cc
+++ b/webrtc/api/videotrack.cc
@@ -34,8 +34,9 @@ std::string VideoTrack::kind() const {
 
 // AddOrUpdateSink and RemoveSink should be called on the worker
 // thread.
-void VideoTrack::AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
-                                 const rtc::VideoSinkWants& wants) {
+void VideoTrack::AddOrUpdateSink(
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
+    const rtc::VideoSinkWants& wants) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   VideoSourceBase::AddOrUpdateSink(sink, wants);
   rtc::VideoSinkWants modified_wants = wants;
@@ -43,7 +44,8 @@ void VideoTrack::AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
   video_source_->AddOrUpdateSink(sink, modified_wants);
 }
 
-void VideoTrack::RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
+void VideoTrack::RemoveSink(
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   VideoSourceBase::RemoveSink(sink);
   video_source_->RemoveSink(sink);
diff --git a/webrtc/api/videotrack.h b/webrtc/api/videotrack.h
index cbebec3e86..60a0a64aec 100644
--- a/webrtc/api/videotrack.h
+++ b/webrtc/api/videotrack.h
@@ -29,9 +29,9 @@ class VideoTrack : public MediaStreamTrack<VideoTrackInterface>,
       const std::string& label,
       VideoTrackSourceInterface* source);
 
-  void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
+  void AddOrUpdateSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override;
-  void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override;
+  void RemoveSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override;
 
   VideoTrackSourceInterface* GetSource() const override {
     return video_source_.get();
diff --git a/webrtc/api/videotrack_unittest.cc b/webrtc/api/videotrack_unittest.cc
index 53204827b2..0b67c77829 100644
--- a/webrtc/api/videotrack_unittest.cc
+++ b/webrtc/api/videotrack_unittest.cc
@@ -17,6 +17,7 @@
 #include "webrtc/base/gunit.h"
 #include "webrtc/media/base/fakevideocapturer.h"
 #include "webrtc/media/base/fakemediaengine.h"
+#include "webrtc/media/engine/webrtcvideoframe.h"
 
 using webrtc::FakeVideoTrackRenderer;
 using webrtc::MediaSourceInterface;
diff --git a/webrtc/api/videotracksource.cc b/webrtc/api/videotracksource.cc
index 83ae4932ff..17d32fbc71 100644
--- a/webrtc/api/videotracksource.cc
+++ b/webrtc/api/videotracksource.cc
@@ -15,7 +15,7 @@
 namespace webrtc {
 
 VideoTrackSource::VideoTrackSource(
-    rtc::VideoSourceInterface<VideoFrame>* source,
+    rtc::VideoSourceInterface<cricket::VideoFrame>* source,
     bool remote)
     : source_(source), state_(kInitializing), remote_(remote) {
   worker_thread_checker_.DetachFromThread();
@@ -33,7 +33,7 @@ void VideoTrackSource::OnSourceDestroyed() {
 }
 
 void VideoTrackSource::AddOrUpdateSink(
-    rtc::VideoSinkInterface<VideoFrame>* sink,
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
     const rtc::VideoSinkWants& wants) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   if (!source_) {
@@ -42,7 +42,8 @@ void VideoTrackSource::AddOrUpdateSink(
   source_->AddOrUpdateSink(sink, wants);
 }
 
-void VideoTrackSource::RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
+void VideoTrackSource::RemoveSink(
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   if (!source_) {
     return;
diff --git a/webrtc/api/videotracksource.h b/webrtc/api/videotracksource.h
index 330af2332e..67e764fd40 100644
--- a/webrtc/api/videotracksource.h
+++ b/webrtc/api/videotracksource.h
@@ -22,7 +22,8 @@ namespace webrtc {
 
 class VideoTrackSource : public Notifier<VideoTrackSourceInterface> {
  public:
-  VideoTrackSource(rtc::VideoSourceInterface<VideoFrame>* source, bool remote);
+  VideoTrackSource(rtc::VideoSourceInterface<cricket::VideoFrame>* source,
+                   bool remote);
   void SetState(SourceState new_state);
   // OnSourceDestroyed clears this instance pointer to |source_|. It is useful
   // when the underlying rtc::VideoSourceInterface is destroyed before the
@@ -38,13 +39,13 @@ class VideoTrackSource : public Notifier<VideoTrackSourceInterface> {
 
   bool GetStats(Stats* stats) override { return false; }
 
-  void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
+  void AddOrUpdateSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override;
-  void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override;
+  void RemoveSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override;
 
  private:
   rtc::ThreadChecker worker_thread_checker_;
-  rtc::VideoSourceInterface<VideoFrame>* source_;
+  rtc::VideoSourceInterface<cricket::VideoFrame>* source_;
   cricket::VideoOptions options_;
   SourceState state_;
   const bool remote_;
diff --git a/webrtc/examples/peerconnection/client/linux/main_wnd.cc b/webrtc/examples/peerconnection/client/linux/main_wnd.cc
index 8d7d11ac15..eda6617826 100644
--- a/webrtc/examples/peerconnection/client/linux/main_wnd.cc
+++ b/webrtc/examples/peerconnection/client/linux/main_wnd.cc
@@ -19,6 +19,7 @@
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringutils.h"
+#include "webrtc/media/engine/webrtcvideoframe.h"
 
 using rtc::sprintfn;
 
@@ -482,15 +483,18 @@ void GtkMainWnd::VideoRenderer::SetSize(int width, int height) {
 }
 
 void GtkMainWnd::VideoRenderer::OnFrame(
-    const webrtc::VideoFrame& video_frame) {
+    const cricket::VideoFrame& video_frame) {
   gdk_threads_enter();
 
-  rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
+  const cricket::WebRtcVideoFrame frame(
       webrtc::I420Buffer::Rotate(video_frame.video_frame_buffer(),
-                                 video_frame.rotation()));
+                                 video_frame.rotation()),
+      webrtc::kVideoRotation_0, video_frame.timestamp_us());
 
-  SetSize(buffer->width(), buffer->height());
+  SetSize(frame.width(), frame.height());
 
+  rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
+      frame.video_frame_buffer());
   libyuv::I420ToRGBA(buffer->DataY(), buffer->StrideY(),
                      buffer->DataU(), buffer->StrideU(),
                      buffer->DataV(), buffer->StrideV(),
diff --git a/webrtc/examples/peerconnection/client/linux/main_wnd.h b/webrtc/examples/peerconnection/client/linux/main_wnd.h
index 33b0725c08..3c718577d1 100644
--- a/webrtc/examples/peerconnection/client/linux/main_wnd.h
+++ b/webrtc/examples/peerconnection/client/linux/main_wnd.h
@@ -72,14 +72,14 @@ class GtkMainWnd : public MainWindow {
   void OnRedraw();
 
  protected:
-  class VideoRenderer : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+  class VideoRenderer : public rtc::VideoSinkInterface<cricket::VideoFrame> {
    public:
     VideoRenderer(GtkMainWnd* main_wnd,
                   webrtc::VideoTrackInterface* track_to_render);
     virtual ~VideoRenderer();
 
     // VideoSinkInterface implementation
-    void OnFrame(const webrtc::VideoFrame& frame) override;
+    void OnFrame(const cricket::VideoFrame& frame) override;
 
     const uint8_t* image() const { return image_.get(); }
 
diff --git a/webrtc/examples/peerconnection/client/main_wnd.cc b/webrtc/examples/peerconnection/client/main_wnd.cc
index 22a45b0445..7fe5132fa0 100644
--- a/webrtc/examples/peerconnection/client/main_wnd.cc
+++ b/webrtc/examples/peerconnection/client/main_wnd.cc
@@ -17,6 +17,7 @@
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/media/engine/webrtcvideoframe.h"
 
 ATOM MainWnd::wnd_class_ = 0;
 const wchar_t MainWnd::kClassName[] = L"WebRTC_MainWnd";
@@ -600,18 +601,21 @@ void MainWnd::VideoRenderer::SetSize(int width, int height) {
 }
 
 void MainWnd::VideoRenderer::OnFrame(
-    const webrtc::VideoFrame& video_frame) {
+    const cricket::VideoFrame& video_frame) {
 
   {
     AutoLock<VideoRenderer> lock(this);
 
-    rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
+    const cricket::WebRtcVideoFrame frame(
         webrtc::I420Buffer::Rotate(video_frame.video_frame_buffer(),
-                                   video_frame.rotation()));
+                                   video_frame.rotation()),
+        webrtc::kVideoRotation_0, video_frame.timestamp_us());
 
-    SetSize(buffer->width(), buffer->height());
+    SetSize(frame.width(), frame.height());
 
     ASSERT(image_.get() != NULL);
+    rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
+        frame.video_frame_buffer());
     libyuv::I420ToARGB(buffer->DataY(), buffer->StrideY(),
                        buffer->DataU(), buffer->StrideU(),
                        buffer->DataV(), buffer->StrideV(),
diff --git a/webrtc/examples/peerconnection/client/main_wnd.h b/webrtc/examples/peerconnection/client/main_wnd.h
index 543b7ce573..03db80d0b6 100644
--- a/webrtc/examples/peerconnection/client/main_wnd.h
+++ b/webrtc/examples/peerconnection/client/main_wnd.h
@@ -21,7 +21,7 @@
 #include "webrtc/examples/peerconnection/client/peer_connection_client.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/videocommon.h"
-#include "webrtc/video_frame.h"
+#include "webrtc/media/base/videoframe.h"
 
 class MainWndCallback {
  public:
@@ -102,7 +102,7 @@ class MainWnd : public MainWindow {
 
   HWND handle() const { return wnd_; }
 
-  class VideoRenderer : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+  class VideoRenderer : public rtc::VideoSinkInterface<cricket::VideoFrame> {
    public:
     VideoRenderer(HWND wnd, int width, int height,
                   webrtc::VideoTrackInterface* track_to_render);
@@ -117,7 +117,7 @@ class MainWnd : public MainWindow {
     }
 
     // VideoSinkInterface implementation
-    void OnFrame(const webrtc::VideoFrame& frame) override;
+    void OnFrame(const cricket::VideoFrame& frame) override;
 
     const BITMAPINFO& bmi() const { return bmi_; }
     const uint8_t* image() const { return image_.get(); }
diff --git a/webrtc/media/base/adaptedvideotracksource.cc b/webrtc/media/base/adaptedvideotracksource.cc
index acc147cc89..5f6144f708 100644
--- a/webrtc/media/base/adaptedvideotracksource.cc
+++ b/webrtc/media/base/adaptedvideotracksource.cc
@@ -27,7 +27,7 @@ bool AdaptedVideoTrackSource::GetStats(Stats* stats) {
   return true;
 }
 
-void AdaptedVideoTrackSource::OnFrame(const webrtc::VideoFrame& frame) {
+void AdaptedVideoTrackSource::OnFrame(const cricket::VideoFrame& frame) {
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
       frame.video_frame_buffer());
   /* Note that this is a "best effort" approach to
@@ -42,7 +42,7 @@ void AdaptedVideoTrackSource::OnFrame(const webrtc::VideoFrame& frame) {
       frame.rotation() != webrtc::kVideoRotation_0 &&
       !buffer->native_handle()) {
     /* Apply pending rotation. */
-    broadcaster_.OnFrame(webrtc::VideoFrame(
+    broadcaster_.OnFrame(cricket::WebRtcVideoFrame(
         webrtc::I420Buffer::Rotate(buffer, frame.rotation()),
         webrtc::kVideoRotation_0, frame.timestamp_us()));
   } else {
@@ -51,7 +51,7 @@ void AdaptedVideoTrackSource::OnFrame(const webrtc::VideoFrame& frame) {
 }
 
 void AdaptedVideoTrackSource::AddOrUpdateSink(
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
     const rtc::VideoSinkWants& wants) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
@@ -60,7 +60,7 @@ void AdaptedVideoTrackSource::AddOrUpdateSink(
 }
 
 void AdaptedVideoTrackSource::RemoveSink(
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   broadcaster_.RemoveSink(sink);
diff --git a/webrtc/media/base/adaptedvideotracksource.h b/webrtc/media/base/adaptedvideotracksource.h
index 5b420aeb9e..dad24db119 100644
--- a/webrtc/media/base/adaptedvideotracksource.h
+++ b/webrtc/media/base/adaptedvideotracksource.h
@@ -31,7 +31,7 @@ class AdaptedVideoTrackSource
   // Checks the apply_rotation() flag. If the frame needs rotation, and it is a
   // plain memory frame, it is rotated. Subclasses producing native frames must
   // handle apply_rotation() themselves.
-  void OnFrame(const webrtc::VideoFrame& frame);
+  void OnFrame(const cricket::VideoFrame& frame);
 
   // Reports the appropriate frame size after adaptation. Returns true
   // if a frame is wanted. Returns false if there are no interested
@@ -57,9 +57,9 @@ class AdaptedVideoTrackSource
 
  private:
   // Implements rtc::VideoSourceInterface.
-  void AddOrUpdateSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
+  void AddOrUpdateSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override;
-  void RemoveSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
+  void RemoveSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override;
 
   // Part of VideoTrackSourceInterface.
   bool GetStats(Stats* stats) override;
diff --git a/webrtc/media/base/fakemediaengine.h b/webrtc/media/base/fakemediaengine.h
index 130142accb..6470624061 100644
--- a/webrtc/media/base/fakemediaengine.h
+++ b/webrtc/media/base/fakemediaengine.h
@@ -509,8 +509,8 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
   const std::vector<VideoCodec>& codecs() const { return send_codecs(); }
   bool rendering() const { return playout(); }
   const VideoOptions& options() const { return options_; }
-  const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
-  sinks() const {
+  const std::map<uint32_t, rtc::VideoSinkInterface<VideoFrame>*>& sinks()
+      const {
     return sinks_;
   }
   int max_bps() const { return max_bps_; }
@@ -538,7 +538,7 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
     return true;
   }
   bool SetSink(uint32_t ssrc,
-               rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override {
+               rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override {
     if (ssrc != 0 && sinks_.find(ssrc) == sinks_.end()) {
       return false;
     }
@@ -556,7 +556,7 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
       uint32_t ssrc,
       bool enable,
       const VideoOptions* options,
-      rtc::VideoSourceInterface<webrtc::VideoFrame>* source) override {
+      rtc::VideoSourceInterface<cricket::VideoFrame>* source) override {
     if (!RtpHelper<VideoMediaChannel>::MuteStream(ssrc, !enable)) {
       return false;
     }
@@ -618,8 +618,8 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
   FakeVideoEngine* engine_;
   std::vector<VideoCodec> recv_codecs_;
   std::vector<VideoCodec> send_codecs_;
-  std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*> sinks_;
-  std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_;
+  std::map<uint32_t, rtc::VideoSinkInterface<VideoFrame>*> sinks_;
+  std::map<uint32_t, rtc::VideoSourceInterface<VideoFrame>*> sources_;
   VideoOptions options_;
   int max_bps_;
 };
diff --git a/webrtc/media/base/fakevideocapturer.h b/webrtc/media/base/fakevideocapturer.h
index f1d349792b..ba8f01eddb 100644
--- a/webrtc/media/base/fakevideocapturer.h
+++ b/webrtc/media/base/fakevideocapturer.h
@@ -19,7 +19,7 @@
 #include "webrtc/base/timeutils.h"
 #include "webrtc/media/base/videocapturer.h"
 #include "webrtc/media/base/videocommon.h"
-#include "webrtc/video_frame.h"
+#include "webrtc/media/base/videoframe.h"
 
 namespace cricket {
 
@@ -97,9 +97,8 @@ class FakeVideoCapturer : public cricket::VideoCapturer {
           webrtc::I420Buffer::Create(adapted_width, adapted_height));
       buffer->InitializeData();
 
-      OnFrame(webrtc::VideoFrame(
-                  buffer, rotation_,
-                  next_timestamp_ / rtc::kNumNanosecsPerMicrosec),
+      OnFrame(WebRtcVideoFrame(buffer, rotation_,
+                               next_timestamp_ / rtc::kNumNanosecsPerMicrosec),
               width, height);
     }
     next_timestamp_ += timestamp_interval;
diff --git a/webrtc/media/base/fakevideorenderer.h b/webrtc/media/base/fakevideorenderer.h
index a2e0d28e63..2c7904b7eb 100644
--- a/webrtc/media/base/fakevideorenderer.h
+++ b/webrtc/media/base/fakevideorenderer.h
@@ -12,13 +12,13 @@
 #define WEBRTC_MEDIA_BASE_FAKEVIDEORENDERER_H_
 
 #include "webrtc/base/logging.h"
+#include "webrtc/media/base/videoframe.h"
 #include "webrtc/media/base/videosinkinterface.h"
-#include "webrtc/video_frame.h"
 
 namespace cricket {
 
 // Faked video renderer that has a callback for actions on rendering.
-class FakeVideoRenderer : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+class FakeVideoRenderer : public rtc::VideoSinkInterface<cricket::VideoFrame> {
  public:
   FakeVideoRenderer()
       : errors_(0),
@@ -29,7 +29,7 @@ class FakeVideoRenderer : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
         num_rendered_frames_(0),
         black_frame_(false) {}
 
-  virtual void OnFrame(const webrtc::VideoFrame& frame) {
+  virtual void OnFrame(const VideoFrame& frame) {
     rtc::CritScope cs(&crit_);
     // TODO(zhurunz) Check with VP8 team to see if we can remove this
     // tolerance on Y values. Some unit tests produce Y values close
@@ -79,7 +79,7 @@ class FakeVideoRenderer : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
                                  uint8_t u_max,
                                  uint8_t v_min,
                                  uint8_t v_max,
-                                 const webrtc::VideoFrame* frame) {
+                                 const cricket::VideoFrame* frame) {
     if (!frame || !frame->video_frame_buffer()) {
       return false;
     }
diff --git a/webrtc/media/base/mediachannel.h b/webrtc/media/base/mediachannel.h
index 7286fd643e..b21919c94a 100644
--- a/webrtc/media/base/mediachannel.h
+++ b/webrtc/media/base/mediachannel.h
@@ -31,6 +31,9 @@
 #include "webrtc/media/base/codec.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/streamparams.h"
+// TODO(nisse): Temporarily; to be replaced with a forward declaration
+// of webrtc::VideoFrame when dependency on cricket::VideoFrame is deleted.
+#include "webrtc/media/base/videoframe.h"
 #include "webrtc/media/base/videosinkinterface.h"
 #include "webrtc/media/base/videosourceinterface.h"
 // TODO(juberti): re-evaluate this include
@@ -43,7 +46,6 @@ class Timing;
 
 namespace webrtc {
 class AudioSinkInterface;
-class VideoFrame;
 }
 
 namespace cricket {
@@ -1029,11 +1031,11 @@ class VideoMediaChannel : public MediaChannel {
       uint32_t ssrc,
       bool enable,
       const VideoOptions* options,
-      rtc::VideoSourceInterface<webrtc::VideoFrame>* source) = 0;
+      rtc::VideoSourceInterface<cricket::VideoFrame>* source) = 0;
   // Sets the sink object to be used for the specified stream.
   // If SSRC is 0, the renderer is used for the 'default' stream.
   virtual bool SetSink(uint32_t ssrc,
-                       rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) = 0;
+                       rtc::VideoSinkInterface<cricket::VideoFrame>* sink) = 0;
   // Gets quality stats for the channel.
   virtual bool GetStats(VideoMediaInfo* info) = 0;
 };
diff --git a/webrtc/media/base/testutils.cc b/webrtc/media/base/testutils.cc
index b1f520a929..321719d3e9 100644
--- a/webrtc/media/base/testutils.cc
+++ b/webrtc/media/base/testutils.cc
@@ -23,7 +23,7 @@
 #include "webrtc/base/testutils.h"
 #include "webrtc/media/base/rtpdump.h"
 #include "webrtc/media/base/videocapturer.h"
-#include "webrtc/video_frame.h"
+#include "webrtc/media/base/videoframe.h"
 
 namespace cricket {
 
@@ -230,7 +230,7 @@ void VideoCapturerListener::OnStateChange(VideoCapturer* capturer,
   last_capture_state_ = result;
 }
 
-void VideoCapturerListener::OnFrame(const webrtc::VideoFrame& frame) {
+void VideoCapturerListener::OnFrame(const VideoFrame& frame) {
   ++frame_count_;
   if (1 == frame_count_) {
     frame_width_ = frame.width();
diff --git a/webrtc/media/base/testutils.h b/webrtc/media/base/testutils.h
index 01a2a4f9c1..40034c0969 100644
--- a/webrtc/media/base/testutils.h
+++ b/webrtc/media/base/testutils.h
@@ -29,10 +29,6 @@ class ByteBufferWriter;
 class StreamInterface;
 }
 
-namespace webrtc {
-class VideoFrame;
-}
-
 namespace cricket {
 
 // Returns size of 420 image with rounding on chroma for odd sizes.
@@ -119,7 +115,7 @@ class RtpTestUtility {
 // Test helper for testing VideoCapturer implementations.
 class VideoCapturerListener
     : public sigslot::has_slots<>,
-      public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+      public rtc::VideoSinkInterface<cricket::VideoFrame> {
  public:
   explicit VideoCapturerListener(VideoCapturer* cap);
   ~VideoCapturerListener();
@@ -131,7 +127,7 @@ class VideoCapturerListener
   bool resolution_changed() const { return resolution_changed_; }
 
   void OnStateChange(VideoCapturer* capturer, CaptureState state);
-  void OnFrame(const webrtc::VideoFrame& frame) override;
+  void OnFrame(const VideoFrame& frame) override;
 
  private:
   VideoCapturer* capturer_;
diff --git a/webrtc/media/base/videoadapter_unittest.cc b/webrtc/media/base/videoadapter_unittest.cc
index 7f660ef37f..444ef54886 100644
--- a/webrtc/media/base/videoadapter_unittest.cc
+++ b/webrtc/media/base/videoadapter_unittest.cc
@@ -42,7 +42,7 @@ class VideoAdapterTest : public testing::Test {
 
  protected:
   class VideoCapturerListener
-      : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+      : public rtc::VideoSinkInterface<cricket::VideoFrame> {
    public:
     struct Stats {
       int captured_frames;
@@ -62,7 +62,7 @@ class VideoAdapterTest : public testing::Test {
           last_adapt_was_no_op_(false) {
     }
 
-    void OnFrame(const webrtc::VideoFrame& frame) {
+    void OnFrame(const cricket::VideoFrame& frame) {
       rtc::CritScope lock(&crit_);
       const int in_width = frame.width();
       const int in_height = frame.height();
diff --git a/webrtc/media/base/videobroadcaster.cc b/webrtc/media/base/videobroadcaster.cc
index 6d6ffa747c..653829639c 100644
--- a/webrtc/media/base/videobroadcaster.cc
+++ b/webrtc/media/base/videobroadcaster.cc
@@ -22,7 +22,7 @@ VideoBroadcaster::VideoBroadcaster() {
 }
 
 void VideoBroadcaster::AddOrUpdateSink(
-    VideoSinkInterface<webrtc::VideoFrame>* sink,
+    VideoSinkInterface<cricket::VideoFrame>* sink,
     const VideoSinkWants& wants) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(sink != nullptr);
@@ -32,7 +32,7 @@ void VideoBroadcaster::AddOrUpdateSink(
 }
 
 void VideoBroadcaster::RemoveSink(
-    VideoSinkInterface<webrtc::VideoFrame>* sink) {
+    VideoSinkInterface<cricket::VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(sink != nullptr);
   rtc::CritScope cs(&sinks_and_wants_lock_);
@@ -50,7 +50,7 @@ VideoSinkWants VideoBroadcaster::wants() const {
   return current_wants_;
 }
 
-void VideoBroadcaster::OnFrame(const webrtc::VideoFrame& frame) {
+void VideoBroadcaster::OnFrame(const cricket::VideoFrame& frame) {
   rtc::CritScope cs(&sinks_and_wants_lock_);
   for (auto& sink_pair : sink_pairs()) {
     if (sink_pair.wants.rotation_applied &&
@@ -63,7 +63,7 @@ void VideoBroadcaster::OnFrame(const webrtc::VideoFrame& frame) {
       continue;
     }
     if (sink_pair.wants.black_frames) {
-      sink_pair.sink->OnFrame(webrtc::VideoFrame(
+      sink_pair.sink->OnFrame(cricket::WebRtcVideoFrame(
           GetBlackFrameBuffer(frame.width(), frame.height()), frame.rotation(),
           frame.timestamp_us()));
     } else {
diff --git a/webrtc/media/base/videobroadcaster.h b/webrtc/media/base/videobroadcaster.h
index 9fae1d4024..1fcc9c3f35 100644
--- a/webrtc/media/base/videobroadcaster.h
+++ b/webrtc/media/base/videobroadcaster.h
@@ -17,9 +17,10 @@
 
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/thread_checker.h"
+#include "webrtc/media/base/videoframe.h"
 #include "webrtc/media/base/videosinkinterface.h"
 #include "webrtc/media/base/videosourcebase.h"
-#include "webrtc/video_frame.h"
+#include "webrtc/media/engine/webrtcvideoframe.h"
 
 namespace rtc {
 
@@ -30,12 +31,12 @@ namespace rtc {
 // Video frames can be broadcasted on any thread. I.e VideoBroadcaster::OnFrame
 // can be called on any thread.
 class VideoBroadcaster : public VideoSourceBase,
-                         public VideoSinkInterface<webrtc::VideoFrame> {
+                         public VideoSinkInterface<cricket::VideoFrame> {
  public:
   VideoBroadcaster();
-  void AddOrUpdateSink(VideoSinkInterface<webrtc::VideoFrame>* sink,
+  void AddOrUpdateSink(VideoSinkInterface<cricket::VideoFrame>* sink,
                        const VideoSinkWants& wants) override;
-  void RemoveSink(VideoSinkInterface<webrtc::VideoFrame>* sink) override;
+  void RemoveSink(VideoSinkInterface<cricket::VideoFrame>* sink) override;
 
   // Returns true if the next frame will be delivered to at least one sink.
   bool frame_wanted() const;
@@ -48,7 +49,7 @@ class VideoBroadcaster : public VideoSourceBase,
   // it will never receive a frame with pending rotation. Our caller
   // may pass in frames without precise synchronization with changes
   // to the VideoSinkWants.
-  void OnFrame(const webrtc::VideoFrame& frame) override;
+  void OnFrame(const cricket::VideoFrame& frame) override;
 
  protected:
   void UpdateWants() EXCLUSIVE_LOCKS_REQUIRED(sinks_and_wants_lock_);
diff --git a/webrtc/media/base/videobroadcaster_unittest.cc b/webrtc/media/base/videobroadcaster_unittest.cc
index 6a8c618bb6..593c8e5151 100644
--- a/webrtc/media/base/videobroadcaster_unittest.cc
+++ b/webrtc/media/base/videobroadcaster_unittest.cc
@@ -11,11 +11,12 @@
 #include "webrtc/base/gunit.h"
 #include "webrtc/media/base/fakevideorenderer.h"
 #include "webrtc/media/base/videobroadcaster.h"
-#include "webrtc/video_frame.h"
+#include "webrtc/media/engine/webrtcvideoframe.h"
 
 using rtc::VideoBroadcaster;
 using rtc::VideoSinkWants;
 using cricket::FakeVideoRenderer;
+using cricket::WebRtcVideoFrame;
 
 
 TEST(VideoBroadcasterTest, frame_wanted) {
@@ -38,7 +39,7 @@ TEST(VideoBroadcasterTest, OnFrame) {
   broadcaster.AddOrUpdateSink(&sink1, rtc::VideoSinkWants());
   broadcaster.AddOrUpdateSink(&sink2, rtc::VideoSinkWants());
 
-  webrtc::VideoFrame frame;
+  WebRtcVideoFrame frame;
 
   broadcaster.OnFrame(frame);
   EXPECT_EQ(1, sink1.num_rendered_frames());
@@ -138,8 +139,8 @@ TEST(VideoBroadcasterTest, SinkWantsBlackFrames) {
   // Makes it not all black.
   buffer->InitializeData();
 
-  webrtc::VideoFrame frame1(buffer, webrtc::kVideoRotation_0,
-                            10 /* timestamp_us */);
+  cricket::WebRtcVideoFrame frame1(buffer, webrtc::kVideoRotation_0,
+                                   10 /* timestamp_us */);
   broadcaster.OnFrame(frame1);
   EXPECT_TRUE(sink1.black_frame());
   EXPECT_EQ(10, sink1.timestamp_us());
@@ -152,8 +153,8 @@ TEST(VideoBroadcasterTest, SinkWantsBlackFrames) {
   wants2.black_frames = true;
   broadcaster.AddOrUpdateSink(&sink2, wants2);
 
-  webrtc::VideoFrame frame2(buffer, webrtc::kVideoRotation_0,
-                            30 /* timestamp_us */);
+  cricket::WebRtcVideoFrame frame2(buffer, webrtc::kVideoRotation_0,
+                                   30 /* timestamp_us */);
   broadcaster.OnFrame(frame2);
   EXPECT_FALSE(sink1.black_frame());
   EXPECT_EQ(30, sink1.timestamp_us());
diff --git a/webrtc/media/base/videocapturer.cc b/webrtc/media/base/videocapturer.cc
index e7d3e3a3d6..1d81d49eb8 100644
--- a/webrtc/media/base/videocapturer.cc
+++ b/webrtc/media/base/videocapturer.cc
@@ -18,7 +18,7 @@
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/systeminfo.h"
-#include "webrtc/video_frame.h"
+#include "webrtc/media/engine/webrtcvideoframe.h"
 
 namespace cricket {
 
@@ -132,14 +132,14 @@ bool VideoCapturer::GetInputSize(int* width, int* height) {
 }
 
 void VideoCapturer::RemoveSink(
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   broadcaster_.RemoveSink(sink);
   OnSinkWantsChanged(broadcaster_.wants());
 }
 
 void VideoCapturer::AddOrUpdateSink(
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
     const rtc::VideoSinkWants& wants) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   broadcaster_.AddOrUpdateSink(sink, wants);
@@ -196,7 +196,7 @@ bool VideoCapturer::AdaptFrame(int width,
   return true;
 }
 
-void VideoCapturer::OnFrame(const webrtc::VideoFrame& frame,
+void VideoCapturer::OnFrame(const VideoFrame& frame,
                             int orig_width,
                             int orig_height) {
   // For a child class which implements rotation itself, we should
@@ -215,7 +215,7 @@ void VideoCapturer::OnFrame(const webrtc::VideoFrame& frame,
       LOG(LS_WARNING) << "Native frame requiring rotation. Discarding.";
       return;
     }
-    broadcaster_.OnFrame(webrtc::VideoFrame(
+    broadcaster_.OnFrame(WebRtcVideoFrame(
         webrtc::I420Buffer::Rotate(buffer, frame.rotation()),
         webrtc::kVideoRotation_0, frame.timestamp_us()));
   } else {
diff --git a/webrtc/media/base/videocapturer.h b/webrtc/media/base/videocapturer.h
index 1f1da3a88c..909c838fa5 100644
--- a/webrtc/media/base/videocapturer.h
+++ b/webrtc/media/base/videocapturer.h
@@ -29,9 +29,6 @@
 #include "webrtc/media/base/videobroadcaster.h"
 #include "webrtc/media/base/videocommon.h"
 
-namespace webrtc {
-class VideoFrame;
-}
 
 namespace cricket {
 
@@ -72,7 +69,7 @@ enum CaptureState {
 //   thread safe.
 //
 class VideoCapturer : public sigslot::has_slots<>,
-                      public rtc::VideoSourceInterface<webrtc::VideoFrame> {
+                      public rtc::VideoSourceInterface<cricket::VideoFrame> {
  public:
   VideoCapturer();
 
@@ -172,9 +169,9 @@ class VideoCapturer : public sigslot::has_slots<>,
   bool GetInputSize(int* width, int* height);
 
   // Implements VideoSourceInterface
-  void AddOrUpdateSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
+  void AddOrUpdateSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override;
-  void RemoveSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
+  void RemoveSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override;
 
  protected:
   // OnSinkWantsChanged can be overridden to change the default behavior
@@ -213,9 +210,7 @@ class VideoCapturer : public sigslot::has_slots<>,
   // VideoFrame. OnFrame can be called directly by an implementation
   // that does not use SignalFrameCaptured or OnFrameCaptured. The
   // orig_width and orig_height are used only to produce stats.
-  void OnFrame(const webrtc::VideoFrame& frame,
-               int orig_width,
-               int orig_height);
+  void OnFrame(const VideoFrame& frame, int orig_width, int orig_height);
 
   VideoAdapter* video_adapter() { return &video_adapter_; }
 
diff --git a/webrtc/media/base/videosourcebase.cc b/webrtc/media/base/videosourcebase.cc
index 514072efda..d00ddfba2a 100644
--- a/webrtc/media/base/videosourcebase.cc
+++ b/webrtc/media/base/videosourcebase.cc
@@ -19,7 +19,7 @@ VideoSourceBase::VideoSourceBase() {
 }
 
 void VideoSourceBase::AddOrUpdateSink(
-    VideoSinkInterface<webrtc::VideoFrame>* sink,
+    VideoSinkInterface<cricket::VideoFrame>* sink,
     const VideoSinkWants& wants) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(sink != nullptr);
@@ -32,7 +32,8 @@ void VideoSourceBase::AddOrUpdateSink(
   }
 }
 
-void VideoSourceBase::RemoveSink(VideoSinkInterface<webrtc::VideoFrame>* sink) {
+void VideoSourceBase::RemoveSink(
+    VideoSinkInterface<cricket::VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(sink != nullptr);
   RTC_DCHECK(FindSinkPair(sink));
@@ -44,7 +45,7 @@ void VideoSourceBase::RemoveSink(VideoSinkInterface<webrtc::VideoFrame>* sink) {
 }
 
 VideoSourceBase::SinkPair* VideoSourceBase::FindSinkPair(
-    const VideoSinkInterface<webrtc::VideoFrame>* sink) {
+    const VideoSinkInterface<cricket::VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   auto sink_pair_it = std::find_if(
       sinks_.begin(), sinks_.end(),
diff --git a/webrtc/media/base/videosourcebase.h b/webrtc/media/base/videosourcebase.h
index 5ddef093b4..40d2fb3482 100644
--- a/webrtc/media/base/videosourcebase.h
+++ b/webrtc/media/base/videosourcebase.h
@@ -14,27 +14,28 @@
 #include <vector>
 
 #include "webrtc/base/thread_checker.h"
+#include "webrtc/media/base/videoframe.h"
 #include "webrtc/media/base/videosourceinterface.h"
-#include "webrtc/video_frame.h"
 
 namespace rtc {
 
 // VideoSourceBase is not thread safe.
-class VideoSourceBase : public VideoSourceInterface<webrtc::VideoFrame> {
+class VideoSourceBase : public VideoSourceInterface<cricket::VideoFrame> {
  public:
   VideoSourceBase();
-  void AddOrUpdateSink(VideoSinkInterface<webrtc::VideoFrame>* sink,
+  void AddOrUpdateSink(VideoSinkInterface<cricket::VideoFrame>* sink,
                        const VideoSinkWants& wants) override;
-  void RemoveSink(VideoSinkInterface<webrtc::VideoFrame>* sink) override;
+  void RemoveSink(VideoSinkInterface<cricket::VideoFrame>* sink) override;
 
  protected:
   struct SinkPair {
-    SinkPair(VideoSinkInterface<webrtc::VideoFrame>* sink, VideoSinkWants wants)
+    SinkPair(VideoSinkInterface<cricket::VideoFrame>* sink,
+             VideoSinkWants wants)
         : sink(sink), wants(wants) {}
-    VideoSinkInterface<webrtc::VideoFrame>* sink;
+    VideoSinkInterface<cricket::VideoFrame>* sink;
     VideoSinkWants wants;
   };
-  SinkPair* FindSinkPair(const VideoSinkInterface<webrtc::VideoFrame>* sink);
+  SinkPair* FindSinkPair(const VideoSinkInterface<cricket::VideoFrame>* sink);
 
   const std::vector<SinkPair>& sink_pairs() const { return sinks_; }
   ThreadChecker thread_checker_;
diff --git a/webrtc/media/devices/gtkvideorenderer.cc b/webrtc/media/devices/gtkvideorenderer.cc
index b88c391caf..91fa933e0d 100644
--- a/webrtc/media/devices/gtkvideorenderer.cc
+++ b/webrtc/media/devices/gtkvideorenderer.cc
@@ -11,13 +11,13 @@
 // Implementation of GtkVideoRenderer
 
 #include "webrtc/media/devices/gtkvideorenderer.h"
-#include "webrtc/video_frame.h"
 
 #include <gdk/gdk.h>
 #include <glib.h>
 #include <gtk/gtk.h>
 
 #include "libyuv/convert_argb.h"
+#include "webrtc/media/engine/webrtcvideoframe.h"
 
 namespace cricket {
 
@@ -80,21 +80,24 @@ bool GtkVideoRenderer::SetSize(int width, int height) {
   return true;
 }
 
-void GtkVideoRenderer::OnFrame(const webrtc::VideoFrame& video_frame) {
-  rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
+void GtkVideoRenderer::OnFrame(const VideoFrame& video_frame) {
+  const cricket::WebRtcVideoFrame frame(
       webrtc::I420Buffer::Rotate(video_frame.video_frame_buffer(),
-                                 video_frame.rotation()));
+                                 video_frame.rotation()),
+      webrtc::kVideoRotation_0, video_frame.timestamp_us());
 
   // Need to set size as the frame might be rotated.
-  if (!SetSize(buffer->width(), buffer->height())) {
+  if (!SetSize(frame.width(), frame.height())) {
     return;
   }
 
   // convert I420 frame to ABGR format, which is accepted by GTK
+  rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
+      frame.video_frame_buffer());
   libyuv::I420ToARGB(buffer->DataY(), buffer->StrideY(),
                      buffer->DataU(), buffer->StrideU(),
                      buffer->DataV(), buffer->StrideV(),
-                     image_.get(), buffer->width() * 4,
+                     image_.get(), frame.width() * 4,
                      buffer->width(), buffer->height());
 
   ScopedGdkLock lock;
@@ -108,11 +111,11 @@ void GtkVideoRenderer::OnFrame(const webrtc::VideoFrame& video_frame) {
                         draw_area_->style->fg_gc[GTK_STATE_NORMAL],
                         0,
                         0,
-                        buffer->width(),
-                        buffer->height(),
+                        frame.width(),
+                        frame.height(),
                         GDK_RGB_DITHER_MAX,
                         image_.get(),
-                        buffer->width() * 4);
+                        frame.width() * 4);
 
   // Run the Gtk main loop to refresh the window.
   Pump();
diff --git a/webrtc/media/devices/gtkvideorenderer.h b/webrtc/media/devices/gtkvideorenderer.h
index 63a3ea900b..7834f1bcf6 100644
--- a/webrtc/media/devices/gtkvideorenderer.h
+++ b/webrtc/media/devices/gtkvideorenderer.h
@@ -17,22 +17,22 @@
 #include <memory>
 
 #include "webrtc/base/basictypes.h"
+// TODO(nisse): Temporarily; to be replaced with a forward declaration
+// of webrtc::VideoFrame when dependency on cricket::VideoFrame is deleted.
+#include "webrtc/media/base/videoframe.h"
 #include "webrtc/media/base/videosinkinterface.h"
 
 typedef struct _GtkWidget GtkWidget;  // forward declaration, defined in gtk.h
-namespace webrtc {
-class VideoFrame;
-}
 
 namespace cricket {
 
-class GtkVideoRenderer : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+class GtkVideoRenderer : public rtc::VideoSinkInterface<VideoFrame> {
  public:
   GtkVideoRenderer(int x, int y);
   virtual ~GtkVideoRenderer();
 
   // Implementation of VideoSinkInterface.
-  void OnFrame(const webrtc::VideoFrame& frame) override;
+  void OnFrame(const VideoFrame& frame) override;
 
  private:
   bool SetSize(int width, int height);
diff --git a/webrtc/media/engine/webrtcvideocapturer.cc b/webrtc/media/engine/webrtcvideocapturer.cc
index 66b167e1cf..7fe47d92eb 100644
--- a/webrtc/media/engine/webrtcvideocapturer.cc
+++ b/webrtc/media/engine/webrtcvideocapturer.cc
@@ -18,6 +18,7 @@
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
+#include "webrtc/media/engine/webrtcvideoframe.h"
 
 #include "webrtc/base/win32.h"  // Need this to #include the impl files.
 #include "webrtc/modules/video_capture/video_capture_factory.h"
@@ -352,7 +353,10 @@ void WebRtcVideoCapturer::OnIncomingCapturedFrame(
                  << ". Expected format " << GetCaptureFormat()->ToString();
   }
 
-  OnFrame(sample, sample.width(), sample.height());
+  OnFrame(cricket::WebRtcVideoFrame(
+              sample.video_frame_buffer(), sample.rotation(),
+              sample.render_time_ms() * rtc::kNumMicrosecsPerMillisec),
+          sample.width(), sample.height());
 }
 
 void WebRtcVideoCapturer::OnCaptureDelayChanged(const int32_t id,
diff --git a/webrtc/media/engine/webrtcvideocapturer.h b/webrtc/media/engine/webrtcvideocapturer.h
index 08af7c9b7d..01defefdfe 100644
--- a/webrtc/media/engine/webrtcvideocapturer.h
+++ b/webrtc/media/engine/webrtcvideocapturer.h
@@ -21,6 +21,7 @@
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/media/base/device.h"
 #include "webrtc/media/base/videocapturer.h"
+#include "webrtc/media/engine/webrtcvideoframe.h"
 #include "webrtc/modules/video_capture/video_capture.h"
 
 namespace cricket {
diff --git a/webrtc/media/engine/webrtcvideoengine2.cc b/webrtc/media/engine/webrtcvideoengine2.cc
index 1a98db2883..d3e71a381f 100644
--- a/webrtc/media/engine/webrtcvideoengine2.cc
+++ b/webrtc/media/engine/webrtcvideoengine2.cc
@@ -520,14 +520,14 @@ UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
   return kDeliverPacket;
 }
 
-rtc::VideoSinkInterface<webrtc::VideoFrame>*
+rtc::VideoSinkInterface<VideoFrame>*
 DefaultUnsignalledSsrcHandler::GetDefaultSink() const {
   return default_sink_;
 }
 
 void DefaultUnsignalledSsrcHandler::SetDefaultSink(
     VideoMediaChannel* channel,
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
+    rtc::VideoSinkInterface<VideoFrame>* sink) {
   default_sink_ = sink;
   if (default_recv_ssrc_ != 0) {
     channel->SetSink(default_recv_ssrc_, default_sink_);
@@ -1062,7 +1062,7 @@ bool WebRtcVideoChannel2::SetVideoSend(
     uint32_t ssrc,
     bool enable,
     const VideoOptions* options,
-    rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
+    rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
   TRACE_EVENT0("webrtc", "SetVideoSend");
   RTC_DCHECK(ssrc != 0);
   LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable
@@ -1303,9 +1303,8 @@ bool WebRtcVideoChannel2::RemoveRecvStream(uint32_t ssrc) {
   return true;
 }
 
-bool WebRtcVideoChannel2::SetSink(
-    uint32_t ssrc,
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
+bool WebRtcVideoChannel2::SetSink(uint32_t ssrc,
+                                  rtc::VideoSinkInterface<VideoFrame>* sink) {
   LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " "
                << (sink ? "(ptr)" : "nullptr");
   if (ssrc == 0) {
@@ -1589,7 +1588,7 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::OnFrame(
-    const webrtc::VideoFrame& frame) {
+    const VideoFrame& frame) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::OnFrame");
   webrtc::VideoFrame video_frame(frame.video_frame_buffer(),
                                  frame.rotation(),
@@ -1628,7 +1627,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::OnFrame(
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend(
     bool enable,
     const VideoOptions* options,
-    rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
+    rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend");
   RTC_DCHECK_RUN_ON(&thread_checker_);
 
@@ -2384,7 +2383,7 @@ bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSink(
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
   rtc::CritScope crit(&sink_lock_);
   sink_ = sink;
 }
diff --git a/webrtc/media/engine/webrtcvideoengine2.h b/webrtc/media/engine/webrtcvideoengine2.h
index 416fc79d54..bc11425756 100644
--- a/webrtc/media/engine/webrtcvideoengine2.h
+++ b/webrtc/media/engine/webrtcvideoengine2.h
@@ -26,10 +26,10 @@
 #include "webrtc/media/base/videosourceinterface.h"
 #include "webrtc/call.h"
 #include "webrtc/media/base/mediaengine.h"
+#include "webrtc/media/base/videoframe.h"
 #include "webrtc/media/engine/webrtcvideodecoderfactory.h"
 #include "webrtc/media/engine/webrtcvideoencoderfactory.h"
 #include "webrtc/transport.h"
-#include "webrtc/video_frame.h"
 #include "webrtc/video_receive_stream.h"
 #include "webrtc/video_send_stream.h"
 
@@ -82,14 +82,14 @@ class DefaultUnsignalledSsrcHandler : public UnsignalledSsrcHandler {
   Action OnUnsignalledSsrc(WebRtcVideoChannel2* channel,
                            uint32_t ssrc) override;
 
-  rtc::VideoSinkInterface<webrtc::VideoFrame>* GetDefaultSink() const;
+  rtc::VideoSinkInterface<VideoFrame>* GetDefaultSink() const;
   void SetDefaultSink(VideoMediaChannel* channel,
-                      rtc::VideoSinkInterface<webrtc::VideoFrame>* sink);
+                      rtc::VideoSinkInterface<VideoFrame>* sink);
   virtual ~DefaultUnsignalledSsrcHandler() = default;
 
  private:
   uint32_t default_recv_ssrc_;
-  rtc::VideoSinkInterface<webrtc::VideoFrame>* default_sink_;
+  rtc::VideoSinkInterface<VideoFrame>* default_sink_;
 };
 
 // WebRtcVideoEngine2 is used for the new native WebRTC Video API (webrtc:1667).
@@ -156,14 +156,14 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
       uint32_t ssrc,
       bool enable,
       const VideoOptions* options,
-      rtc::VideoSourceInterface<webrtc::VideoFrame>* source) override;
+      rtc::VideoSourceInterface<cricket::VideoFrame>* source) override;
   bool AddSendStream(const StreamParams& sp) override;
   bool RemoveSendStream(uint32_t ssrc) override;
   bool AddRecvStream(const StreamParams& sp) override;
   bool AddRecvStream(const StreamParams& sp, bool default_stream);
   bool RemoveRecvStream(uint32_t ssrc) override;
   bool SetSink(uint32_t ssrc,
-               rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
+               rtc::VideoSinkInterface<VideoFrame>* sink) override;
   bool GetStats(VideoMediaInfo* info) override;
 
   void OnPacketReceived(rtc::CopyOnWriteBuffer* packet,
@@ -237,7 +237,7 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
   // Wrapper for the sender part, this is where the source is connected and
   // frames are then converted from cricket frames to webrtc frames.
   class WebRtcVideoSendStream
-      : public rtc::VideoSinkInterface<webrtc::VideoFrame>,
+      : public rtc::VideoSinkInterface<cricket::VideoFrame>,
         public rtc::VideoSourceInterface<webrtc::VideoFrame> {
    public:
     WebRtcVideoSendStream(
@@ -259,17 +259,18 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
 
     // Implements rtc::VideoSourceInterface<webrtc::VideoFrame>.
     // WebRtcVideoSendStream acts as a source to the webrtc::VideoSendStream
-    // in |stream_|.
+    // in |stream_|. The reason is that WebRtcVideoSendStream receives
+    // cricket::VideoFrames and forwards webrtc::VideoFrames to |source_|.
     // TODO(perkj, nisse): Refactor WebRtcVideoSendStream to directly connect
     // the camera input |source_|
     void AddOrUpdateSink(VideoSinkInterface<webrtc::VideoFrame>* sink,
                          const rtc::VideoSinkWants& wants) override;
     void RemoveSink(VideoSinkInterface<webrtc::VideoFrame>* sink) override;
 
-    void OnFrame(const webrtc::VideoFrame& frame) override;
+    void OnFrame(const cricket::VideoFrame& frame) override;
     bool SetVideoSend(bool mute,
                       const VideoOptions* options,
-                      rtc::VideoSourceInterface<webrtc::VideoFrame>* source);
+                      rtc::VideoSourceInterface<cricket::VideoFrame>* source);
 
     void SetSend(bool send);
 
@@ -346,7 +347,7 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
     const std::vector<SsrcGroup> ssrc_groups_ ACCESS_ON(&thread_checker_);
     webrtc::Call* const call_;
     const bool enable_cpu_overuse_detection_;
-    rtc::VideoSourceInterface<webrtc::VideoFrame>* source_
+    rtc::VideoSourceInterface<cricket::VideoFrame>* source_
         ACCESS_ON(&thread_checker_);
     WebRtcVideoEncoderFactory* const external_encoder_factory_
         ACCESS_ON(&thread_checker_);
@@ -376,7 +377,9 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
   };
 
   // Wrapper for the receiver part, contains configs etc. that are needed to
-  // reconstruct the underlying VideoReceiveStream.
+  // reconstruct the underlying VideoReceiveStream. Also serves as a wrapper
+  // between rtc::VideoSinkInterface<webrtc::VideoFrame> and
+  // rtc::VideoSinkInterface<cricket::VideoFrame>.
   class WebRtcVideoReceiveStream
       : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
    public:
@@ -404,7 +407,7 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
     void OnFrame(const webrtc::VideoFrame& frame) override;
     bool IsDefaultStream() const;
 
-    void SetSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink);
+    void SetSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink);
 
     VideoReceiverInfo GetVideoReceiverInfo(bool log_stats);
 
@@ -451,7 +454,7 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
     std::vector<AllocatedDecoder> allocated_decoders_;
 
     rtc::CriticalSection sink_lock_;
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink_ GUARDED_BY(sink_lock_);
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink_ GUARDED_BY(sink_lock_);
     // Expands remote RTP timestamps to int64_t to be able to estimate how long
     // the stream has been running.
     rtc::TimestampWrapAroundHandler timestamp_wraparound_handler_
diff --git a/webrtc/pc/channel.cc b/webrtc/pc/channel.cc
index 92945fd92b..d9eb9b6fac 100644
--- a/webrtc/pc/channel.cc
+++ b/webrtc/pc/channel.cc
@@ -1865,7 +1865,7 @@ VideoChannel::~VideoChannel() {
 }
 
 bool VideoChannel::SetSink(uint32_t ssrc,
-                           rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
+                           rtc::VideoSinkInterface<VideoFrame>* sink) {
   worker_thread()->Invoke<void>(
       RTC_FROM_HERE,
       Bind(&VideoMediaChannel::SetSink, media_channel(), ssrc, sink));
@@ -1876,7 +1876,7 @@ bool VideoChannel::SetVideoSend(
     uint32_t ssrc,
     bool mute,
     const VideoOptions* options,
-    rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
+    rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
   return InvokeOnWorker(RTC_FROM_HERE,
                         Bind(&VideoMediaChannel::SetVideoSend, media_channel(),
                              ssrc, mute, options, source));
diff --git a/webrtc/pc/channel.h b/webrtc/pc/channel.h
index 5d6588e981..45918ffca0 100644
--- a/webrtc/pc/channel.h
+++ b/webrtc/pc/channel.h
@@ -548,8 +548,7 @@ class VideoChannel : public BaseChannel {
     return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
   }
 
-  bool SetSink(uint32_t ssrc,
-               rtc::VideoSinkInterface<webrtc::VideoFrame>* sink);
+  bool SetSink(uint32_t ssrc, rtc::VideoSinkInterface<VideoFrame>* sink);
   // Get statistics about the current media session.
   bool GetStats(VideoMediaInfo* stats);
 
@@ -565,7 +564,7 @@ class VideoChannel : public BaseChannel {
   bool SetVideoSend(uint32_t ssrc,
                     bool enable,
                     const VideoOptions* options,
-                    rtc::VideoSourceInterface<webrtc::VideoFrame>* source);
+                    rtc::VideoSourceInterface<cricket::VideoFrame>* source);
   webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const;
   bool SetRtpSendParameters(uint32_t ssrc,
                             const webrtc::RtpParameters& parameters);
diff --git a/webrtc/sdk/objc/Framework/Classes/RTCVideoFrame+Private.h b/webrtc/sdk/objc/Framework/Classes/RTCVideoFrame+Private.h
index b47ee4b465..83ae21ba68 100644
--- a/webrtc/sdk/objc/Framework/Classes/RTCVideoFrame+Private.h
+++ b/webrtc/sdk/objc/Framework/Classes/RTCVideoFrame+Private.h
@@ -10,8 +10,8 @@
 
 #import "WebRTC/RTCVideoFrame.h"
 
-#include "webrtc/common_video/include/video_frame_buffer.h"
 #include "webrtc/common_video/rotation.h"
+#include "webrtc/media/base/videoframe.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
diff --git a/webrtc/sdk/objc/Framework/Classes/RTCVideoRendererAdapter+Private.h b/webrtc/sdk/objc/Framework/Classes/RTCVideoRendererAdapter+Private.h
index 0c6f0657e4..b413f7e3f6 100644
--- a/webrtc/sdk/objc/Framework/Classes/RTCVideoRendererAdapter+Private.h
+++ b/webrtc/sdk/objc/Framework/Classes/RTCVideoRendererAdapter+Private.h
@@ -31,7 +31,7 @@ NS_ASSUME_NONNULL_BEGIN
  * during construction. This pointer is unsafe and owned by this class.
  */
 @property(nonatomic, readonly)
-    rtc::VideoSinkInterface<webrtc::VideoFrame> *nativeVideoRenderer;
+    rtc::VideoSinkInterface<cricket::VideoFrame> *nativeVideoRenderer;
 
 /** Initialize an RTCVideoRendererAdapter with an RTCVideoRenderer. */
 - (instancetype)initWithNativeRenderer:(id<RTCVideoRenderer>)videoRenderer
diff --git a/webrtc/sdk/objc/Framework/Classes/RTCVideoRendererAdapter.mm b/webrtc/sdk/objc/Framework/Classes/RTCVideoRendererAdapter.mm
index 8bc01b1ce8..55d3917845 100644
--- a/webrtc/sdk/objc/Framework/Classes/RTCVideoRendererAdapter.mm
+++ b/webrtc/sdk/objc/Framework/Classes/RTCVideoRendererAdapter.mm
@@ -14,17 +14,19 @@
 
 #include <memory>
 
+#include "webrtc/media/engine/webrtcvideoframe.h"
+
 namespace webrtc {
 
 class VideoRendererAdapter
-    : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+    : public rtc::VideoSinkInterface<cricket::VideoFrame> {
  public:
   VideoRendererAdapter(RTCVideoRendererAdapter* adapter) {
     adapter_ = adapter;
     size_ = CGSizeZero;
   }
 
-  void OnFrame(const webrtc::VideoFrame& nativeVideoFrame) override {
+  void OnFrame(const cricket::VideoFrame& nativeVideoFrame) override {
     RTCVideoFrame* videoFrame = [[RTCVideoFrame alloc]
         initWithVideoBuffer:nativeVideoFrame.video_frame_buffer()
                    rotation:nativeVideoFrame.rotation()
@@ -62,7 +64,7 @@ class VideoRendererAdapter
   return self;
 }
 
-- (rtc::VideoSinkInterface<webrtc::VideoFrame> *)nativeVideoRenderer {
+- (rtc::VideoSinkInterface<cricket::VideoFrame> *)nativeVideoRenderer {
   return _adapter.get();
 }
 
diff --git a/webrtc/sdk/objc/Framework/Headers/WebRTC/RTCVideoFrame.h b/webrtc/sdk/objc/Framework/Headers/WebRTC/RTCVideoFrame.h
index bfad608897..ffbbbc6906 100644
--- a/webrtc/sdk/objc/Framework/Headers/WebRTC/RTCVideoFrame.h
+++ b/webrtc/sdk/objc/Framework/Headers/WebRTC/RTCVideoFrame.h
@@ -15,7 +15,7 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-// RTCVideoFrame is an ObjectiveC version of webrtc::VideoFrame.
+// RTCVideoFrame is an ObjectiveC version of cricket::VideoFrame.
 RTC_EXPORT
 @interface RTCVideoFrame : NSObject
 
diff --git a/webrtc/video_frame.h b/webrtc/video_frame.h
index 755cbce089..0569278897 100644
--- a/webrtc/video_frame.h
+++ b/webrtc/video_frame.h
@@ -20,6 +20,9 @@
 
 namespace webrtc {
 
+// TODO(nisse): This class duplicates cricket::VideoFrame. There's
+// ongoing work to merge the classes. See
+// https://bugs.chromium.org/p/webrtc/issues/detail?id=5682.
 class VideoFrame {
  public:
   // TODO(nisse): Deprecated. Using the default constructor violates the