cc: Route offscreen context creation for compositor to the browser.

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/ganesh_resource_provider.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/picture_layer.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_layer.h"
 #include "cc/test/fake_scrollbar_theme_painter.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 "gpu/GLES2/gl2extchromium.h"
 #include "media/base/media.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperations.h"
 
 using media::VideoFrame;
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 namespace {
 
 // These tests deal with losing the 3d graphics context.
 class LayerTreeHostContextTest : public ThreadedTest {
  public:
   LayerTreeHostContextTest()
       : ThreadedTest(),
         context3d_(NULL),
         times_to_fail_create_(0),
         times_to_fail_initialize_(0),
         times_to_lose_on_create_(0),
         times_to_lose_during_commit_(0),
         times_to_lose_during_draw_(0),
         times_to_fail_recreate_(0),
         times_to_fail_reinitialize_(0),
-        times_to_lose_on_recreate_(0) {
+        times_to_lose_on_recreate_(0),
+        times_to_fail_create_offscreen_(0),
+        times_to_lose_on_create_offscreen_(0),
+        times_to_fail_recreate_offscreen_(0),
+        times_to_lose_on_recreate_offscreen_(0),
+        times_to_expect_recreate_retried_(0),
+        times_recreate_retried_(0) {
     media::InitializeMediaLibraryForTesting();
   }
 
   void LoseContext() {
     context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                     GL_INNOCENT_CONTEXT_RESET_ARB);
     context3d_ = NULL;
   }
 
   virtual scoped_ptr<FakeWebGraphicsContext3D> CreateContext3d() {
     return FakeWebGraphicsContext3D::Create();
   }
 
   virtual scoped_ptr<OutputSurface> createOutputSurface() OVERRIDE {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
+      ExpectRecreateToRetry();
       return scoped_ptr<OutputSurface>();
     }
 
     scoped_ptr<FakeWebGraphicsContext3D> context3d = CreateContext3d();
     context3d_ = context3d.get();
 
     if (times_to_fail_initialize_) {
       --times_to_fail_initialize_;
       // Make the context get lost during reinitialization.
       // 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);
+      ExpectRecreateToRetry();
     } else if (times_to_lose_on_create_) {
       --times_to_lose_on_create_;
       LoseContext();
+      ExpectRecreateToRetry();
     }
 
     return FakeOutputSurface::Create3d(
         context3d.PassAs<WebGraphicsContext3D>()).PassAs<OutputSurface>();
   }
 
-    virtual bool prepareToDrawOnThread(
-        LayerTreeHostImpl*, LayerTreeHostImpl::FrameData&, bool result)
-        OVERRIDE {
-      EXPECT_TRUE(result);
-      if (!times_to_lose_during_draw_)
-        return result;
+  WebKit::WebGraphicsContext3D* CreateOffscreenContext3d() {
+    DCHECK(!offscreen_context3d_);
 
-      --times_to_lose_during_draw_;
-      if (context3d_)
-        context3d_->set_times_make_current_succeeds(0);
-      return result;
+    if (times_to_fail_create_offscreen_) {
+      --times_to_fail_create_offscreen_;
+      ExpectRecreateToRetry();
+      return NULL;
     }
 
+    WebKit::WebGraphicsContext3D::Attributes attrs;
+    offscreen_context3d_ =
+        FakeWebGraphicsContext3D::Create(attrs)
+        .PassAs<WebKit::WebGraphicsContext3D>();
+    DCHECK(offscreen_context3d_);
+
+    if (times_to_lose_on_create_offscreen_) {
+      --times_to_lose_on_create_offscreen_;
+      offscreen_context3d_->loseContextCHROMIUM(
+          GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
+      offscreen_context3d_.reset();
+      ExpectRecreateToRetry();
+    }
+
+    return offscreen_context3d_.get();
+  }
+
+  // LayerTreeHostClient implementation.
+  virtual WebKit::WebGraphicsContext3D* offscreenContext3dForMainThread()
+      OVERRIDE {
+    DCHECK(!implThread());
+
+    if (!offscreen_context3d_)
+      CreateOffscreenContext3d();
+    return offscreen_context3d_.get();
+  }
+
+  // LayerTreeHostClient implementation.
+  virtual WebKit::WebGraphicsContext3D* offscreenContext3dForCompositorThread()
+      OVERRIDE {
+    DCHECK(implThread());
+
+    if (!offscreen_context3d_)
+      CreateOffscreenContext3d();
+    return offscreen_context3d_.get();
+  }
+
+  // LayerTreeHostClient implementation.
+  virtual GrContext* offscreenGrContextForMainThread() OVERRIDE {
+    DCHECK(!implThread());
+    // TODO(danakj): Make a FakeGrContext.
+    return NULL;
+  }
+
+  // LayerTreeHostClient implementation.
+  virtual GrContext* offscreenGrContextForCompositorThread() OVERRIDE {
+    DCHECK(implThread());
+    // TODO(danakj): Make a FakeGrContext.
+    return NULL;
+  }
+
+  virtual bool prepareToDrawOnThread(
+      LayerTreeHostImpl*, LayerTreeHostImpl::FrameData&, bool result)
+      OVERRIDE {
+    EXPECT_TRUE(result);
+    if (!times_to_lose_during_draw_)
+      return result;
+
+    --times_to_lose_during_draw_;
+    if (context3d_)
+      context3d_->set_times_make_current_succeeds(0);
+    return result;
+  }
+
   virtual void commitCompleteOnThread(LayerTreeHostImpl *host_impl) OVERRIDE {
-    if (!times_to_lose_during_commit_)
-      return;
-    --times_to_lose_during_commit_;
-    LoseContext();
+    if (times_to_lose_during_commit_) {
+      --times_to_lose_during_commit_;
+      LoseContext();
+    }
 
     times_to_fail_create_ = times_to_fail_recreate_;
     times_to_fail_recreate_ = 0;
     times_to_fail_initialize_ = times_to_fail_reinitialize_;
     times_to_fail_reinitialize_ = 0;
     times_to_lose_on_create_ = times_to_lose_on_recreate_;
     times_to_lose_on_recreate_ = 0;
+    times_to_fail_create_offscreen_ = times_to_fail_recreate_offscreen_;
+    times_to_fail_recreate_offscreen_ = 0;
+    times_to_lose_on_create_offscreen_ = times_to_lose_on_recreate_offscreen_;
+    times_to_lose_on_recreate_offscreen_ = 0;
+  }
+
+  virtual void willRetryRecreateOutputSurface() OVERRIDE {
+    ++times_recreate_retried_;
+  }
+
+  virtual void afterTest() OVERRIDE {
+    EXPECT_EQ(times_to_expect_recreate_retried_, times_recreate_retried_);
+  }
+
+  void ExpectRecreateToRetry() {
+    ++times_to_expect_recreate_retried_;
   }
 
  protected:
   FakeWebGraphicsContext3D* context3d_;
   int times_to_fail_create_;
   int times_to_fail_initialize_;
   int times_to_lose_on_create_;
   int times_to_lose_during_commit_;
   int times_to_lose_during_draw_;
   int times_to_fail_reinitialize_;
   int times_to_fail_recreate_;
   int times_to_lose_on_recreate_;
+  int times_to_fail_create_offscreen_;
+  int times_to_lose_on_create_offscreen_;
+  int times_to_fail_recreate_offscreen_;
+  int times_to_lose_on_recreate_offscreen_;
+  int times_to_expect_recreate_retried_;
+  int times_recreate_retried_;
+
+  scoped_ptr<WebKit::WebGraphicsContext3D> offscreen_context3d_;
 };
 
 class LayerTreeHostContextTestLostContextSucceeds :
       public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextSucceeds()
       : LayerTreeHostContextTest(),
         test_case_(0),
         num_losses_(0),
         recovered_context_(true) {
   }
 
   virtual void beginTest() OVERRIDE {
     postSetNeedsCommitToMainThread();
   }
 
   virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_TRUE(succeeded);
     ++num_losses_;
     recovered_context_ = true;
   }
 
   virtual void afterTest() OVERRIDE {
-    EXPECT_EQ(8, test_case_);
-    EXPECT_EQ(6 + 10 + 10, num_losses_);
+    LayerTreeHostContextTest::afterTest();
+    EXPECT_EQ(12, test_case_);
+    EXPECT_EQ(10 + 10 + 10, num_losses_);
   }
 
   virtual void didCommitAndDrawFrame() OVERRIDE {
     // If the last frame had a context loss, then we'll commit again to
     // recover.
     if (!recovered_context_)
       return;
     if (times_to_lose_during_commit_)
       return;
     if (times_to_lose_during_draw_)
@@ skipping 12 matching lines @@
 
   bool NextTestCase() {
     static const TestCase kTests[] = {
       // Losing the context and failing to recreate it (or losing it again
       // immediately) a small number of times should succeed.
       { 1, // times_to_lose_during_commit
         0, // times_to_lose_during_draw
         3, // times_to_fail_reinitialize
         0, // times_to_fail_recreate
         0, // times_to_lose_on_recreate
+        0, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
       },
       { 0, // times_to_lose_during_commit
         1, // times_to_lose_during_draw
         3, // times_to_fail_reinitialize
         0, // times_to_fail_recreate
         0, // times_to_lose_on_recreate
+        0, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
       },
       { 1, // times_to_lose_during_commit
         0, // times_to_lose_during_draw
         0, // times_to_fail_reinitialize
         3, // times_to_fail_recreate
         0, // times_to_lose_on_recreate
+        0, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
       },
       { 0, // times_to_lose_during_commit
         1, // times_to_lose_during_draw
         0, // times_to_fail_reinitialize
         3, // times_to_fail_recreate
         0, // times_to_lose_on_recreate
+        0, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
       },
       { 1, // times_to_lose_during_commit
         0, // times_to_lose_during_draw
         0, // times_to_fail_reinitialize
         0, // times_to_fail_recreate
         3, // times_to_lose_on_recreate
+        0, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
       },
       { 0, // times_to_lose_during_commit
         1, // times_to_lose_during_draw
         0, // times_to_fail_reinitialize
         0, // times_to_fail_recreate
         3, // times_to_lose_on_recreate
+        0, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
+      },
+      { 1, // times_to_lose_during_commit
+        0, // times_to_lose_during_draw
+        0, // times_to_fail_reinitialize
+        0, // times_to_fail_recreate
+        0, // times_to_lose_on_recreate
+        3, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
+      },
+      { 0, // times_to_lose_during_commit
+        1, // times_to_lose_during_draw
+        0, // times_to_fail_reinitialize
+        0, // times_to_fail_recreate
+        0, // times_to_lose_on_recreate
+        3, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
+      },
+      { 1, // times_to_lose_during_commit
+        0, // times_to_lose_during_draw
+        0, // times_to_fail_reinitialize
+        0, // times_to_fail_recreate
+        0, // times_to_lose_on_recreate
+        3, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
+      },
+      { 0, // times_to_lose_during_commit
+        1, // times_to_lose_during_draw
+        0, // times_to_fail_reinitialize
+        0, // times_to_fail_recreate
+        0, // times_to_lose_on_recreate
+        0, // times_to_fail_recreate_offscreen;
+        3, // times_to_lose_on_recreate_offscreen;
       },
       // Losing the context and recreating it any number of times should
       // succeed.
       { 10, // times_to_lose_during_commit
         0, // times_to_lose_during_draw
         0, // times_to_fail_reinitialize
         0, // times_to_fail_recreate
         0, // times_to_lose_on_recreate
+        0, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
       },
       { 0, // times_to_lose_during_commit
         10, // times_to_lose_during_draw
         0, // times_to_fail_reinitialize
         0, // times_to_fail_recreate
         0, // times_to_lose_on_recreate
+        0, // times_to_fail_recreate_offscreen;
+        0, // times_to_lose_on_recreate_offscreen;
       },
     };
 
     if (test_case_ >= arraysize(kTests))
       return false;
 
     times_to_lose_during_commit_ =
         kTests[test_case_].times_to_lose_during_commit;
     times_to_lose_during_draw_ =
         kTests[test_case_].times_to_lose_during_draw;
     times_to_fail_reinitialize_ = kTests[test_case_].times_to_fail_reinitialize;
     times_to_fail_recreate_ = kTests[test_case_].times_to_fail_recreate;
     times_to_lose_on_recreate_ = kTests[test_case_].times_to_lose_on_recreate;
+    times_to_fail_recreate_offscreen_ = kTests[test_case_].times_to_fail_recreate_offscreen;
+    times_to_lose_on_recreate_offscreen_ = kTests[test_case_].times_to_lose_on_recreate_offscreen;
     ++test_case_;
     return true;
   }
 
   struct TestCase {
     int times_to_lose_during_commit;
     int times_to_lose_during_draw;
     int times_to_fail_reinitialize;
     int times_to_fail_recreate;
     int times_to_lose_on_recreate;
+    int times_to_fail_recreate_offscreen;
+    int times_to_lose_on_recreate_offscreen;
   };
 
  private:
   size_t test_case_;
   int num_losses_;
   bool recovered_context_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestLostContextSucceeds)
 
 class LayerTreeHostContextTestLostContextSucceedsWithContent :
     public LayerTreeHostContextTestLostContextSucceeds {
  public:
 
   LayerTreeHostContextTestLostContextSucceedsWithContent()
       : LayerTreeHostContextTestLostContextSucceeds() {
   }
 
   virtual void setupTree() OVERRIDE {
     root_ = Layer::create();
     root_->setBounds(gfx::Size(10, 10));
     root_->setAnchorPoint(gfx::PointF());
     root_->setIsDrawable(true);
 
     content_ = FakeContentLayer::Create(&client_);
     content_->setBounds(gfx::Size(10, 10));
     content_->setAnchorPoint(gfx::PointF());
     content_->setIsDrawable(true);
     if (use_surface_) {
-      // TODO(danakj): Give the surface a filter to test more code when we can
-      // do so without crashing in the shared context creation.
       content_->setForceRenderSurface(true);
+      // Filters require us to create an offscreen context.
+      WebKit::WebFilterOperations filters;
+      filters.append(WebKit::WebFilterOperation::createGrayscaleFilter(0.5f));
+      content_->setFilters(filters);
+      content_->setBackgroundFilters(filters);
     }
 
     root_->addChild(content_);
 
     m_layerTreeHost->setRootLayer(root_);
     LayerTreeHostContextTest::setupTree();
   }
 
   virtual void InvalidateAndSetNeedsCommit() OVERRIDE {
     // Invalidate the render surface so we don't try to use a cached copy of the
     // surface.  We want to make sure to test the drawing paths for drawing to
     // a child surface.
     content_->setNeedsDisplay();
     LayerTreeHostContextTestLostContextSucceeds::InvalidateAndSetNeedsCommit();
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* host_impl) {
     FakeContentLayerImpl* content_impl = static_cast<FakeContentLayerImpl*>(
         host_impl->rootLayer()->children()[0]);
     // Even though the context was lost, we should have a resource. The
     // FakeWebGraphicsContext3D ensures that this resource is created with
     // the active context.
     EXPECT_TRUE(content_impl->HaveResourceForTileAt(0, 0));
+
+    GaneshResourceProvider::ScopedContexts contexts(
+        host_impl->resourceProvider()->ganeshResourceProvider());
+    if (use_surface_)
+      EXPECT_TRUE(contexts.context3d());
+    else
+      EXPECT_FALSE(contexts.context3d());
   }
 
  protected:
   bool use_surface_;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
   scoped_refptr<ContentLayer> content_;
 };
 
 TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
@@ skipping 49 matching lines @@
       EXPECT_TRUE(host_impl->resourceProvider());
       return;
     }
 
     // When context recreation fails we shouldn't be left with any of them.
     EXPECT_FALSE(host_impl->outputSurface());
     EXPECT_FALSE(host_impl->renderer());
     EXPECT_FALSE(host_impl->resourceProvider());
   }
 
