Move VideoFrameProvider to, and remove all usage of WebVideoFrame from cc/

cc/layer_tree_host_unittest_context.cc

 // Copyright 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.
 
 #include "cc/layer_tree_host.h"
 
 #include "base/basictypes.h"
 #include "cc/content_layer.h"
 #include "cc/delegated_renderer_layer.h"
 #include "cc/delegated_renderer_layer_impl.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/io_surface_layer.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/scrollbar_layer.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_content_layer_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_scrollbar_theme_painter.h"
-#include "cc/test/fake_video_frame.h"
 #include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/fake_web_scrollbar.h"
 #include "cc/test/fake_web_scrollbar_theme_geometry.h"
 #include "cc/test/layer_tree_test_common.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/texture_layer.h"
 #include "cc/video_layer.h"
 #include "cc/video_layer_impl.h"
 #include "media/base/media.h"
@@ skipping 524 matching lines @@
     mask_->setAnchorPoint(gfx::PointF());
 
     scoped_refptr<ContentLayer> content_with_mask_ =
         ContentLayer::create(&client_);
     content_with_mask_->setBounds(gfx::Size(10, 10));
     content_with_mask_->setAnchorPoint(gfx::PointF());
     content_with_mask_->setIsDrawable(true);
     content_with_mask_->setMaskLayer(mask_.get());
     root_->addChild(content_with_mask_);
 
-    VideoLayerImpl::FrameUnwrapper unwrapper =
-        base::Bind(FakeVideoFrame::ToVideoFrame);
-
     scoped_refptr<VideoLayer> video_color_ = VideoLayer::create(
-        &color_frame_provider_, unwrapper);
+        &color_frame_provider_);
     video_color_->setBounds(gfx::Size(10, 10));
     video_color_->setAnchorPoint(gfx::PointF());
     video_color_->setIsDrawable(true);
     root_->addChild(video_color_);
 
     scoped_refptr<VideoLayer> video_hw_ = VideoLayer::create(
-        &hw_frame_provider_, unwrapper);
+        &hw_frame_provider_);
     video_hw_->setBounds(gfx::Size(10, 10));
     video_hw_->setAnchorPoint(gfx::PointF());
     video_hw_->setIsDrawable(true);
     root_->addChild(video_hw_);
 
     scoped_refptr<VideoLayer> video_scaled_hw_ = VideoLayer::create(
-        &scaled_hw_frame_provider_, unwrapper);
+        &scaled_hw_frame_provider_);
     video_scaled_hw_->setBounds(gfx::Size(10, 10));
     video_scaled_hw_->setAnchorPoint(gfx::PointF());
     video_scaled_hw_->setIsDrawable(true);
     root_->addChild(video_scaled_hw_);
 
     scoped_refptr<IOSurfaceLayer> io_surface_ = IOSurfaceLayer::create();
     io_surface_->setBounds(gfx::Size(10, 10));
     io_surface_->setAnchorPoint(gfx::PointF());
     io_surface_->setIsDrawable(true);
     io_surface_->setIOSurfaceProperties(1, gfx::Size(10, 10));
@@ skipping 57 matching lines @@
       pass_list.append(pass_for_quad.PassAs<RenderPass>());
       pass_list.append(pass.PassAs<RenderPass>());
 
       // First child is the delegated layer.
       DelegatedRendererLayerImpl* delegated_impl =
           static_cast<DelegatedRendererLayerImpl*>(
               host_impl->rootLayer()->children()[0]);
       delegated_impl->setRenderPasses(pass_list);
       EXPECT_TRUE(pass_list.isEmpty());
 
-      color_video_frame_ = make_scoped_ptr(new FakeVideoFrame(
-          VideoFrame::CreateColorFrame(
-              gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta())));
-      hw_video_frame_ = make_scoped_ptr(new FakeVideoFrame(
-          VideoFrame::WrapNativeTexture(
-              resource_provider->graphicsContext3D()->createTexture(),
-              GL_TEXTURE_2D,
-              gfx::Size(4, 4), gfx::Rect(0, 0, 4, 4), gfx::Size(4, 4),
-              base::TimeDelta(),
-              VideoFrame::ReadPixelsCB(),
-              base::Closure())));
-      scaled_hw_video_frame_ = make_scoped_ptr(new FakeVideoFrame(
-          VideoFrame::WrapNativeTexture(
-              resource_provider->graphicsContext3D()->createTexture(),
-              GL_TEXTURE_2D,
-              gfx::Size(4, 4), gfx::Rect(0, 0, 3, 2), gfx::Size(4, 4),
-              base::TimeDelta(),
-              VideoFrame::ReadPixelsCB(),
-              base::Closure())));
+      color_video_frame_ = VideoFrame::CreateColorFrame(
+          gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
+      hw_video_frame_ = VideoFrame::WrapNativeTexture(
+          resource_provider->graphicsContext3D()->createTexture(),
+          GL_TEXTURE_2D,
+          gfx::Size(4, 4), gfx::Rect(0, 0, 4, 4), gfx::Size(4, 4),
+          base::TimeDelta(),
+          VideoFrame::ReadPixelsCB(),
+          base::Closure());
+      scaled_hw_video_frame_ = VideoFrame::WrapNativeTexture(
+          resource_provider->graphicsContext3D()->createTexture(),
+          GL_TEXTURE_2D,
+          gfx::Size(4, 4), gfx::Rect(0, 0, 3, 2), gfx::Size(4, 4),
+          base::TimeDelta(),
+          VideoFrame::ReadPixelsCB(),
+          base::Closure());
 
-      color_frame_provider_.set_frame(color_video_frame_.get());
-      hw_frame_provider_.set_frame(hw_video_frame_.get());
-      scaled_hw_frame_provider_.set_frame(scaled_hw_video_frame_.get());
+      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_);
       return;
     }
 
     if (host_impl->activeTree()->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);
     }
@@ skipping 26 matching lines @@
   scoped_refptr<TextureLayer> texture_;
   scoped_refptr<ContentLayer> mask_;
   scoped_refptr<ContentLayer> content_with_mask_;
   scoped_refptr<VideoLayer> video_color_;
   scoped_refptr<VideoLayer> video_hw_;
   scoped_refptr<VideoLayer> video_scaled_hw_;
   scoped_refptr<IOSurfaceLayer> io_surface_;
   scoped_refptr<HeadsUpDisplayLayer> hud_;
   scoped_refptr<ScrollbarLayer> scrollbar_;
 
-  scoped_ptr<FakeVideoFrame> color_video_frame_;
-  scoped_ptr<FakeVideoFrame> hw_video_frame_;
-  scoped_ptr<FakeVideoFrame> scaled_hw_video_frame_;
+  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)
 
 }  // namespace
 }  // namespace cc