diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 9c4752d..e217b12 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -222,13 +222,6 @@ component("cc") {
     "layers/ui_resource_layer.h",
     "layers/ui_resource_layer_impl.cc",
     "layers/ui_resource_layer_impl.h",
-    "layers/video_frame_provider.h",
-    "layers/video_frame_provider_client_impl.cc",
-    "layers/video_frame_provider_client_impl.h",
-    "layers/video_layer.cc",
-    "layers/video_layer.h",
-    "layers/video_layer_impl.cc",
-    "layers/video_layer_impl.h",
     "output/begin_frame_args.cc",
     "output/begin_frame_args.h",
     "output/bsp_tree.cc",
@@ -480,8 +473,6 @@ component("cc") {
     "resources/ui_resource_client.h",
     "resources/ui_resource_request.cc",
     "resources/ui_resource_request.h",
-    "resources/video_resource_updater.cc",
-    "resources/video_resource_updater.h",
     "resources/zero_copy_tile_task_worker_pool.cc",
     "resources/zero_copy_tile_task_worker_pool.h",
     "scheduler/begin_frame_source.cc",
@@ -623,8 +614,6 @@ source_set("test_support") {
     "test/fake_tile_manager_client.h",
     "test/fake_ui_resource_layer_tree_host_impl.cc",
     "test/fake_ui_resource_layer_tree_host_impl.h",
-    "test/fake_video_frame_provider.cc",
-    "test/fake_video_frame_provider.h",
     "test/geometry_test_utils.cc",
     "test/geometry_test_utils.h",
     "test/impl_side_painting_settings.h",
@@ -782,7 +771,6 @@ test("cc_unittests") {
     "layers/tiled_layer_unittest.cc",
     "layers/ui_resource_layer_impl_unittest.cc",
     "layers/ui_resource_layer_unittest.cc",
-    "layers/video_layer_impl_unittest.cc",
     "output/begin_frame_args_unittest.cc",
     "output/delegating_renderer_unittest.cc",
     "output/filter_operations_unittest.cc",
@@ -843,7 +831,6 @@ test("cc_unittests") {
     "trees/layer_tree_host_unittest_picture.cc",
     "trees/layer_tree_host_unittest_proxy.cc",
     "trees/layer_tree_host_unittest_scroll.cc",
-    "trees/layer_tree_host_unittest_video.cc",
     "trees/layer_tree_impl_unittest.cc",
     "trees/occlusion_tracker_unittest.cc",
     "trees/occlusion_unittest.cc",
diff --git a/cc/layers/video_frame_provider.h b/cc/layers/video_frame_provider.h
deleted file mode 100644
index 784d951..0000000
--- a/cc/layers/video_frame_provider.h
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CC_LAYERS_VIDEO_FRAME_PROVIDER_H_
-#define CC_LAYERS_VIDEO_FRAME_PROVIDER_H_
-
-#include "base/memory/ref_counted.h"
-
-namespace media {
-class VideoFrame;
-}
-
-namespace cc {
-
-// Threading notes: This class may be used in a multi threaded manner.
-// Specifically, the implementation may call GetCurrentFrame() or
-// PutCurrentFrame() from the compositor thread. If so, the caller is
-// responsible for making sure Client::DidReceiveFrame() and
-// Client::DidUpdateMatrix() are only called from this same thread.
-class VideoFrameProvider {
- public:
-  virtual ~VideoFrameProvider() {}
-
-  class Client {
-   public:
-    // Provider will call this method to tell the client to stop using it.
-    // StopUsingProvider() may be called from any thread. The client should
-    // block until it has PutCurrentFrame() any outstanding frames.
-    virtual void StopUsingProvider() = 0;
-
-    // Notifies the provider's client that a call to GetCurrentFrame() will
-    // return new data.
-    virtual void DidReceiveFrame() = 0;
-
-    // Notifies the provider's client of a new UV transform matrix to be used.
-    virtual void DidUpdateMatrix(const float* matrix) = 0;
-
-   protected:
-    virtual ~Client() {}
-  };
-
-  // May be called from any thread, but there must be some external guarantee
-  // that the provider is not destroyed before this call returns.
-  virtual void SetVideoFrameProviderClient(Client* client) = 0;
-
-  // This function places a lock on the current frame and returns a pointer to
-  // it. Calls to this method should always be followed with a call to
-  // PutCurrentFrame().
-  // Only the current provider client should call this function.
-  virtual scoped_refptr<media::VideoFrame> GetCurrentFrame() = 0;
-
-  // This function releases the lock on the video frame. It should always be
-  // called after GetCurrentFrame(). Frames passed into this method
-  // should no longer be referenced after the call is made. Only the current
-  // provider client should call this function.
-  virtual void PutCurrentFrame(
-      const scoped_refptr<media::VideoFrame>& frame) = 0;
-};
-
-}  // namespace cc
-
-#endif  // CC_LAYERS_VIDEO_FRAME_PROVIDER_H_
diff --git a/cc/layers/video_frame_provider_client_impl.cc b/cc/layers/video_frame_provider_client_impl.cc
deleted file mode 100644
index 4bbd92f..0000000
--- a/cc/layers/video_frame_provider_client_impl.cc
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "cc/layers/video_frame_provider_client_impl.h"
-
-#include "base/trace_event/trace_event.h"
-#include "cc/base/math_util.h"
-#include "cc/layers/video_layer_impl.h"
-#include "media/base/video_frame.h"
-
-namespace cc {
-
-// static
-scoped_refptr<VideoFrameProviderClientImpl>
-    VideoFrameProviderClientImpl::Create(
-        VideoFrameProvider* provider) {
-  return make_scoped_refptr(
-      new VideoFrameProviderClientImpl(provider));
-}
-
-VideoFrameProviderClientImpl::~VideoFrameProviderClientImpl() {}
-
-VideoFrameProviderClientImpl::VideoFrameProviderClientImpl(
-    VideoFrameProvider* provider)
-    : active_video_layer_(nullptr), provider_(provider) {
-  // This only happens during a commit on the compositor thread while the main
-  // thread is blocked. That makes this a thread-safe call to set the video
-  // frame provider client that does not require a lock. The same is true of
-  // the call to Stop().
-  provider_->SetVideoFrameProviderClient(this);
-
-  // This matrix is the default transformation for stream textures, and flips
-  // on the Y axis.
-  stream_texture_matrix_ = gfx::Transform(
-      1.0, 0.0, 0.0, 0.0,
-      0.0, -1.0, 0.0, 1.0,
-      0.0, 0.0, 1.0, 0.0,
-      0.0, 0.0, 0.0, 1.0);
-}
-
-void VideoFrameProviderClientImpl::SetActiveVideoLayer(
-    VideoLayerImpl* video_layer) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(video_layer);
-  active_video_layer_ = video_layer;
-}
-
-void VideoFrameProviderClientImpl::Stop() {
-  // It's called when the main thread is blocked, so lock isn't needed.
-  if (!provider_)
-    return;
-  DCHECK(thread_checker_.CalledOnValidThread());
-  provider_->SetVideoFrameProviderClient(nullptr);
-  provider_ = nullptr;
-}
-
-bool VideoFrameProviderClientImpl::Stopped() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  // |provider_| is changed while the main thread is blocked, and not changed
-  // thereafter, so lock isn't needed.
-  return !provider_;
-}
-
-scoped_refptr<media::VideoFrame>
-VideoFrameProviderClientImpl::AcquireLockAndCurrentFrame() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  provider_lock_.Acquire();  // Balanced by call to ReleaseLock().
-  if (!provider_)
-    return nullptr;
-
-  return provider_->GetCurrentFrame();
-}
-
-void VideoFrameProviderClientImpl::PutCurrentFrame(
-    const scoped_refptr<media::VideoFrame>& frame) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  provider_lock_.AssertAcquired();
-  provider_->PutCurrentFrame(frame);
-}
-
-void VideoFrameProviderClientImpl::ReleaseLock() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  provider_lock_.AssertAcquired();
-  provider_lock_.Release();
-}
-
-void VideoFrameProviderClientImpl::StopUsingProvider() {
-  // Block the provider from shutting down until this client is done
-  // using the frame.
-  base::AutoLock locker(provider_lock_);
-  provider_ = nullptr;
-}
-
-void VideoFrameProviderClientImpl::DidReceiveFrame() {
-  TRACE_EVENT1("cc",
-               "VideoFrameProviderClientImpl::DidReceiveFrame",
-               "active_video_layer",
-               !!active_video_layer_);
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (active_video_layer_)
-    active_video_layer_->SetNeedsRedraw();
-}
-
-void VideoFrameProviderClientImpl::DidUpdateMatrix(const float* matrix) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  stream_texture_matrix_ = gfx::Transform(
-      matrix[0], matrix[4], matrix[8], matrix[12],
-      matrix[1], matrix[5], matrix[9], matrix[13],
-      matrix[2], matrix[6], matrix[10], matrix[14],
-      matrix[3], matrix[7], matrix[11], matrix[15]);
-  if (active_video_layer_)
-    active_video_layer_->SetNeedsRedraw();
-}
-
-}  // namespace cc
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 2016447..578faa9 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -13,7 +13,6 @@
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
-#include "cc/layers/video_layer_impl.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/context_provider.h"
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index b30b0a5..81ad842 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -12,7 +12,6 @@
 #include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/pixel_test.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