-  virtual void afterTest() OVERRIDE {}
-
  private:
   int num_commits_;
 };
 
 TEST_F(LayerTreeHostContextTestLostContextFails, FailReinitialize100_SingleThread) {
   times_to_fail_reinitialize_ = 100;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 0;
   runTest(false);
 }
@@ skipping 41 matching lines @@
     times_to_lose_during_commit_ = 1;
     times_to_fail_reinitialize_ = 10;
     postSetNeedsCommitToMainThread();
   }
 
   virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_FALSE(succeeded);
     m_layerTreeHost->finishAllRendering();
     endTest();
   }
-
-  virtual void afterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestFinishAllRenderingAfterLoss)
 
 class LayerTreeHostContextTestLostContextAndEvictTextures :
     public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextAndEvictTextures()
       : LayerTreeHostContextTest(),
@@ skipping 45 matching lines @@
     if (!lose_after_evict_)
       LoseContext();
     impl_host_ = impl;
   }
 
   virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_TRUE(succeeded);
     endTest();
   }
 
-  virtual void afterTest() OVERRIDE {}
-
  protected:
   bool lose_after_evict_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> layer_;
   LayerTreeHostImpl* impl_host_;
   int num_commits_;
 };
 
 TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
        LoseAfterEvict_SingleThread) {
@@ skipping 59 matching lines @@
 
   virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) {
     endTest();
   }
 
   virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_TRUE(succeeded);
   }
 
   virtual void afterTest() {
+    LayerTreeHostContextTest::afterTest();
     EXPECT_EQ(0, times_to_lose_on_end_query_);
   }
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> parent_;
   int num_children_;
   int times_to_lose_on_end_query_;
 };
 
