Run all LayerTreeHost tests with a delegating renderer.

cc/trees/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/trees/layer_tree_host.h"
 
 #include "base/basictypes.h"
 #include "cc/base/thread_impl.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/io_surface_layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/scrollbar_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/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_context_provider.h"
 #include "cc/test/fake_delegated_renderer_layer.h"
 #include "cc/test/fake_delegated_renderer_layer_impl.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
@@ skipping 73 matching lines @@
       // The number of times MakeCurrent succeeds is not important, and
       // can be changed if needed to make this pass with future changes.
       context3d_->set_times_make_current_succeeds(2);
       ExpectCreateToFail();
     } else if (times_to_lose_on_create_) {
       --times_to_lose_on_create_;
       LoseContext();
       ExpectCreateToFail();
     }
 
+    if (delegating_renderer()) {
+      return FakeOutputSurface::CreateDelegating3d(
+          context3d.PassAs<WebGraphicsContext3D>()).PassAs<OutputSurface>();
+    }
     return FakeOutputSurface::Create3d(
         context3d.PassAs<WebGraphicsContext3D>()).PassAs<OutputSurface>();
   }
 
   scoped_ptr<TestWebGraphicsContext3D> CreateOffscreenContext3d() {
     if (!context3d_)
       return scoped_ptr<TestWebGraphicsContext3D>();
 
     ++times_offscreen_created_;
 
@@ skipping 353 matching lines @@
   }
 
  protected:
   bool use_surface_;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
   scoped_refptr<ContentLayer> content_;
 };
 
 TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