-#include "media/base/video_frame.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkMatrix.h"
@@ -388,453 +387,6 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) {
       FuzzyPixelOffByOneComparator(true)));
 }

-class VideoGLRendererPixelTest : public GLRendererPixelTest {
- protected:
-  void CreateTestYUVVideoDrawQuad_Striped(const SharedQuadState* shared_state,
-                                          media::VideoFrame::Format format,
-                                          bool is_transparent,
-                                          const gfx::RectF& tex_coord_rect,
-                                          RenderPass* render_pass) {
-    const gfx::Rect rect(this->device_viewport_size_);
-
-    scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::CreateFrame(
-            format, rect.size(), rect, rect.size(), base::TimeDelta());
-
-    // YUV values representing a striped pattern, for validating texture
-    // coordinates for sampling.
-    uint8_t y_value = 0;
-    uint8_t u_value = 0;
-    uint8_t v_value = 0;
-    for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) {
-      uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) +
-                       video_frame->stride(media::VideoFrame::kYPlane) * i;
-      for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane);
-           ++j) {
-        y_row[j] = (y_value += 1);
-      }
-    }
-    for (int i = 0; i < video_frame->rows(media::VideoFrame::kUPlane); ++i) {
-      uint8_t* u_row = video_frame->data(media::VideoFrame::kUPlane) +
-                       video_frame->stride(media::VideoFrame::kUPlane) * i;
-      uint8_t* v_row = video_frame->data(media::VideoFrame::kVPlane) +
-                       video_frame->stride(media::VideoFrame::kVPlane) * i;
-      for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kUPlane);
-           ++j) {
-        u_row[j] = (u_value += 3);
-        v_row[j] = (v_value += 5);
-      }
-    }
-    uint8 alpha_value = is_transparent ? 0 : 128;
-    CreateTestYUVVideoDrawQuad_FromVideoFrame(
-        shared_state, video_frame, alpha_value, tex_coord_rect, render_pass);
-  }
-
-  void CreateTestYUVVideoDrawQuad_Solid(const SharedQuadState* shared_state,
-                                        media::VideoFrame::Format format,
-                                        bool is_transparent,
-                                        const gfx::RectF& tex_coord_rect,
-                                        uint8 y,
-                                        uint8 u,
-                                        uint8 v,
-                                        RenderPass* render_pass) {
-    const gfx::Rect rect(this->device_viewport_size_);
-
-    scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::CreateFrame(
-            format, rect.size(), rect, rect.size(), base::TimeDelta());
-
-    // YUV values of a solid, constant, color. Useful for testing that color
-    // space/color range are being handled properly.
-    memset(video_frame->data(media::VideoFrame::kYPlane),
-           y,
-           video_frame->stride(media::VideoFrame::kYPlane) *
-               video_frame->rows(media::VideoFrame::kYPlane));
-    memset(video_frame->data(media::VideoFrame::kUPlane),
-           u,
-           video_frame->stride(media::VideoFrame::kUPlane) *
-               video_frame->rows(media::VideoFrame::kUPlane));
-    memset(video_frame->data(media::VideoFrame::kVPlane),
-           v,
-           video_frame->stride(media::VideoFrame::kVPlane) *
-               video_frame->rows(media::VideoFrame::kVPlane));
-
-    uint8 alpha_value = is_transparent ? 0 : 128;
-    CreateTestYUVVideoDrawQuad_FromVideoFrame(
-        shared_state, video_frame, alpha_value, tex_coord_rect, render_pass);
-  }
-
-  void CreateEdgeBleedPass(media::VideoFrame::Format format,
-                           RenderPassList* pass_list) {
-    gfx::Rect rect(200, 200);
-
-    RenderPassId id(1, 1);
-    scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
-
-    // Scale the video up so that bilinear filtering kicks in to sample more
-    // than just nearest neighbor would.
-    gfx::Transform scale_by_2;
-    scale_by_2.Scale(2.f, 2.f);
-    gfx::Rect half_rect(100, 100);
-    SharedQuadState* shared_state =
-        CreateTestSharedQuadState(scale_by_2, half_rect, pass.get());
-
-    gfx::Size background_size(200, 200);
-    gfx::Rect green_rect(16, 20, 100, 100);
-    gfx::RectF tex_coord_rect(
-        static_cast<float>(green_rect.x()) / background_size.width(),
-        static_cast<float>(green_rect.y()) / background_size.height(),
-        static_cast<float>(green_rect.width()) / background_size.width(),
-        static_cast<float>(green_rect.height()) / background_size.height());
-
-    // YUV of (149,43,21) should be green (0,255,0) in RGB.
-    // Create a video frame that has a non-green background rect, with a
-    // green sub-rectangle that should be the only thing displayed in
-    // the final image.  Bleeding will appear on all four sides of the video
-    // if the tex coords are not clamped.
-    CreateTestYUVVideoDrawQuad_TwoColor(shared_state, format, false,
-                                        tex_coord_rect, background_size, 0, 0,
-                                        0, green_rect, 149, 43, 21, pass.get());
-    pass_list->push_back(pass.Pass());
-  }
-
-  // Creates a video frame of size background_size filled with yuv_background,
-  // and then draws a foreground rectangle in a different color on top of
-  // that. The foreground rectangle must have coordinates that are divisible
-  // by 2 because YUV is a block format.
-  void CreateTestYUVVideoDrawQuad_TwoColor(const SharedQuadState* shared_state,
-                                           media::VideoFrame::Format format,
-                                           bool is_transparent,
-                                           const gfx::RectF& tex_coord_rect,
-                                           const gfx::Size& background_size,
-                                           uint8 y_background,
-                                           uint8 u_background,
-                                           uint8 v_background,
-                                           const gfx::Rect& foreground_rect,
-                                           uint8 y_foreground,
-                                           uint8 u_foreground,
-                                           uint8 v_foreground,
-                                           RenderPass* render_pass) {
-    const gfx::Rect rect(background_size);
-
-    scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::CreateFrame(format, background_size, foreground_rect,
-                                       foreground_rect.size(),
-                                       base::TimeDelta());
-
-    int planes[] = {media::VideoFrame::kYPlane,
-                    media::VideoFrame::kUPlane,
-                    media::VideoFrame::kVPlane};
-    uint8 yuv_background[] = {y_background, u_background, v_background};
-    uint8 yuv_foreground[] = {y_foreground, u_foreground, v_foreground};
-    int sample_size[] = {1, 2, 2};
-
-    for (int i = 0; i < 3; ++i) {
-      memset(video_frame->data(planes[i]), yuv_background[i],
-             video_frame->stride(planes[i]) * video_frame->rows(planes[i]));
-    }
-
-    for (int i = 0; i < 3; ++i) {
-      // Since yuv encoding uses block encoding, widths have to be divisible
-      // by the sample size in order for this function to behave properly.
-      DCHECK_EQ(foreground_rect.x() % sample_size[i], 0);
-      DCHECK_EQ(foreground_rect.y() % sample_size[i], 0);
-      DCHECK_EQ(foreground_rect.width() % sample_size[i], 0);
-      DCHECK_EQ(foreground_rect.height() % sample_size[i], 0);
-
-      gfx::Rect sample_rect(foreground_rect.x() / sample_size[i],
-                            foreground_rect.y() / sample_size[i],
-                            foreground_rect.width() / sample_size[i],
-                            foreground_rect.height() / sample_size[i]);
-      for (int y = sample_rect.y(); y < sample_rect.bottom(); ++y) {
-        for (int x = sample_rect.x(); x < sample_rect.right(); ++x) {
-          size_t offset = y * video_frame->stride(planes[i]) + x;
-          video_frame->data(planes[i])[offset] = yuv_foreground[i];
-        }
-      }
-    }
-
-    uint8 alpha_value = 255;
-    CreateTestYUVVideoDrawQuad_FromVideoFrame(
-        shared_state, video_frame, alpha_value, tex_coord_rect, render_pass);
-  }
-
-  void CreateTestYUVVideoDrawQuad_FromVideoFrame(
-      const SharedQuadState* shared_state,
-      scoped_refptr<media::VideoFrame> video_frame,
-      uint8 alpha_value,
-      const gfx::RectF& tex_coord_rect,
-      RenderPass* render_pass) {
-    const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A);
-    const YUVVideoDrawQuad::ColorSpace color_space =
-        (video_frame->format() == media::VideoFrame::YV12J
-             ? YUVVideoDrawQuad::JPEG
-             : YUVVideoDrawQuad::REC_601);
-    const gfx::Rect rect(shared_state->content_bounds);
-    const gfx::Rect opaque_rect(0, 0, 0, 0);
-
-    if (with_alpha)
-      memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value,
-             video_frame->stride(media::VideoFrame::kAPlane) *
-                 video_frame->rows(media::VideoFrame::kAPlane));
-
-    VideoFrameExternalResources resources =
-        video_resource_updater_->CreateExternalResourcesFromVideoFrame(
-            video_frame);
-
-    EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
-    EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
-              resources.mailboxes.size());
-    EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
-              resources.release_callbacks.size());
-
-    ResourceProvider::ResourceId y_resource =
-        resource_provider_->CreateResourceFromTextureMailbox(
-            resources.mailboxes[media::VideoFrame::kYPlane],
-            SingleReleaseCallbackImpl::Create(
-                resources.release_callbacks[media::VideoFrame::kYPlane]));
-    ResourceProvider::ResourceId u_resource =
-        resource_provider_->CreateResourceFromTextureMailbox(
-            resources.mailboxes[media::VideoFrame::kUPlane],
-            SingleReleaseCallbackImpl::Create(
-                resources.release_callbacks[media::VideoFrame::kUPlane]));
-    ResourceProvider::ResourceId v_resource =
-        resource_provider_->CreateResourceFromTextureMailbox(
-            resources.mailboxes[media::VideoFrame::kVPlane],
-            SingleReleaseCallbackImpl::Create(
-                resources.release_callbacks[media::VideoFrame::kVPlane]));
-    ResourceProvider::ResourceId a_resource = 0;
-    if (with_alpha) {
-      a_resource = resource_provider_->CreateResourceFromTextureMailbox(
-          resources.mailboxes[media::VideoFrame::kAPlane],
-          SingleReleaseCallbackImpl::Create(
-              resources.release_callbacks[media::VideoFrame::kAPlane]));
-    }
-
-    YUVVideoDrawQuad* yuv_quad =
-        render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
-    yuv_quad->SetNew(shared_state, rect, opaque_rect, rect, tex_coord_rect,
-                     video_frame->coded_size(), y_resource, u_resource,
-                     v_resource, a_resource, color_space);
-  }
-
-  void SetUp() override {
-    GLRendererPixelTest::SetUp();
-    video_resource_updater_.reset(new VideoResourceUpdater(
-        output_surface_->context_provider(), resource_provider_.get()));
-  }
-
- private:
-  scoped_ptr<VideoResourceUpdater> video_resource_updater_;
-};
-
-TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) {
-  gfx::Rect rect(this->device_viewport_size_);
-
-  RenderPassId id(1, 1);
-  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
-
-  SharedQuadState* shared_state =
-      CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
-
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::YV12,
-                                     false,
-                                     gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                     pass.get());
-
-  RenderPassList pass_list;
-  pass_list.push_back(pass.Pass());
-
-  EXPECT_TRUE(
-      this->RunPixelTest(&pass_list,
-                         base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")),
-                         FuzzyPixelOffByOneComparator(true)));
-}
-
-TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) {
-  gfx::Rect rect(this->device_viewport_size_);
-
-  RenderPassId id(1, 1);
-  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
-
-  SharedQuadState* shared_state =
-      CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
-
-  // Intentionally sets frame format to I420 for testing coverage.
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::I420,
-                                     false,
-                                     gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f),
-                                     pass.get());
-
-  RenderPassList pass_list;
-  pass_list.push_back(pass.Pass());
-
-  EXPECT_TRUE(this->RunPixelTest(
-      &pass_list,
-      base::FilePath(FILE_PATH_LITERAL("yuv_stripes_offset.png")),
-      FuzzyPixelOffByOneComparator(true)));
-}
-
-TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) {
-  gfx::Rect rect(this->device_viewport_size_);
-
-  RenderPassId id(1, 1);
-  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
-
-  SharedQuadState* shared_state =
-      CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
-
-  // In MPEG color range YUV values of (15,128,128) should produce black.
-  CreateTestYUVVideoDrawQuad_Solid(shared_state,
-                                   media::VideoFrame::YV12,
-                                   false,
-                                   gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                   15,
-                                   128,
-                                   128,
-                                   pass.get());
-
-  RenderPassList pass_list;
-  pass_list.push_back(pass.Pass());
-
-  // If we didn't get black out of the YUV values above, then we probably have a
-  // color range issue.
-  EXPECT_TRUE(this->RunPixelTest(&pass_list,
-                                 base::FilePath(FILE_PATH_LITERAL("black.png")),
-                                 FuzzyPixelOffByOneComparator(true)));
-}
-
-TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) {
-  gfx::Rect rect(this->device_viewport_size_);
-
-  RenderPassId id(1, 1);
-  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
-
-  SharedQuadState* shared_state =
-      CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
-
-  // YUV of (149,43,21) should be green (0,255,0) in RGB.
-  CreateTestYUVVideoDrawQuad_Solid(shared_state,
-                                   media::VideoFrame::YV12J,
-                                   false,
-                                   gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                   149,
-                                   43,
-                                   21,
-                                   pass.get());
-
-  RenderPassList pass_list;
-  pass_list.push_back(pass.Pass());
-
-  EXPECT_TRUE(this->RunPixelTest(&pass_list,
-                                 base::FilePath(FILE_PATH_LITERAL("green.png")),
-                                 FuzzyPixelOffByOneComparator(true)));
-}
-
-// Test that a YUV video doesn't bleed outside of its tex coords when the
-// tex coord rect is only a partial subrectangle of the coded contents.
-TEST_F(VideoGLRendererPixelTest, YUVEdgeBleed) {
-  RenderPassList pass_list;
-  CreateEdgeBleedPass(media::VideoFrame::YV12J, &pass_list);
-  EXPECT_TRUE(this->RunPixelTest(&pass_list,
-                                 base::FilePath(FILE_PATH_LITERAL("green.png")),
-                                 FuzzyPixelOffByOneComparator(true)));
-}
-
-TEST_F(VideoGLRendererPixelTest, YUVAEdgeBleed) {
-  RenderPassList pass_list;
-  CreateEdgeBleedPass(media::VideoFrame::YV12A, &pass_list);
-  EXPECT_TRUE(this->RunPixelTest(&pass_list,
-                                 base::FilePath(FILE_PATH_LITERAL("green.png")),
-                                 FuzzyPixelOffByOneComparator(true)));
-}
-
-TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) {
-  gfx::Rect rect(this->device_viewport_size_);
-
-  RenderPassId id(1, 1);
-  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
-
-  SharedQuadState* shared_state =
-      CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
-
-  // Dark grey in JPEG color range (in MPEG, this is black).
-  CreateTestYUVVideoDrawQuad_Solid(shared_state,
-                                   media::VideoFrame::YV12J,
-                                   false,
-                                   gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                   15,
-                                   128,
-                                   128,
-                                   pass.get());
-
-  RenderPassList pass_list;
-  pass_list.push_back(pass.Pass());
-
-  EXPECT_TRUE(
-      this->RunPixelTest(&pass_list,
-                         base::FilePath(FILE_PATH_LITERAL("dark_grey.png")),
-                         FuzzyPixelOffByOneComparator(true)));
-}
-
-TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) {
-  gfx::Rect rect(this->device_viewport_size_);
-
-  RenderPassId id(1, 1);
-  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
-
-  SharedQuadState* shared_state =
-      CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
-
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::YV12A,
-                                     false,
-                                     gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                     pass.get());
-
-  SolidColorDrawQuad* color_quad =
-      pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false);
-
-  RenderPassList pass_list;
-  pass_list.push_back(pass.Pass());
-
-  EXPECT_TRUE(this->RunPixelTest(
-      &pass_list,
-      base::FilePath(FILE_PATH_LITERAL("yuv_stripes_alpha.png")),
-      FuzzyPixelOffByOneComparator(true)));
-}
-
-TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) {
-  gfx::Rect rect(this->device_viewport_size_);
-
-  RenderPassId id(1, 1);
-  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
-
-  SharedQuadState* shared_state =
-      CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
-
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::YV12A,
-                                     true,
-                                     gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                     pass.get());
-
-  SolidColorDrawQuad* color_quad =
-      pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  color_quad->SetNew(shared_state, rect, rect, SK_ColorBLACK, false);
-
-  RenderPassList pass_list;
-  pass_list.push_back(pass.Pass());
-
-  EXPECT_TRUE(this->RunPixelTest(
-      &pass_list,
-      base::FilePath(FILE_PATH_LITERAL("black.png")),
-      ExactPixelComparator(true)));
-}
-
 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
   gfx::Rect viewport_rect(this->device_viewport_size_);