@@ skipping 62 matching lines @@
         EXPECT_EQ(5u, root->lost_output_surface_count());
         EXPECT_EQ(5u, child->lost_output_surface_count());
         EXPECT_EQ(5u, grandchild->lost_output_surface_count());
         endTest();
         break;
       default:
         NOTREACHED();
     }
   }
 
-  virtual void afterTest() OVERRIDE {}
-
  private:
   int num_commits_;
 
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_;
   scoped_refptr<FakeContentLayer> child_;
   scoped_refptr<FakeContentLayer> grandchild_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestLayersNotified)
@@ skipping 179 matching lines @@
     }
     return true;
   }
 
   virtual void didCommitAndDrawFrame() OVERRIDE {
     // End the test once we know the 3nd frame drew.
     if (m_layerTreeHost->commitNumber() == 4)
       endTest();
   }
 
-  virtual void afterTest() OVERRIDE {}
-
  private:
   FakeContentLayerClient client_;
 
   scoped_refptr<Layer> root_;
   scoped_refptr<DelegatedRendererLayer> delegated_;
   scoped_refptr<ContentLayer> content_;
   scoped_refptr<TextureLayer> texture_;
   scoped_refptr<ContentLayer> mask_;
   scoped_refptr<ContentLayer> content_with_mask_;
   scoped_refptr<VideoLayer> video_color_;
@@ skipping 20 matching lines @@
   LayerTreeHostContextTestFailsImmediately()
       : LayerTreeHostContextTest() {
   }
 
   virtual ~LayerTreeHostContextTestFailsImmediately() {}
 
   virtual void beginTest() OVERRIDE {
     postSetNeedsCommitToMainThread();
   }
 
-  virtual void afterTest() OVERRIDE {
-  }
-
   virtual scoped_ptr<FakeWebGraphicsContext3D> CreateContext3d() OVERRIDE {
     scoped_ptr<FakeWebGraphicsContext3D> context =
         LayerTreeHostContextTest::CreateContext3d();
     context->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                  GL_INNOCENT_CONTEXT_RESET_ARB);
     return context.Pass();
   }
 
   virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_FALSE(succeeded);
@@ skipping 29 matching lines @@
 
     m_layerTreeHost->setRootLayer(root);
     LayerTreeHostContextTest::setupTree();
   }
 
   virtual void beginTest() OVERRIDE {
     times_to_lose_during_commit_ = 1;
     postSetNeedsCommitToMainThread();
   }
 
-  virtual void afterTest() OVERRIDE {}
-
   virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_TRUE(succeeded);
     endTest();
   }
 
  private:
   FakeContentLayerClient client_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostContextTestImplSidePainting)
 
 class ScrollbarLayerLostContext : public LayerTreeHostContextTest {
  public:
   ScrollbarLayerLostContext() : commits_(0) {}
 
   virtual void beginTest() OVERRIDE {
     scoped_refptr<Layer> scroll_layer = Layer::create();
     scrollbar_layer_ = FakeScrollbarLayer::Create(
         false, true, scroll_layer->id());
     scrollbar_layer_->setBounds(gfx::Size(10, 100));
     m_layerTreeHost->rootLayer()->addChild(scrollbar_layer_);
     m_layerTreeHost->rootLayer()->addChild(scroll_layer);
     postSetNeedsCommitToMainThread();
   }
 
-  virtual void afterTest() OVERRIDE {
-  }
-
   virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ++commits_;
     size_t upload_count = scrollbar_layer_->last_update_full_upload_size() +
         scrollbar_layer_->last_update_partial_upload_size();
     switch(commits_) {
       case 1:
         // First (regular) update, we should upload 2 resources (thumb, and
         // backtrack).
         EXPECT_EQ(1, scrollbar_layer_->update_count());
         EXPECT_EQ(2, upload_count);
@@ skipping 13 matching lines @@
 
  private:
   int commits_;
   scoped_refptr<FakeScrollbarLayer> scrollbar_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(ScrollbarLayerLostContext)
 
 }  // namespace
 }  // namespace cc