-       NoSurface_SingleThread) {
+       NoSurface_SingleThread_DirectRenderer) {
   use_surface_ = false;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
-       NoSurface_MultiThread) {
+       NoSurface_SingleThread_DelegatingRenderer) {
   use_surface_ = false;
-  RunTest(true);
+  RunTest(false, true);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
-       WithSurface_SingleThread) {
-  use_surface_ = true;
-  RunTest(false);
+       NoSurface_MultiThread_DirectRenderer) {
+  use_surface_ = false;
+  RunTest(true, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
-       WithSurface_MultiThread) {
+       NoSurface_MultiThread_DelegatingRenderer) {
+  use_surface_ = false;
+  RunTest(true, true);
+}
+
+// Surfaces don't exist with a delegating renderer.
+TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
+       WithSurface_SingleThread_DirectRenderer) {
   use_surface_ = true;
-  RunTest(true);
+  RunTest(false, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
+       WithSurface_MultiThread_DirectRenderer) {
+  use_surface_ = true;
+  RunTest(true, false);
 }
 
 class LayerTreeHostContextTestOffscreenContextFails
     : public LayerTreeHostContextTest {
  public:
   virtual void SetupTree() OVERRIDE {
     root_ = Layer::Create();
     root_->SetBounds(gfx::Size(10, 10));
     root_->SetAnchorPoint(gfx::PointF());
     root_->SetIsDrawable(true);
@@ skipping 82 matching lines @@
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_commits_;
   bool first_initialized_;
 };
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       FailReinitialize100_SingleThread) {
+       FailReinitialize100_SingleThread_DirectRenderer) {
   times_to_fail_reinitialize_ = 100;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 0;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       FailReinitialize100_MultiThread) {
+       FailReinitialize100_SingleThread_DelegatingRenderer) {
   times_to_fail_reinitialize_ = 100;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 0;
-  RunTest(true);
+  RunTest(false, true);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       FailRecreate100_SingleThread) {
+       FailReinitialize100_MultiThread_DirectRenderer) {
+  times_to_fail_reinitialize_ = 100;
+  times_to_fail_recreate_ = 0;
+  times_to_lose_on_recreate_ = 0;
+  RunTest(true, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       FailReinitialize100_MultiThread_DelegatingRenderer) {
+  times_to_fail_reinitialize_ = 100;
+  times_to_fail_recreate_ = 0;
+  times_to_lose_on_recreate_ = 0;
+  RunTest(true, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       FailRecreate100_SingleThread_DirectRenderer) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 100;
   times_to_lose_on_recreate_ = 0;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       FailRecreate100_MultiThread) {
+       FailRecreate100_SingleThread_DelegatingRenderer) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 100;
   times_to_lose_on_recreate_ = 0;
-  RunTest(true);
+  RunTest(false, true);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       LoseOnRecreate100_SingleThread) {
+       FailRecreate100_MultiThread_DirectRenderer) {
+  times_to_fail_reinitialize_ = 0;
+  times_to_fail_recreate_ = 100;
+  times_to_lose_on_recreate_ = 0;
+  RunTest(true, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       FailRecreate100_MultiThread_DelegatingRenderer) {
+  times_to_fail_reinitialize_ = 0;
+  times_to_fail_recreate_ = 100;
+  times_to_lose_on_recreate_ = 0;
+  RunTest(true, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       LoseOnRecreate100_SingleThread_DirectRenderer) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 100;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       LoseOnRecreate100_MultiThread) {
+       LoseOnRecreate100_SingleThread_DelegatingRenderer) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 100;
-  RunTest(true);
+  RunTest(false, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       LoseOnRecreate100_MultiThread_DirectRenderer) {
+  times_to_fail_reinitialize_ = 0;
+  times_to_fail_recreate_ = 0;
+  times_to_lose_on_recreate_ = 100;
+  RunTest(true, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       LoseOnRecreate100_MultiThread_DelegatingRenderer) {
+  times_to_fail_reinitialize_ = 0;
+  times_to_fail_recreate_ = 0;
+  times_to_lose_on_recreate_ = 100;
+  RunTest(true, true);
 }
 
 class LayerTreeHostContextTestFinishAllRenderingAfterLoss
     : public LayerTreeHostContextTest {
  public:
   virtual void BeginTest() OVERRIDE {
     // Lose the context until the compositor gives up on it.
     first_initialized_ = false;
     times_to_lose_during_commit_ = 1;
     times_to_fail_reinitialize_ = 10;
@@ skipping 83 matching lines @@
 
  protected:
   bool lose_after_evict_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> layer_;
   LayerTreeHostImpl* impl_host_;
   int num_commits_;
 };
 
 TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
-       LoseAfterEvict_SingleThread) {
+       LoseAfterEvict_SingleThread_DirectRenderer) {
   lose_after_evict_ = true;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
-       LoseAfterEvict_MultiThread) {
+       LoseAfterEvict_SingleThread_DelegatingRenderer) {
   lose_after_evict_ = true;
-  RunTest(true);
+  RunTest(false, true);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
-       LoseBeforeEvict_SingleThread) {
-  lose_after_evict_ = false;
-  RunTest(false);
+       LoseAfterEvict_MultiThread_DirectRenderer) {
+  lose_after_evict_ = true;
+  RunTest(true, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
-       LoseBeforeEvict_MultiThread) {
+       LoseAfterEvict_MultiThread_DelegatingRenderer) {
+  lose_after_evict_ = true;
+  RunTest(true, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
+       LoseBeforeEvict_SingleThread_DirectRenderer) {
   lose_after_evict_ = false;
-  RunTest(true);
+  RunTest(false, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
+       LoseBeforeEvict_SingleThread_DelegatingRenderer) {
+  lose_after_evict_ = false;
+  RunTest(false, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
+       LoseBeforeEvict_MultiThread_DirectRenderer) {
+  lose_after_evict_ = false;
+  RunTest(true, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
+       LoseBeforeEvict_MultiThread_DelegatingRenderer) {
+  lose_after_evict_ = false;
+  RunTest(true, true);
 }
 
 class LayerTreeHostContextTestLostContextWhileUpdatingResources
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextWhileUpdatingResources()
       : parent_(FakeContentLayer::Create(&client_)),
         num_children_(50),
         times_to_lose_on_end_query_(3) {}
 
@@ skipping 150 matching lines @@
 
     scoped_refptr<ContentLayer> content_ = ContentLayer::Create(&client_);
     content_->SetBounds(gfx::Size(10, 10));
     content_->SetAnchorPoint(gfx::PointF());
     content_->SetIsDrawable(true);
     root_->AddChild(content_);
 
     scoped_refptr<TextureLayer> texture_ = TextureLayer::Create(NULL);
     texture_->SetBounds(gfx::Size(10, 10));
     texture_->SetAnchorPoint(gfx::PointF());
-    texture_->SetTextureId(TestWebGraphicsContext3D::kExternalTextureId);
     texture_->SetIsDrawable(true);
     root_->AddChild(texture_);
 
     scoped_refptr<ContentLayer> mask_ = ContentLayer::Create(&client_);
     mask_->SetBounds(gfx::Size(10, 10));
     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_);
 
     scoped_refptr<VideoLayer> video_color_ = VideoLayer::Create(
         &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_);
-    video_hw_->SetBounds(gfx::Size(10, 10));
-    video_hw_->SetAnchorPoint(gfx::PointF());
-    video_hw_->SetIsDrawable(true);
-    root_->AddChild(video_hw_);
+    if (!delegating_renderer()) {
+      // TODO(danakj): Hardware video decode can not be transported.
+      // crbug.com/179729
+      scoped_refptr<VideoLayer> video_hw_ = VideoLayer::Create(
+          &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_);
-    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<VideoLayer> video_scaled_hw_ = VideoLayer::Create(
+          &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));
-    root_->AddChild(io_surface_);
+    if (!delegating_renderer()) {
+      // TODO(danakj): IOSurface layer can not be transported. crbug.com/239335
+      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));
+      root_->AddChild(io_surface_);
+    }
 
     // Enable the hud.
     LayerTreeDebugState debug_state;
     debug_state.show_property_changed_rects = true;
     layer_tree_host()->SetDebugState(debug_state);
 
     bool paint_scrollbar = true;
     bool has_thumb = true;
     scoped_refptr<ScrollbarLayer> scrollbar_ = ScrollbarLayer::Create(
         FakeWebScrollbar::Create().PassAs<WebKit::WebScrollbar>(),
@@ skipping 44 matching lines @@
       pass_list.push_back(pass_for_quad.PassAs<RenderPass>());
       pass_list.push_back(pass.PassAs<RenderPass>());
 
       // First child is the delegated layer.
       FakeDelegatedRendererLayerImpl* delegated_impl =
           static_cast<FakeDelegatedRendererLayerImpl*>(
               host_impl->active_tree()->root_layer()->children()[0]);
       delegated_impl->SetFrameDataForRenderPasses(&pass_list);
       EXPECT_TRUE(pass_list.empty());
 
+      // Third child is the texture layer.
+      TextureLayerImpl* texture_impl =
+          static_cast<TextureLayerImpl*>(
+              host_impl->active_tree()->root_layer()->children()[2]);
+      texture_impl->set_texture_id(
+          resource_provider->GraphicsContext3D()->createTexture());
+
+      DCHECK(resource_provider->GraphicsContext3D());
+      ResourceProvider::ResourceId texture = resource_provider->CreateResource(
+          gfx::Size(4, 4),
+          resource_provider->default_resource_type(),
+          ResourceProvider::TextureUsageAny);
+      ResourceProvider::ScopedWriteLockGL lock(resource_provider, texture);
+
       color_video_frame_ = VideoFrame::CreateColorFrame(
           gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
       hw_video_frame_ = VideoFrame::WrapNativeTexture(
-          resource_provider->GraphicsContext3D()->createTexture(),
+          lock.texture_id(),
           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(),
+          lock.texture_id(),
           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_);
       hw_frame_provider_.set_frame(hw_video_frame_);
       scaled_hw_frame_provider_.set_frame(scaled_hw_video_frame_);
       return;
@@ skipping 128 matching lines @@
     : public LayerTreeHostContextTest {
  public:
   virtual void BeginTest() OVERRIDE {
     // This must be called immediately after creating LTH, before the first
     // OutputSurface is initialized.
     ASSERT_TRUE(layer_tree_host()->output_surface_lost());
 
     times_output_surface_created_ = 0;
 
     char pixels[4];
-    EXPECT_TRUE(layer_tree_host()->CompositeAndReadback(
-          &pixels, gfx::Rect(1, 1)));
+    bool result = layer_tree_host()->CompositeAndReadback(
+        &pixels, gfx::Rect(1, 1));
+    EXPECT_EQ(!delegating_renderer(), result);
     EXPECT_EQ(1, times_output_surface_created_);
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidInitializeOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_TRUE(succeeded);
     ++times_output_surface_created_;
   }
 
@@ skipping 134 matching lines @@
     EXPECT_FALSE(
         layer_tree_host()->CompositeAndReadback(pixels, gfx::Rect(1, 1)));
     // If we've made it this far without crashing, we've succeeded.
     EndTest();
   }
 
  private:
   int failure_count_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestFailsToCreateSurface);
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostContextTestFailsToCreateSurface);
 
 // Not reusing LayerTreeTest because it expects creating LTH to always succeed.
 class LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface
     : public testing::Test,
       public FakeLayerTreeHostClient {
  public:
   LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface()
       : FakeLayerTreeHostClient(FakeLayerTreeHostClient::DIRECT_3D) {}
 
-  // FakeLayerTreeHostClient
+  // FakeLayerTreeHostClient implementation.
   virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
     return scoped_ptr<OutputSurface>();
   }
 
-  void RunTest(bool threaded) {
+  void RunTest(bool threaded, bool delegating_renderer) {
     scoped_ptr<base::Thread> impl_thread;
     scoped_ptr<cc::Thread> impl_ccthread(NULL);
     if (threaded) {
       impl_thread.reset(new base::Thread("LayerTreeTest"));
       impl_ccthread = cc::ThreadImpl::CreateForDifferentThread(
           impl_thread->message_loop_proxy());
       ASSERT_TRUE(impl_ccthread);
     }
 
     LayerTreeSettings settings;
     scoped_ptr<LayerTreeHost> layer_tree_host =
         LayerTreeHost::Create(this, settings, impl_ccthread.Pass());
     EXPECT_FALSE(layer_tree_host);
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface);
 
 }  // namespace
 }  // namespace cc