Remove WebGraphicsContext3D getter from cc::ContextProvider

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/layers/content_layer.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
@@ skipping 59 matching lines @@
   void LoseContext() {
     context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                     GL_INNOCENT_CONTEXT_RESET_ARB);
     context3d_ = NULL;
   }
 
   virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
-  virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
-      OVERRIDE {
+  virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurfaceForTest(
+      bool fallback) OVERRIDE {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
       ExpectCreateToFail();
-      return scoped_ptr<OutputSurface>();
+      return scoped_ptr<FakeOutputSurface>();
     }
 
     scoped_ptr<TestWebGraphicsContext3D> context3d = CreateContext3d();
     context3d_ = context3d.get();
 
     if (context_should_support_io_surface_) {
       context3d_->set_have_extension_io_surface(true);
       context3d_->set_have_extension_egl_image(true);
     }
 
-    if (delegating_renderer()) {
-      return FakeOutputSurface::CreateDelegating3d(context3d.Pass())
-          .PassAs<OutputSurface>();
-    }
-    return FakeOutputSurface::Create3d(context3d.Pass())
-        .PassAs<OutputSurface>();
+    if (delegating_renderer())
+      return FakeOutputSurface::CreateDelegating3d(context3d.Pass());
+    else
+      return FakeOutputSurface::Create3d(context3d.Pass());
   }
 
   scoped_ptr<TestWebGraphicsContext3D> CreateOffscreenContext3d() {
     if (!context3d_)
       return scoped_ptr<TestWebGraphicsContext3D>();
 
     ++times_offscreen_created_;
 
     if (times_to_fail_create_offscreen_) {
       --times_to_fail_create_offscreen_;
@@ skipping 52 matching lines @@
 
   virtual void DidFailToInitializeOutputSurface() OVERRIDE {
     ++times_create_failed_;
   }
 
   virtual void TearDown() OVERRIDE {
     LayerTreeTest::TearDown();
     EXPECT_EQ(times_to_expect_create_failed_, times_create_failed_);
   }
 
-  void ExpectCreateToFail() {
-    ++times_to_expect_create_failed_;
-  }
+  void ExpectCreateToFail() { ++times_to_expect_create_failed_; }
 
  protected:
   TestWebGraphicsContext3D* context3d_;
   int times_to_fail_create_;
   int times_to_lose_during_commit_;
   int times_to_lose_during_draw_;
   int times_to_fail_recreate_;
   int times_to_fail_create_offscreen_;
   int times_to_fail_recreate_offscreen_;
   int times_to_expect_create_failed_;
@@ skipping 10 matching lines @@
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextSucceeds()
       : LayerTreeHostContextTest(),
         test_case_(0),
         num_losses_(0),
         num_losses_last_test_case_(-1),
         recovered_context_(true),
         first_initialized_(false) {}
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidInitializeOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_TRUE(succeeded);
 
     if (first_initialized_)
       ++num_losses_;
     else
       first_initialized_ = true;
 
     recovered_context_ = true;
@@ skipping 19 matching lines @@
   }
 
   virtual void InvalidateAndSetNeedsCommit() {
     // Cause damage so we try to draw.
     layer_tree_host()->root_layer()->SetNeedsDisplay();
     layer_tree_host()->SetNeedsCommit();
   }
 
   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
-        0,      // times_to_fail_recreate
-        0,      // times_to_fail_recreate_offscreen
-        false,  // fallback_context_works
-    },
-      { 0,      // times_to_lose_during_commit
-        1,      // times_to_lose_during_draw
-        0,      // times_to_fail_recreate
-        0,      // times_to_fail_recreate_offscreen
-        false,  // fallback_context_works
-    },
-      { 1,      // times_to_lose_during_commit
-        0,      // times_to_lose_during_draw
-        3,      // times_to_fail_recreate
-        0,      // times_to_fail_recreate_offscreen
-        false,  // fallback_context_works
-    },
-      { 0,      // times_to_lose_during_commit
-        1,      // times_to_lose_during_draw
-        3,      // times_to_fail_recreate
-        0,      // times_to_fail_recreate_offscreen
-        false,  // fallback_context_works
-    },
-      { 1,      // times_to_lose_during_commit
-        0,      // times_to_lose_during_draw
-        0,      // times_to_fail_recreate
-        3,      // times_to_fail_recreate_offscreen
-        false,  // fallback_context_works
-    },
-      { 0,      // times_to_lose_during_commit
-        1,      // times_to_lose_during_draw
-        0,      // times_to_fail_recreate
-        3,      // times_to_fail_recreate_offscreen
-        false,  // fallback_context_works
-    },
-             // 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_recreate
-        0,   // times_to_fail_recreate_offscreen
-        false,  // fallback_context_works
-    },
-      { 0,      // times_to_lose_during_commit
-        10,     // times_to_lose_during_draw
-        0,      // times_to_fail_recreate
-        0,      // times_to_fail_recreate_offscreen
-        false,  // fallback_context_works
-    },
-      // Losing the context, failing to reinitialize it, and making a fallback
-      // context should work.
-      { 0,      // times_to_lose_during_commit
-        1,      // times_to_lose_during_draw
-        0,      // times_to_fail_recreate
-        0,      // times_to_fail_recreate_offscreen
-        true,   // fallback_context_works
-    },
-    };
+        // 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
+         0,      // times_to_fail_recreate
+         0,      // times_to_fail_recreate_offscreen
+         false,  // fallback_context_works
+        },
+        {0,      // times_to_lose_during_commit
+         1,      // times_to_lose_during_draw
+         0,      // times_to_fail_recreate
+         0,      // times_to_fail_recreate_offscreen
+         false,  // fallback_context_works
+        },
+        {1,      // times_to_lose_during_commit
+         0,      // times_to_lose_during_draw
+         3,      // times_to_fail_recreate
+         0,      // times_to_fail_recreate_offscreen
+         false,  // fallback_context_works
+        },
+        {0,      // times_to_lose_during_commit
+         1,      // times_to_lose_during_draw
+         3,      // times_to_fail_recreate
+         0,      // times_to_fail_recreate_offscreen
+         false,  // fallback_context_works
+        },
+        {1,      // times_to_lose_during_commit
+         0,      // times_to_lose_during_draw
+         0,      // times_to_fail_recreate
+         3,      // times_to_fail_recreate_offscreen
+         false,  // fallback_context_works
+        },
+        {0,      // times_to_lose_during_commit
+         1,      // times_to_lose_during_draw
+         0,      // times_to_fail_recreate
+         3,      // times_to_fail_recreate_offscreen
+         false,  // fallback_context_works
+        },
+        // 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_recreate
+         0,      // times_to_fail_recreate_offscreen
+         false,  // fallback_context_works
+        },
+        {0,      // times_to_lose_during_commit
+         10,     // times_to_lose_during_draw
+         0,      // times_to_fail_recreate
+         0,      // times_to_fail_recreate_offscreen
+         false,  // fallback_context_works
+        },
+        // Losing the context, failing to reinitialize it, and making a fallback
+        // context should work.
+        {0,     // times_to_lose_during_commit
+         1,     // times_to_lose_during_draw
+         0,     // times_to_fail_recreate
+         0,     // times_to_fail_recreate_offscreen
+         true,  // fallback_context_works
+        }, };
 
     if (test_case_ >= arraysize(kTests))
       return false;
     // Make sure that we lost our context at least once in the last test run so
     // the test did something.
     EXPECT_GT(num_losses_, num_losses_last_test_case_);
     num_losses_last_test_case_ = num_losses_;
 
     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_lose_during_draw_ = kTests[test_case_].times_to_lose_during_draw;
     times_to_fail_recreate_ = kTests[test_case_].times_to_fail_recreate;
     times_to_fail_recreate_offscreen_ =
         kTests[test_case_].times_to_fail_recreate_offscreen;
     fallback_context_works_ = kTests[test_case_].fallback_context_works;
     ++test_case_;
     return true;
   }
 
   struct TestCase {
     int times_to_lose_during_commit;
@@ skipping 87 matching lines @@
     FakeContentLayerImpl* content_impl = static_cast<FakeContentLayerImpl*>(
         host_impl->active_tree()->root_layer()->children()[0]);
     // Even though the context was lost, we should have a resource. The
     // TestWebGraphicsContext3D ensures that this resource is created with
     // the active context.
     EXPECT_TRUE(content_impl->HaveResourceForTileAt(0, 0));
 
     ContextProvider* contexts = host_impl->offscreen_context_provider();
     if (use_surface_) {
       ASSERT_TRUE(contexts);
-      EXPECT_TRUE(contexts->Context3d());
+      EXPECT_TRUE(contexts->ContextGL());
       // TODO(danakj): Make a fake GrContext.
       // EXPECT_TRUE(contexts->GrContext());
     } else {
       EXPECT_FALSE(contexts);
     }
   }
 
   virtual void AfterTest() OVERRIDE {
     LayerTreeHostContextTestLostContextSucceeds::AfterTest();
     if (use_surface_) {
@@ skipping 190 matching lines @@
   scoped_refptr<Layer> root_;
   scoped_refptr<ContentLayer> content_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestOffscreenContextFails);
 
 class LayerTreeHostContextTestLostContextFails
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextFails()
-      : LayerTreeHostContextTest(),
-        num_commits_(0),
-        first_initialized_(false) {
+      : LayerTreeHostContextTest(), num_commits_(0), first_initialized_(false) {
     times_to_lose_during_commit_ = 1;
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidInitializeOutputSurface(bool succeeded) OVERRIDE {
     if (first_initialized_) {
       EXPECT_FALSE(succeeded);
       EndTest();
     } else {
       first_initialized_ = true;
     }
   }
 
@@ skipping 30 matching lines @@
         layer_(FakeContentLayer::Create(&client_)),
         impl_host_(0),
         num_commits_(0) {}
 
   virtual void SetupTree() OVERRIDE {
     layer_->SetBounds(gfx::Size(10, 20));
     layer_tree_host()->SetRootLayer(layer_);
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   void PostEvictTextures() {
     if (HasImplThread()) {
       ImplThreadTaskRunner()->PostTask(
           FROM_HERE,
-          base::Bind(
-              &LayerTreeHostContextTestLostContextAndEvictTextures::
-              EvictTexturesOnImplThread,
-              base::Unretained(this)));
+          base::Bind(&LayerTreeHostContextTestLostContextAndEvictTextures::
+                          EvictTexturesOnImplThread,
+                     base::Unretained(this)));
     } else {
       DebugScopedSetImplThread impl(proxy());
       EvictTexturesOnImplThread();
     }
   }
 
   void EvictTexturesOnImplThread() {
     impl_host_->EvictTexturesForTesting();
     if (lose_after_evict_)
       LoseContext();
@@ skipping 124 matching lines @@
           FakeContentLayer::Create(&client_);
       child->SetPosition(gfx::PointF(i, 0.f));
       child->SetBounds(gfx::Size(1, 1));
       parent_->AddChild(child);
     }
 
     layer_tree_host()->SetRootLayer(parent_);
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     EXPECT_EQ(0, times_to_lose_on_end_query_);
     EndTest();
   }
 
   virtual void DidInitializeOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_TRUE(succeeded);
   }
 
   virtual void AfterTest() OVERRIDE {
     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_;
 };
 
 SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(
     LayerTreeHostContextTestLostContextWhileUpdatingResources);
 
-class LayerTreeHostContextTestLayersNotified
-    : public LayerTreeHostContextTest {
+class LayerTreeHostContextTestLayersNotified : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLayersNotified()
-      : LayerTreeHostContextTest(),
-        num_commits_(0) {}
+      : LayerTreeHostContextTest(), num_commits_(0) {}
 
   virtual void SetupTree() OVERRIDE {
     root_ = FakeContentLayer::Create(&client_);
     child_ = FakeContentLayer::Create(&client_);
     grandchild_ = FakeContentLayer::Create(&client_);
 
     root_->AddChild(child_);
     child_->AddChild(grandchild_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     LayerTreeHostContextTest::DidActivateTreeOnThread(host_impl);
 
     FakeContentLayerImpl* root = static_cast<FakeContentLayerImpl*>(
         host_impl->active_tree()->root_layer());
-    FakeContentLayerImpl* child = static_cast<FakeContentLayerImpl*>(
-        root->children()[0]);
-    FakeContentLayerImpl* grandchild = static_cast<FakeContentLayerImpl*>(
-        child->children()[0]);
+    FakeContentLayerImpl* child =
+        static_cast<FakeContentLayerImpl*>(root->children()[0]);
+    FakeContentLayerImpl* grandchild =
+        static_cast<FakeContentLayerImpl*>(child->children()[0]);
 
     ++num_commits_;
     switch (num_commits_) {
       case 1:
         EXPECT_EQ(0u, root->lost_output_surface_count());
         EXPECT_EQ(0u, child->lost_output_surface_count());
         EXPECT_EQ(0u, grandchild->lost_output_surface_count());
         // Lose the context and struggle to recreate it.
         LoseContext();
         times_to_fail_create_ = 1;
@@ skipping 18 matching lines @@
   scoped_refptr<FakeContentLayer> root_;
   scoped_refptr<FakeContentLayer> child_;
   scoped_refptr<FakeContentLayer> grandchild_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestLayersNotified);
 
 class LayerTreeHostContextTestDontUseLostResources
     : public LayerTreeHostContextTest {
  public:
-  LayerTreeHostContextTestDontUseLostResources()
-      : lost_context_(false) {
+  LayerTreeHostContextTestDontUseLostResources() : lost_context_(false) {
     context_should_support_io_surface_ = true;
 
     child_output_surface_ = FakeOutputSurface::Create3d();
     child_output_surface_->BindToClient(&output_surface_client_);
-    child_resource_provider_ =
-        ResourceProvider::Create(child_output_surface_.get(),
-                                 NULL,
-                                 0,
-                                 false,
-                                 1);
+    child_resource_provider_ = ResourceProvider::Create(
+        child_output_surface_.get(), NULL, 0, false, 1);
   }
 
   static void EmptyReleaseCallback(unsigned sync_point, bool lost) {}
 
   virtual void SetupTree() OVERRIDE {
-    blink::WebGraphicsContext3D* context3d =
-        child_output_surface_->context_provider()->Context3d();
+    gpu::gles2::GLES2Interface* gl =
+        child_output_surface_->context_provider()->ContextGL();
 
     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
 
     scoped_ptr<TestRenderPass> pass_for_quad = TestRenderPass::Create();
     pass_for_quad->SetNew(
         // AppendOneOfEveryQuadType() makes a RenderPass quad with this id.
         RenderPass::Id(2, 1),
         gfx::Rect(0, 0, 10, 10),
         gfx::Rect(0, 0, 10, 10),
         gfx::Transform());
@@ skipping 16 matching lines @@
     ResourceProvider::ResourceId resource =
         child_resource_provider_->CreateResource(
             gfx::Size(4, 4),
             GL_CLAMP_TO_EDGE,
             ResourceProvider::TextureUsageAny,
             RGBA_8888);
     ResourceProvider::ScopedWriteLockGL lock(child_resource_provider_.get(),
                                              resource);
 
     gpu::Mailbox mailbox;
-    context3d->genMailboxCHROMIUM(mailbox.name);
-    unsigned sync_point = context3d->insertSyncPoint();
+    gl->GenMailboxCHROMIUM(mailbox.name);
+    GLuint sync_point = gl->InsertSyncPointCHROMIUM();
 
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetAnchorPoint(gfx::PointF());
     root->SetIsDrawable(true);
 
     scoped_refptr<FakeDelegatedRendererLayer> delegated =
         FakeDelegatedRendererLayer::Create(delegated_frame_provider_.get());
     delegated->SetBounds(gfx::Size(10, 10));
     delegated->SetAnchorPoint(gfx::PointF());
     delegated->SetIsDrawable(true);
     root->AddChild(delegated);
 
     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::CreateForMailbox(NULL);
     texture->SetBounds(gfx::Size(10, 10));
     texture->SetAnchorPoint(gfx::PointF());
     texture->SetIsDrawable(true);
     texture->SetTextureMailbox(
         TextureMailbox(mailbox, sync_point),
-        SingleReleaseCallback::Create(base::Bind(
-            &LayerTreeHostContextTestDontUseLostResources::
-                EmptyReleaseCallback)));
+        SingleReleaseCallback::Create(
+            base::Bind(&LayerTreeHostContextTestDontUseLostResources::
+                            EmptyReleaseCallback)));
     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());
@@ skipping 98 matching lines @@
                                      LayerTreeHostImpl::FrameData* frame,
                                      bool result) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() == 2) {
       // Lose the context during draw on the second commit. This will cause
       // a third commit to recover.
       context3d_->set_times_bind_texture_succeeds(0);
     }
     return true;
   }
 
-  virtual scoped_ptr<OutputSurface> CreateOutputSurface(
-      bool fallback) OVERRIDE {
+  virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
+      OVERRIDE {
     // This will get called twice:
     // First when we create the initial output surface...
     if (layer_tree_host()->source_frame_number() > 0) {
       // ... and then again after we forced the context to be lost on the third
       // frame. Verify this assumption here.
       lost_context_ = true;
       EXPECT_EQ(layer_tree_host()->source_frame_number(), 3);
     }
     return LayerTreeHostContextTest::CreateOutputSurface(fallback);
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     ASSERT_TRUE(layer_tree_host()->hud_layer());
     // End the test once we know the 3nd frame drew.
     if (layer_tree_host()->source_frame_number() < 4) {
       layer_tree_host()->root_layer()->SetNeedsDisplay();
       layer_tree_host()->SetNeedsCommit();
     } else {
       EndTest();
     }
   }
 
-  virtual void AfterTest() OVERRIDE {
-    EXPECT_TRUE(lost_context_);
-  }
+  virtual void AfterTest() OVERRIDE { EXPECT_TRUE(lost_context_); }
 
  private:
   FakeContentLayerClient client_;
   bool lost_context_;
 
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> child_output_surface_;
   scoped_ptr<ResourceProvider> child_resource_provider_;
 
   scoped_refptr<DelegatedFrameResourceCollection>
@@ skipping 20 matching lines @@
     ASSERT_TRUE(layer_tree_host()->output_surface_lost());
 
     times_output_surface_created_ = 0;
 
     // Post the SetNeedsCommit before the readback to make sure it is run
     // on the main thread before the readback's replacement commit when
     // we have a threaded compositor.
     PostSetNeedsCommitToMainThread();
 
     char pixels[4];
-    bool result = 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_);
   }
 
   virtual void DidInitializeOutputSurface(bool succeeded) OVERRIDE {
     EXPECT_TRUE(succeeded);
     ++times_output_surface_created_;
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
-    EndTest();
-  }
+  virtual void DidCommitAndDrawFrame() OVERRIDE { EndTest(); }
 
   virtual void AfterTest() OVERRIDE {
     // Should not try to create output surface again after successfully
     // created by CompositeAndReadback.
     EXPECT_EQ(1, times_output_surface_created_);
   }
 
   virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                      LayerTreeHostImpl::FrameData* frame_data,
                                      bool result) OVERRIDE {
@@ skipping 233 matching lines @@
 };
 
 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_ = FakePaintedScrollbarLayer::Create(
-        false, true, scroll_layer->id());
+    scrollbar_layer_ =
+        FakePaintedScrollbarLayer::Create(false, true, scroll_layer->id());
     scrollbar_layer_->SetBounds(gfx::Size(10, 100));
     layer_tree_host()->root_layer()->AddChild(scrollbar_layer_);
     layer_tree_host()->root_layer()->AddChild(scroll_layer);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
@@ skipping 47 matching lines @@
   // DidActivateTreeOnThread, which happens after DidCommit with impl-side
   // painting.
   virtual void StepCompleteOnMainThread(int time_step) = 0;
 
   // Called after DidActivateTreeOnThread. If this is done during the commit,
   // the call to StepCompleteOnMainThread will not occur until after
   // the commit completes, because the main thread is blocked.
   void PostStepCompleteToMainThread() {
     proxy()->MainThreadTaskRunner()->PostTask(
         FROM_HERE,
-        base::Bind(
-            &UIResourceLostTest::StepCompleteOnMainThreadInternal,
-            base::Unretained(this),
-            time_step_));
+        base::Bind(&UIResourceLostTest::StepCompleteOnMainThreadInternal,
+                   base::Unretained(this),
+                   time_step_));
   }
 
   void PostLoseContextToImplThread() {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
     base::SingleThreadTaskRunner* task_runner =
         HasImplThread() ? ImplThreadTaskRunner()
                         : base::MessageLoopProxy::current();
-    task_runner->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &LayerTreeHostContextTest::LoseContext,
-            base::Unretained(this)));
+    task_runner->PostTask(FROM_HERE,
+                          base::Bind(&LayerTreeHostContextTest::LoseContext,
+                                     base::Unretained(this)));
   }
 
  protected:
   int time_step_;
   scoped_ptr<FakeScopedUIResource> ui_resource_;
 
  private:
   void StepCompleteOnMainThreadInternal(int step) {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
     StepCompleteOnMainThread(step);
@@ skipping 81 matching lines @@
 // of creation/deletion are considered:
 // 1. Create one resource -> Context Lost => Expect the resource to have been
 // created.
 // 2. Delete an exisiting resource (test_id0_) -> create a second resource
 // (test_id1_) -> Context Lost => Expect the test_id0_ to be removed and
 // test_id1_ to have been created.
 // 3. Create one resource -> Delete that same resource -> Context Lost => Expect
 // the resource to not exist in the manager.
 class UIResourceLostBeforeCommit : public UIResourceLostTestSimple {
  public:
-  UIResourceLostBeforeCommit()
-      : test_id0_(0),
-        test_id1_(0) {}
+  UIResourceLostBeforeCommit() : test_id0_(0), test_id1_(0) {}
 
   virtual void StepCompleteOnMainThread(int step) OVERRIDE {
     switch (step) {
       case 0:
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         // Lose the context on the impl thread before the commit.
         PostLoseContextToImplThread();
         break;
       case 2:
         // Sequence 2:
@@ skipping 204 matching lines @@
         ui_resource_.reset();
         EndTest();
         break;
       case 4:
         NOTREACHED();
     }
   }
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* impl,
                                        bool visible) OVERRIDE {
-    TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
-        impl->output_surface()->context_provider()->Context3d());
+    TestWebGraphicsContext3D* context = TestContext();
     if (!visible) {
       // All resources should have been evicted.
       ASSERT_EQ(0u, context->NumTextures());
       EXPECT_EQ(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
       EXPECT_EQ(2, ui_resource_->resource_create_count);
       EXPECT_EQ(1, ui_resource_->lost_resource_count);
       // Drawing is disabled both because of the evicted resources and
       // because the renderer is not visible.
       EXPECT_FALSE(impl->CanDraw());
       // Make the renderer visible again.
       PostSetVisibleToMainThread(true);
     }
   }
 
   virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
-    TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
-        impl->output_surface()->context_provider()->Context3d());
+    TestWebGraphicsContext3D* context = TestContext();
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
       case 1:
         // The resource should have been created on LTHI after the commit.
         ASSERT_EQ(1u, context->NumTextures());
         EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
         EXPECT_EQ(1, ui_resource_->resource_create_count);
         EXPECT_EQ(0, ui_resource_->lost_resource_count);
         EXPECT_TRUE(impl->CanDraw());
         // Evict all UI resources. This will trigger a commit.
@@ skipping 34 matching lines @@
       : LayerTreeHostContextTest(),
         layer_(FakeContentLayer::Create(&client_)),
         num_commits_(0) {}
 
   virtual void SetupTree() OVERRIDE {
     layer_->SetBounds(gfx::Size(10, 20));
     layer_tree_host()->SetRootLayer(layer_);
     LayerTreeHostContextTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidCommit() OVERRIDE {
     switch (num_commits_) {
       case 0:
         EXPECT_EQ(1u, layer_->output_surface_created_count());
         layer_tree_host()->SetNeedsCommit();
         break;
       case 1:
         EXPECT_EQ(1u, layer_->output_surface_created_count());
         layer_tree_host()->SetNeedsCommit();
@@ skipping 34 matching lines @@
  protected:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> layer_;
   int num_commits_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestSurfaceCreateCallback);
 
 }  // namespace
 }  // namespace cc