diff --git a/cc/quads/yuv_video_draw_quad.h b/cc/quads/yuv_video_draw_quad.h
index 358929e..15bce98 100644
--- a/cc/quads/yuv_video_draw_quad.h
+++ b/cc/quads/yuv_video_draw_quad.h
@@ -8,7 +8,6 @@
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
-#include "cc/layers/video_layer_impl.h"
 #include "cc/quads/draw_quad.h"

 namespace cc {
diff --git a/cc/resources/drawing_display_item.cc b/cc/resources/drawing_display_item.cc
index 648f9de..6dffad9 100644
--- a/cc/resources/drawing_display_item.cc
+++ b/cc/resources/drawing_display_item.cc
@@ -6,6 +6,7 @@

 #include <string>

+#include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/debug/picture_debug_util.h"
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 4b2bc75..7ffa683 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -27,7 +27,6 @@
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/layers/tiled_layer_impl.h"
-#include "cc/layers/video_layer_impl.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/compositor_frame_metadata.h"
@@ -47,7 +46,6 @@
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/fake_proxy.h"
-#include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/layer_tree_test.h"
@@ -57,7 +55,6 @@
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
-#include "media/base/media.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
@@ -71,7 +68,6 @@ using ::testing::Return;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::_;
-using media::VideoFrame;

 namespace cc {
 namespace {
@@ -96,7 +92,6 @@ class LayerTreeHostImplTest : public testing::Test,
         reduce_memory_result_(true),
         current_limit_bytes_(0),
         current_priority_cutoff_value_(0) {
-    media::InitializeMediaLibraryForTesting();
   }

   LayerTreeSettings DefaultSettings() {
@@ -5486,18 +5481,6 @@ TEST_F(LayerTreeHostImplTest, LayersFreeTextures) {
   root_layer->SetBounds(gfx::Size(10, 10));
   root_layer->SetHasRenderSurface(true);

-  scoped_refptr<VideoFrame> softwareFrame =
-      media::VideoFrame::CreateColorFrame(
-          gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
-  FakeVideoFrameProvider provider;
-  provider.set_frame(softwareFrame);
-  scoped_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
-      host_impl_->active_tree(), 4, &provider, media::VIDEO_ROTATION_0);
-  video_layer->SetBounds(gfx::Size(10, 10));
-  video_layer->SetContentBounds(gfx::Size(10, 10));
-  video_layer->SetDrawsContent(true);
-  root_layer->AddChild(video_layer.Pass());
-
   scoped_ptr<IOSurfaceLayerImpl> io_surface_layer =
       IOSurfaceLayerImpl::Create(host_impl_->active_tree(), 5);
   io_surface_layer->SetBounds(gfx::Size(10, 10));
@@ -6578,16 +6561,6 @@ TEST_F(LayerTreeHostImplTest,
   scoped_ptr<SolidColorLayerImpl> root_layer =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);

-  // VideoLayerImpl will not be drawn.
-  FakeVideoFrameProvider provider;
-  scoped_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
-      host_impl_->active_tree(), 2, &provider, media::VIDEO_ROTATION_0);
-  video_layer->SetBounds(gfx::Size(10, 10));
-  video_layer->SetContentBounds(gfx::Size(10, 10));
-  video_layer->SetDrawsContent(true);
-  root_layer->AddChild(video_layer.Pass());
-  SetupRootLayerImpl(root_layer.Pass());
-
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index c52132e..1be61a5 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -18,7 +18,6 @@
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_layer.h"
-#include "cc/layers/video_layer.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/copy_output_request.h"
@@ -41,7 +40,6 @@
 #include "cc/test/fake_picture_pile.h"
 #include "cc/test/fake_proxy.h"
 #include "cc/test/fake_scoped_ui_resource.h"
-#include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/impl_side_painting_settings.h"
 #include "cc/test/layer_tree_test.h"
@@ -4163,28 +4161,6 @@ class LayerInvalidateCausesDraw : public LayerTreeHostTest {
   int num_draws_;
 };

-// VideoLayer must support being invalidated and then passing that along
-// to the compositor thread, even though no resources are updated in
-// response to that invalidation.
-class LayerTreeHostTestVideoLayerInvalidate : public LayerInvalidateCausesDraw {
- public:
-  void SetupTree() override {
-    LayerTreeHostTest::SetupTree();
-    scoped_refptr<VideoLayer> video_layer =
-        VideoLayer::Create(&provider_, media::VIDEO_ROTATION_0);
-    video_layer->SetBounds(gfx::Size(10, 10));
-    video_layer->SetIsDrawable(true);
-    layer_tree_host()->root_layer()->AddChild(video_layer);
-
-    invalidate_layer_ = video_layer;
-  }
-
- private:
-  FakeVideoFrameProvider provider_;
-};
-
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestVideoLayerInvalidate);
-
 // IOSurfaceLayer must support being invalidated and then passing that along
 // to the compositor thread, even though no resources are updated in
 // response to that invalidation.
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index c99180d..cc536f4 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -15,8 +15,6 @@
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/layers/texture_layer_impl.h"
-#include "cc/layers/video_layer.h"
-#include "cc/layers/video_layer_impl.h"
 #include "cc/output/filter_operations.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/test/failure_output_surface.h"
@@ -33,7 +31,6 @@
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_scoped_ui_resource.h"
 #include "cc/test/fake_scrollbar.h"
-#include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/test_context_provider.h"
@@ -43,9 +40,6 @@
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
-#include "media/base/media.h"
-
-using media::VideoFrame;

 namespace cc {
 namespace {
@@ -66,7 +60,6 @@ class LayerTreeHostContextTest : public LayerTreeTest {
         context_should_support_io_surface_(false),
         fallback_context_works_(false),
         async_output_surface_creation_(false) {
-    media::InitializeMediaLibraryForTesting();
   }

   void LoseContext() {
@@ -1055,41 +1048,6 @@ class LayerTreeHostContextTestDontUseLostResources
     layer_with_mask->SetMaskLayer(mask.get());
     root->AddChild(layer_with_mask);

-    scoped_refptr<VideoLayer> video_color =
-        VideoLayer::Create(&color_frame_provider_, media::VIDEO_ROTATION_0);
-    video_color->SetBounds(gfx::Size(10, 10));
-    video_color->SetIsDrawable(true);
-    root->AddChild(video_color);
-
-    scoped_refptr<VideoLayer> video_hw =
-        VideoLayer::Create(&hw_frame_provider_, media::VIDEO_ROTATION_0);
-    video_hw->SetBounds(gfx::Size(10, 10));
-    video_hw->SetIsDrawable(true);
-    root->AddChild(video_hw);
-
-    scoped_refptr<VideoLayer> video_scaled_hw =
-        VideoLayer::Create(&scaled_hw_frame_provider_, media::VIDEO_ROTATION_0);
-    video_scaled_hw->SetBounds(gfx::Size(10, 10));
-    video_scaled_hw->SetIsDrawable(true);
-    root->AddChild(video_scaled_hw);
-
-    color_video_frame_ = VideoFrame::CreateColorFrame(
-        gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
-    hw_video_frame_ = VideoFrame::WrapNativeTexture(
-        make_scoped_ptr(
-            new gpu::MailboxHolder(mailbox, GL_TEXTURE_2D, sync_point)),
-        media::VideoFrame::ReleaseMailboxCB(), gfx::Size(4, 4),
-        gfx::Rect(0, 0, 4, 4), gfx::Size(4, 4), base::TimeDelta(), false);
-    scaled_hw_video_frame_ = VideoFrame::WrapNativeTexture(
-        make_scoped_ptr(
-            new gpu::MailboxHolder(mailbox, GL_TEXTURE_2D, sync_point)),
-        media::VideoFrame::ReleaseMailboxCB(), gfx::Size(4, 4),
-        gfx::Rect(0, 0, 3, 2), gfx::Size(4, 4), base::TimeDelta(), false);
-
-    color_frame_provider_.set_frame(color_video_frame_);
-    hw_frame_provider_.set_frame(hw_video_frame_);
-    scaled_hw_frame_provider_.set_frame(scaled_hw_video_frame_);
-
     if (!delegating_renderer()) {
       // TODO(danakj): IOSurface layer can not be transported. crbug.com/239335
       scoped_refptr<IOSurfaceLayer> io_surface = IOSurfaceLayer::Create();
@@ -1119,14 +1077,6 @@ class LayerTreeHostContextTestDontUseLostResources

   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(host_impl);
-
-    if (host_impl->active_tree()->source_frame_number() == 3) {
-      // On the third commit we're recovering from context loss. Hardware
-      // video frames should not be reused by the VideoFrameProvider, but
-      // software frames can be.
-      hw_frame_provider_.set_frame(NULL);
-      scaled_hw_frame_provider_.set_frame(NULL);
-    }
   }

   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
@@ -1175,14 +1125,6 @@ class LayerTreeHostContextTestDontUseLostResources
   scoped_refptr<DelegatedFrameResourceCollection>
       delegated_resource_collection_;
   scoped_refptr<DelegatedFrameProvider> delegated_frame_provider_;
-
-  scoped_refptr<VideoFrame> color_video_frame_;
-  scoped_refptr<VideoFrame> hw_video_frame_;
-  scoped_refptr<VideoFrame> scaled_hw_video_frame_;
-
-  FakeVideoFrameProvider color_frame_provider_;
-  FakeVideoFrameProvider hw_frame_provider_;
-  FakeVideoFrameProvider scaled_hw_frame_provider_;
 };

 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestDontUseLostResources);