Remove WebGraphicsContext3D getter from cc::ContextProvider

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 47 matching lines @@
 #include "ui/gfx/vector2d_conversions.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::Mock;
 
 namespace cc {
 namespace {
 
-class LayerTreeHostTest : public LayerTreeTest {
-};
+class LayerTreeHostTest : public LayerTreeTest {};
 
 // Two setNeedsCommits in a row should lead to at least 1 commit and at least 1
 // draw with frame 0.
 class LayerTreeHostTestSetNeedsCommit1 : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsCommit1() : num_commits_(0), num_draws_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
     PostSetNeedsCommitToMainThread();
@@ skipping 189 matching lines @@
 MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedraw);
 
 // After setNeedsRedrawRect(invalid_rect) the final damage_rect
 // must contain invalid_rect.
 class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsRedrawRect()
       : num_draws_(0),
         bounds_(50, 50),
         invalid_rect_(10, 10, 20, 20),
-        root_layer_(ContentLayer::Create(&client_)) {
-  }
+        root_layer_(ContentLayer::Create(&client_)) {}
 
   virtual void BeginTest() OVERRIDE {
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
@@ skipping 18 matching lines @@
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (!num_draws_) {
       PostSetNeedsRedrawRectToMainThread(invalid_rect_);
     } else {
       EndTest();
     }
     num_draws_++;
   }
 
-  virtual void AfterTest() OVERRIDE {
-    EXPECT_EQ(2, num_draws_);
-  }
+  virtual void AfterTest() OVERRIDE { EXPECT_EQ(2, num_draws_); }
 
  private:
   int num_draws_;
   const gfx::Size bounds_;
   const gfx::Rect invalid_rect_;
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayer> root_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedrawRect);
 
 class LayerTreeHostTestNoExtraCommitFromInvalidate : public LayerTreeHostTest {
  public:
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
   virtual void SetupTree() OVERRIDE {
     root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 20));
 
     scaled_layer_ = FakeContentLayer::Create(&client_);
     scaled_layer_->SetBounds(gfx::Size(1, 1));
     root_layer_->AddChild(scaled_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
   virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Changing the device scale factor causes a commit. It also changes
@@ skipping 37 matching lines @@
         paint_scrollbar, has_thumb, root_layer_->id());
     scrollbar_->SetPosition(gfx::Point(0, 10));
     scrollbar_->SetBounds(gfx::Size(10, 10));
 
     root_layer_->AddChild(scrollbar_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
   virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Changing the device scale factor causes a commit. It also changes
@@ skipping 214 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestCompositeAndReadbackAfterForcedDraw);
 
 class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNextCommitForcesRedraw()
       : num_draws_(0),
         bounds_(50, 50),
         invalid_rect_(10, 10, 20, 20),
-        root_layer_(ContentLayer::Create(&client_)) {
-  }
+        root_layer_(ContentLayer::Create(&client_)) {}
 
   virtual void BeginTest() OVERRIDE {
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ skipping 51 matching lines @@
       case 3:
         host_impl->BlockNotifyReadyToActivateForTesting(false);
         break;
       default:
         EndTest();
         break;
     }
     num_draws_++;
   }
 
-  virtual void AfterTest() OVERRIDE {
-    EXPECT_EQ(5, num_draws_);
-  }
+  virtual void AfterTest() OVERRIDE { EXPECT_EQ(5, num_draws_); }
 
  private:
   int num_draws_;
   const gfx::Size bounds_;
   const gfx::Rect invalid_rect_;
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayer> root_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNextCommitForcesRedraw);
 
 // Tests that if a layer is not drawn because of some reason in the parent then
 // its damage is preserved until the next time it is drawn.
 class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
  public:
   LayerTreeHostTestUndrawnLayersDamageLater()
-      : root_layer_(ContentLayer::Create(&client_)) {
-  }
+      : root_layer_(ContentLayer::Create(&client_)) {}
 
   virtual void SetupTree() OVERRIDE {
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(50, 50));
     layer_tree_host()->SetRootLayer(root_layer_);
 
     // The initially transparent layer has a larger child layer, which is
     // not initially drawn because of the this (parent) layer.
     parent_layer_ = FakeContentLayer::Create(&client_);
     parent_layer_->SetBounds(gfx::Size(15, 15));
     parent_layer_->SetOpacity(0.0f);
     root_layer_->AddChild(parent_layer_);
 
     child_layer_ = FakeContentLayer::Create(&client_);
     child_layer_->SetBounds(gfx::Size(25, 25));
     parent_layer_->AddChild(child_layer_);
 
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                      LayerTreeHostImpl::FrameData* frame_data,
                                      bool result) OVERRIDE {
     EXPECT_TRUE(result);
 
     gfx::RectF root_damage_rect;
     if (!frame_data->render_passes.empty())
       root_damage_rect = frame_data->render_passes.back()->damage_rect;
 
@@ skipping 33 matching lines @@
         parent_layer_->SetForceRenderSurface(true);
         break;
       case 4:
         EndTest();
         break;
       default:
         NOTREACHED();
     }
   }
 
-
   virtual void AfterTest() OVERRIDE {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayer> root_layer_;
   scoped_refptr<FakeContentLayer> parent_layer_;
   scoped_refptr<FakeContentLayer> child_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestUndrawnLayersDamageLater);
@@ skipping 197 matching lines @@
   LayerTreeHostTestFrameTimeUpdatesAfterActivationFails()
       : frame_count_with_pending_tree_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void BeginCommitOnThread(LayerTreeHostImpl *impl) OVERRIDE {
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     EXPECT_EQ(frame_count_with_pending_tree_, 0);
     impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
   virtual void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
                                           const BeginFrameArgs& args) OVERRIDE {
     if (impl->pending_tree())
       frame_count_with_pending_tree_++;
 
     if (frame_count_with_pending_tree_ == 2)
@@ skipping 49 matching lines @@
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     frame_++;
     if (frame_ == 1) {
       first_frame_time_ = impl->CurrentFrameTimeTicks();
       impl->SetNeedsRedraw();
 
       // Since we might use a low-resolution clock on Windows, we need to
       // make sure that the clock has incremented past first_frame_time_.
-      while (first_frame_time_ == gfx::FrameTime::Now()) {}
+      while (first_frame_time_ == gfx::FrameTime::Now()) {
+      }
 
       return;
     }
 
     EXPECT_NE(first_frame_time_, impl->CurrentFrameTimeTicks());
     EndTest();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     // Ensure there isn't a commit between the two draws, to ensure that a
     // commit isn't required for updating the current frame time. We can
     // only check for this in the multi-threaded case, since in the single-
     // threaded case there will always be a commit between consecutive draws.
     if (HasImplThread())
       EXPECT_EQ(0, frame_);
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int frame_;
   base::TimeTicks first_frame_time_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestFrameTimeUpdatesAfterDraw);
 
 // Verifies that StartPageScaleAnimation events propagate correctly
 // from LayerTreeHost to LayerTreeHostImpl in the MT compositor.
-class LayerTreeHostTestStartPageScaleAnimation
-    : public LayerTreeHostTest {
+class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
  public:
   LayerTreeHostTestStartPageScaleAnimation() {}
 
   virtual void SetupTree() OVERRIDE {
     LayerTreeHostTest::SetupTree();
 
     if (layer_tree_host()->settings().impl_side_painting) {
       scoped_refptr<FakePictureLayer> layer =
           FakePictureLayer::Create(&client_);
       layer->set_always_update_resources(true);
       scroll_layer_ = layer;
     } else {
       scroll_layer_ = FakeContentLayer::Create(&client_);
     }
 
     scroll_layer_->SetScrollable(true);
     scroll_layer_->SetScrollOffset(gfx::Vector2d());
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 2.f);
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta, float scale)
-      OVERRIDE {
+  virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta,
+                                   float scale) OVERRIDE {
     gfx::Vector2d offset = scroll_layer_->scroll_offset();
     scroll_layer_->SetScrollOffset(offset + scroll_delta);
     layer_tree_host()->SetPageScaleFactorAndLimits(scale, 0.5f, 2.f);
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // We get one commit before the first draw, and the animation doesn't happen
     // until the second draw.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
@@ skipping 299 matching lines @@
   }
 
   virtual void BeginTest() OVERRIDE {
     drew_frame_ = -1;
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ASSERT_EQ(0u, layer_tree_host()->settings().max_partial_texture_updates);
 
-    TestWebGraphicsContext3D* context = static_cast<TestContextProvider*>(
-        impl->output_surface()->context_provider().get())->TestContext3d();
+    TestWebGraphicsContext3D* context = TestContext();
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         // Number of textures should be one for each layer
         ASSERT_EQ(2u, context->NumTextures());
         // Number of textures used for commit should be one for each layer.
         EXPECT_EQ(2u, context->NumUsedTextures());
         // Verify that used texture is correct.
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(0)));
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(1)));
@@ skipping 20 matching lines @@
       case 2:
         EndTest();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    TestWebGraphicsContext3D* context = static_cast<TestContextProvider*>(
-        impl->output_surface()->context_provider().get())->TestContext3d();
+    TestWebGraphicsContext3D* context = TestContext();
 
     if (drew_frame_ == impl->active_tree()->source_frame_number()) {
       EXPECT_EQ(0u, context->NumUsedTextures()) << "For frame " << drew_frame_;
       return;
     }
     drew_frame_ = impl->active_tree()->source_frame_number();
 
     // We draw/ship one texture each frame for each layer.
     EXPECT_EQ(2u, context->NumUsedTextures());
     context->ResetUsedTextures();
@@ skipping 15 matching lines @@
 
 MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(
     LayerTreeHostTestDirectRendererAtomicCommit);
 
 class LayerTreeHostTestDelegatingRendererAtomicCommit
     : public LayerTreeHostTestDirectRendererAtomicCommit {
  public:
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ASSERT_EQ(0u, layer_tree_host()->settings().max_partial_texture_updates);
 
-    TestWebGraphicsContext3D* context = static_cast<TestContextProvider*>(
-        impl->output_surface()->context_provider().get())->TestContext3d();
+    TestWebGraphicsContext3D* context = TestContext();
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         // Number of textures should be one for each layer
         ASSERT_EQ(2u, context->NumTextures());
         // Number of textures used for commit should be one for each layer.
         EXPECT_EQ(2u, context->NumUsedTextures());
         // Verify that used texture is correct.
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(0)));
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(1)));
@@ skipping 67 matching lines @@
     child_ = FakeContentLayer::Create(&client_);
     child_->SetPosition(gfx::Point(0, 10));
     child_->SetBounds(gfx::Size(3, 10));
 
     parent_->AddChild(child_);
 
     layer_tree_host()->SetRootLayer(parent_);
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         parent_->SetNeedsDisplay();
         child_->SetNeedsDisplay();
         break;
       case 2:
         // Damage part of layers.
         parent_->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
@@ skipping 11 matching lines @@
         break;
       default:
         NOTREACHED() << layer_tree_host()->source_frame_number();
         break;
     }
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ASSERT_EQ(1u, layer_tree_host()->settings().max_partial_texture_updates);
 
-    TestWebGraphicsContext3D* context = static_cast<TestContextProvider*>(
-        impl->output_surface()->context_provider().get())->TestContext3d();
+    TestWebGraphicsContext3D* context = TestContext();
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         // Number of textures should be one for each layer.
         ASSERT_EQ(2u, context->NumTextures());
         // Number of textures used for commit should be one for each layer.
         EXPECT_EQ(2u, context->NumUsedTextures());
         // Verify that used textures are correct.
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(0)));
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(1)));
@@ skipping 69 matching lines @@
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     EXPECT_LT(impl->active_tree()->source_frame_number(), 5);
 
-    TestWebGraphicsContext3D* context = static_cast<TestContextProvider*>(
-        impl->output_surface()->context_provider().get())->TestContext3d();
+    TestWebGraphicsContext3D* context = TestContext();
 
     // Number of textures used for drawing should one per layer except for
     // frame 3 where the viewport only contains one layer.
     if (impl->active_tree()->source_frame_number() == 3) {
       EXPECT_EQ(1u, context->NumUsedTextures());
     } else {
-      EXPECT_EQ(2u, context->NumUsedTextures()) <<
-        "For frame " << impl->active_tree()->source_frame_number();
+      EXPECT_EQ(2u, context->NumUsedTextures())
+          << "For frame " << impl->active_tree()->source_frame_number();
     }
 
     context->ResetUsedTextures();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> parent_;
@@ skipping 86 matching lines @@
     replica_layer1_ = FakeContentLayer::Create(&client_);
     surface_layer1_->SetReplicaLayer(replica_layer1_.get());
 
     replica_layer2_ = FakeContentLayer::Create(&client_);
     surface_layer2_->SetReplicaLayer(replica_layer2_.get());
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     Renderer* renderer = host_impl->renderer();
     RenderPass::Id surface1_render_pass_id = host_impl->active_tree()
-        ->root_layer()->children()[0]->render_surface()->RenderPassId();
-    RenderPass::Id surface2_render_pass_id =
-        host_impl->active_tree()->root_layer()->children()[0]->children()[0]
-        ->render_surface()->RenderPassId();
+                                                 ->root_layer()
+                                                 ->children()[0]
+                                                 ->render_surface()
+                                                 ->RenderPassId();
+    RenderPass::Id surface2_render_pass_id = host_impl->active_tree()
+                                                 ->root_layer()
+                                                 ->children()[0]
+                                                 ->children()[0]
+                                                 ->render_surface()
+                                                 ->RenderPassId();
 
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_TRUE(renderer->HasAllocatedResourcesForTesting(
-            surface1_render_pass_id));
-        EXPECT_TRUE(renderer->HasAllocatedResourcesForTesting(
-            surface2_render_pass_id));
+        EXPECT_TRUE(
+            renderer->HasAllocatedResourcesForTesting(surface1_render_pass_id));
+        EXPECT_TRUE(
+            renderer->HasAllocatedResourcesForTesting(surface2_render_pass_id));
 
         // Reduce the memory limit to only fit the root layer and one render
         // surface. This prevents any contents drawing into surfaces
         // from being allocated.
         host_impl->SetMemoryPolicy(ManagedMemoryPolicy(100 * 100 * 4 * 2));
         break;
       case 1:
-        EXPECT_FALSE(renderer->HasAllocatedResourcesForTesting(
-            surface1_render_pass_id));
-        EXPECT_FALSE(renderer->HasAllocatedResourcesForTesting(
-            surface2_render_pass_id));
+        EXPECT_FALSE(
+            renderer->HasAllocatedResourcesForTesting(surface1_render_pass_id));
+        EXPECT_FALSE(
+            renderer->HasAllocatedResourcesForTesting(surface2_render_pass_id));
 
         EndTest();
         break;
     }
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     if (layer_tree_host()->source_frame_number() < 2)
       root_layer_->SetNeedsDisplay();
   }
@@ skipping 15 matching lines @@
 // Surfaces don't exist with a delegated renderer.
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(
     LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit);
 
 class EvictionTestLayer : public Layer {
  public:
   static scoped_refptr<EvictionTestLayer> Create() {
     return make_scoped_refptr(new EvictionTestLayer());
   }
 
-  virtual bool Update(ResourceUpdateQueue*,
-                      const OcclusionTracker*) OVERRIDE;
+  virtual bool Update(ResourceUpdateQueue*, const OcclusionTracker*) OVERRIDE;
   virtual bool DrawsContent() const OVERRIDE { return true; }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
       OVERRIDE;
   virtual void PushPropertiesTo(LayerImpl* impl) OVERRIDE;
   virtual void SetTexturePriorities(const PriorityCalculator&) OVERRIDE;
 
   bool HaveBackingTexture() const {
     return texture_.get() ? texture_->have_backing_texture() : false;
   }
@@ skipping 471 matching lines @@
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
                                        bool visible) OVERRIDE {
     if (visible) {
       // One backing should remain unevicted.
       EXPECT_EQ(
           100u * 100u * 4u * 1u,
           layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
     } else {
       EXPECT_EQ(
-          0u,
-          layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
+          0u, layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
     }
 
     // Make sure that contents textures are marked as having been
     // purged.
     EXPECT_TRUE(host_impl->active_tree()->ContentsTexturesPurged());
     // End the test in this state.
     EndTest();
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ skipping 135 matching lines @@
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->begin_impl_frame_scheduling_enabled = true;
   }
 
   virtual void BeginTest() OVERRIDE {
     // This will trigger a SetNeedsBeginImplFrame which will trigger a
     // BeginImplFrame.
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual bool PrepareToDrawOnThread(
-      LayerTreeHostImpl* host_impl,
-      LayerTreeHostImpl::FrameData* frame,
-      bool result) OVERRIDE {
+  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+                                     LayerTreeHostImpl::FrameData* frame,
+                                     bool result) OVERRIDE {
     EndTest();
     return true;
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   base::TimeTicks frame_time_;
 };
 
@@ skipping 38 matching lines @@
   virtual void DidCommit() OVERRIDE {
     commit_count_++;
     if (commit_count_ == 4) {
       // After two aborted commits, request a real commit now to make sure a
       // real commit following an aborted commit will still complete and
       // end the test even when the Impl thread is idle.
       layer_tree_host()->SetNeedsCommit();
     }
   }
 
-  virtual void BeginMainFrameAbortedOnThread(
-      LayerTreeHostImpl *host_impl, bool did_handle) OVERRIDE {
+  virtual void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
+                                             bool did_handle) OVERRIDE {
     commit_abort_count_++;
     // Initiate another abortable commit.
     host_impl->SetNeedsCommit();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     commit_complete_count_++;
     if (commit_complete_count_ == 1) {
       // Initiate an abortable commit after the first commit.
       host_impl->SetNeedsCommit();
@@ skipping 43 matching lines @@
 
   virtual void SetupTree() OVERRIDE {
     LayerTreeHostTest::SetupTree();
 
     scoped_refptr<Layer> layer = PictureLayer::Create(&client_);
     layer->SetTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
     layer->SetBounds(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->AddChild(layer);
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
-  }
+  virtual void AfterTest() OVERRIDE {}
 
   FakeContentLayerClient client_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation);
 
 class LayerTreeHostTestChangeLayerPropertiesInPaintContents
     : public LayerTreeHostTest {
  public:
@@ skipping 53 matching lines @@
 class MockIOSurfaceWebGraphicsContext3D : public TestWebGraphicsContext3D {
  public:
   MockIOSurfaceWebGraphicsContext3D() {
     test_capabilities_.gpu.iosurface = true;
     test_capabilities_.gpu.texture_rectangle = true;
   }
 
   virtual GLuint createTexture() OVERRIDE {
     return 1;
   }
-
   MOCK_METHOD1(activeTexture, void(GLenum texture));
   MOCK_METHOD2(bindTexture, void(GLenum target,
                                  GLuint texture_id));
   MOCK_METHOD3(texParameteri, void(GLenum target,
                                    GLenum pname,
                                    GLint param));
   MOCK_METHOD5(texImageIOSurface2DCHROMIUM, void(GLenum target,
                                                  GLint width,
                                                  GLint height,
                                                  GLuint ioSurfaceId,
                                                  GLuint plane));
   MOCK_METHOD4(drawElements, void(GLenum mode,
                                   GLsizei count,
                                   GLenum type,
                                   GLintptr offset));
   MOCK_METHOD1(deleteTexture, void(GLenum texture));
 };
 
-
 class LayerTreeHostTestIOSurfaceDrawing : public LayerTreeHostTest {
  protected:
-  virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
-      OVERRIDE {
+  virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurfaceForTest(
+      bool fallback) OVERRIDE {
     scoped_ptr<MockIOSurfaceWebGraphicsContext3D> mock_context_owned(
         new MockIOSurfaceWebGraphicsContext3D);
     mock_context_ = mock_context_owned.get();
 
-    scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
-        mock_context_owned.PassAs<TestWebGraphicsContext3D>()));
-    return output_surface.Pass();
+    return FakeOutputSurface::Create3d(
+        mock_context_owned.PassAs<TestWebGraphicsContext3D>());
   }
 
   virtual void SetupTree() OVERRIDE {
     LayerTreeHostTest::SetupTree();
 
     layer_tree_host()->root_layer()->SetIsDrawable(false);
 
     io_surface_id_ = 9;
     io_surface_size_ = gfx::Size(6, 7);
 
     scoped_refptr<IOSurfaceLayer> io_surface_layer = IOSurfaceLayer::Create();
     io_surface_layer->SetBounds(gfx::Size(10, 10));
     io_surface_layer->SetAnchorPoint(gfx::PointF());
     io_surface_layer->SetIsDrawable(true);
     io_surface_layer->SetIOSurfaceProperties(io_surface_id_, io_surface_size_);
     layer_tree_host()->root_layer()->AddChild(io_surface_layer);
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     // In WillDraw, the IOSurfaceLayer sets up the io surface texture.
 
-    EXPECT_CALL(*mock_context_, activeTexture(_))
-        .Times(0);
+    EXPECT_CALL(*mock_context_, activeTexture(_)).Times(0);
     EXPECT_CALL(*mock_context_, bindTexture(GL_TEXTURE_RECTANGLE_ARB, 1))
         .Times(AtLeast(1));
-    EXPECT_CALL(*mock_context_, texParameteri(GL_TEXTURE_RECTANGLE_ARB,
-                                              GL_TEXTURE_MIN_FILTER,
-                                              GL_LINEAR))
+    EXPECT_CALL(*mock_context_,
+                texParameteri(
+                    GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR))
         .Times(1);
-    EXPECT_CALL(*mock_context_, texParameteri(GL_TEXTURE_RECTANGLE_ARB,
-                                              GL_TEXTURE_MAG_FILTER,
-                                              GL_LINEAR))
+    EXPECT_CALL(*mock_context_,
+                texParameteri(
+                    GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR))
         .Times(1);
-    EXPECT_CALL(*mock_context_, texParameteri(GL_TEXTURE_RECTANGLE_ARB,
-                                              GL_TEXTURE_WRAP_S,
-                                              GL_CLAMP_TO_EDGE))
-        .Times(1);
-    EXPECT_CALL(*mock_context_, texParameteri(GL_TEXTURE_RECTANGLE_ARB,
-                                              GL_TEXTURE_WRAP_T,
-                                              GL_CLAMP_TO_EDGE))
-        .Times(1);
+    EXPECT_CALL(*mock_context_,
+                texParameteri(GL_TEXTURE_RECTANGLE_ARB,
+                              GL_TEXTURE_WRAP_S,
+                              GL_CLAMP_TO_EDGE)).Times(1);
+    EXPECT_CALL(*mock_context_,
+                texParameteri(GL_TEXTURE_RECTANGLE_ARB,
+                              GL_TEXTURE_WRAP_T,
+                              GL_CLAMP_TO_EDGE)).Times(1);
 
-    EXPECT_CALL(*mock_context_, texImageIOSurface2DCHROMIUM(
-        GL_TEXTURE_RECTANGLE_ARB,
-        io_surface_size_.width(),
-        io_surface_size_.height(),
-        io_surface_id_,
-        0))
-        .Times(1);
+    EXPECT_CALL(*mock_context_,
+                texImageIOSurface2DCHROMIUM(GL_TEXTURE_RECTANGLE_ARB,
+                                            io_surface_size_.width(),
+                                            io_surface_size_.height(),
+                                            io_surface_id_,
+                                            0)).Times(1);
 
-    EXPECT_CALL(*mock_context_, bindTexture(_, 0))
-        .Times(AnyNumber());
+    EXPECT_CALL(*mock_context_, bindTexture(_, 0)).Times(AnyNumber());
   }
 
-  virtual bool PrepareToDrawOnThread(
-      LayerTreeHostImpl* host_impl,
-      LayerTreeHostImpl::FrameData* frame,
-      bool result) OVERRIDE {
+  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+                                     LayerTreeHostImpl::FrameData* frame,
+                                     bool result) OVERRIDE {
     Mock::VerifyAndClearExpectations(&mock_context_);
 
     // The io surface layer's texture is drawn.
-    EXPECT_CALL(*mock_context_, activeTexture(GL_TEXTURE0))
-        .Times(AtLeast(1));
+    EXPECT_CALL(*mock_context_, activeTexture(GL_TEXTURE0)).Times(AtLeast(1));
     EXPECT_CALL(*mock_context_, bindTexture(GL_TEXTURE_RECTANGLE_ARB, 1))
         .Times(1);
     EXPECT_CALL(*mock_context_, drawElements(GL_TRIANGLES, 6, _, _))
         .Times(AtLeast(1));
 
     return result;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     Mock::VerifyAndClearExpectations(&mock_context_);
@@ skipping 137 matching lines @@
       ImplThreadTaskRunner()->PostTask(
           FROM_HERE,
           base::Bind(
               &LayerTreeHostTestDeferredInitialize::DeferredInitializeAndRedraw,
               base::Unretained(this),
               base::Unretained(host_impl)));
     } else if (did_initialize_gl_ && !did_release_gl_) {
       EXPECT_LE(2u, layer_impl->append_quads_count());
       ImplThreadTaskRunner()->PostTask(
           FROM_HERE,
-          base::Bind(
-              &LayerTreeHostTestDeferredInitialize::ReleaseGLAndRedraw,
-              base::Unretained(this),
-              base::Unretained(host_impl)));
+          base::Bind(&LayerTreeHostTestDeferredInitialize::ReleaseGLAndRedraw,
+                     base::Unretained(this),
+                     base::Unretained(host_impl)));
     } else if (did_initialize_gl_ && did_release_gl_) {
       EXPECT_LE(3u, layer_impl->append_quads_count());
       EndTest();
     }
   }
 
   void DeferredInitializeAndRedraw(LayerTreeHostImpl* host_impl) {
     EXPECT_FALSE(did_initialize_gl_);
     // SetAndInitializeContext3D calls SetNeedsCommit.
     FakeOutputSurface* fake_output_surface =
         static_cast<FakeOutputSurface*>(host_impl->output_surface());
     scoped_refptr<TestContextProvider> context_provider =
         TestContextProvider::Create();  // Not bound to thread.
-    EXPECT_TRUE(fake_output_surface->InitializeAndSetContext3d(
-        context_provider, NULL));
+    EXPECT_TRUE(
+        fake_output_surface->InitializeAndSetContext3d(context_provider, NULL));
     did_initialize_gl_ = true;
   }
 
   void ReleaseGLAndRedraw(LayerTreeHostImpl* host_impl) {
     EXPECT_TRUE(did_initialize_gl_);
     EXPECT_FALSE(did_release_gl_);
     // ReleaseGL calls SetNeedsCommit.
     static_cast<FakeOutputSurface*>(host_impl->output_surface())->ReleaseGL();
     did_release_gl_ = true;
   }
@@ skipping 50 matching lines @@
         PostSetNeedsCommitToMainThread();
         break;
       case 5:
         ClearResources();
         EndTest();
         break;
     }
   }
 
   void PerformTest(LayerTreeHostImpl* impl) {
-    TestWebGraphicsContext3D* context = static_cast<TestContextProvider*>(
-        impl->output_surface()->context_provider().get())->TestContext3d();
+    TestWebGraphicsContext3D* context = TestContext();
 
     int frame = num_commits_;
     switch (frame) {
       case 1:
         ASSERT_EQ(0u, context->NumTextures());
         break;
       case 2:
         // Created two textures.
         ASSERT_EQ(2u, context->NumTextures());
         break;
@@ skipping 61 matching lines @@
 
   size_t push_properties_count() const { return push_properties_count_; }
   void reset_push_properties_count() { push_properties_count_ = 0; }
 
   void set_persist_needs_push_properties(bool persist) {
     persist_needs_push_properties_ = persist;
   }
 
  private:
   PushPropertiesCountingLayer()
-      : push_properties_count_(0),
-        persist_needs_push_properties_(false) {
+      : push_properties_count_(0), persist_needs_push_properties_(false) {
     SetAnchorPoint(gfx::PointF());
     SetBounds(gfx::Size(1, 1));
     SetIsDrawable(true);
   }
   virtual ~PushPropertiesCountingLayer() {}
 
   size_t push_properties_count_;
   bool persist_needs_push_properties_;
 };
 
@@ skipping 185 matching lines @@
   size_t expected_push_properties_grandchild_;
   size_t expected_push_properties_other_root_;
   size_t expected_push_properties_leaf_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestLayersPushProperties);
 
 class LayerTreeHostTestPropertyChangesDuringUpdateArePushed
     : public LayerTreeHostTest {
  protected:
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void SetupTree() OVERRIDE {
     root_ = Layer::Create();
     root_->SetBounds(gfx::Size(1, 1));
 
     bool paint_scrollbar = true;
     bool has_thumb = false;
     scrollbar_layer_ = FakePaintedScrollbarLayer::Create(
         paint_scrollbar, has_thumb, root_->id());
 
@@ skipping 481 matching lines @@
       case 3:
         EXPECT_EQ(0, callback_count_);
         callback_count_ = 0;
         EndTest();
         break;
       default:
         ADD_FAILURE() << num_commits_;
         EndTest();
         break;
     }
-    return LayerTreeHostTest::PrepareToDrawOnThread(host_impl, frame_data,
-                                                    result);
+    return LayerTreeHostTest::PrepareToDrawOnThread(
+        host_impl, frame_data, result);
   }
 
-  virtual void AfterTest() OVERRIDE {
-    EXPECT_EQ(3, num_commits_);
+  virtual void AfterTest() OVERRIDE { EXPECT_EQ(3, num_commits_); }
+
+  void SetCallback(bool enable) {
+    output_surface()->SetTreeActivationCallback(
+        enable
+            ? base::Bind(
+                  &LayerTreeHostTestTreeActivationCallback::ActivationCallback,
+                  base::Unretained(this))
+            : base::Closure());
   }
 
-  void SetCallback(bool enable) {
-    output_surface()->SetTreeActivationCallback(enable ?
-        base::Bind(&LayerTreeHostTestTreeActivationCallback::ActivationCallback,
-                   base::Unretained(this)) :
-        base::Closure());
-  }
-
-  void ActivationCallback() {
-    ++callback_count_;
-  }
+  void ActivationCallback() { ++callback_count_; }
 
   int num_commits_;
   int callback_count_;
 };
 
 TEST_F(LayerTreeHostTestTreeActivationCallback, DirectRenderer) {
   RunTest(true, false, true);
 }
 
 TEST_F(LayerTreeHostTestTreeActivationCallback, DelegatingRenderer) {
   RunTest(true, true, true);
 }
 
 class LayerInvalidateCausesDraw : public LayerTreeHostTest {
  public:
   LayerInvalidateCausesDraw() : num_commits_(0), num_draws_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     ASSERT_TRUE(!!invalidate_layer_)
         << "Derived tests must set this in SetupTree";
 
     // One initial commit.
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     // After commit, invalidate the layer.  This should cause a commit.
     if (layer_tree_host()->source_frame_number() == 1)
-     invalidate_layer_->SetNeedsDisplay();
+      invalidate_layer_->SetNeedsDisplay();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_draws_++;
     if (impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_commits_++;
@@ skipping 223 matching lines @@
 // Commits can only be aborted when using the thread proxy.
 MULTI_THREAD_TEST_F(LayerTreeHostTestAbortEvictedTextures);
 
 class LayerTreeHostTestMaxTransferBufferUsageBytes : public LayerTreeHostTest {
  protected:
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->impl_side_painting = true;
     settings->default_tile_size = gfx::Size(128, 128);
   }
 
-  virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
-      OVERRIDE {
+  virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurfaceForTest(
+      bool fallback) OVERRIDE {
     scoped_refptr<TestContextProvider> context_provider =
         TestContextProvider::Create();
     context_provider->SetMaxTransferBufferUsageBytes(1024 * 1024);
-    return FakeOutputSurface::Create3d(context_provider)
-        .PassAs<OutputSurface>();
+    return FakeOutputSurface::Create3d(context_provider);
   }
 
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(6000, 6000));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    TestWebGraphicsContext3D* context = static_cast<TestContextProvider*>(
-        impl->output_surface()->context_provider().get())->TestContext3d();
+    TestWebGraphicsContext3D* context = TestContext();
 
     // Expect that the transfer buffer memory used is equal to the
     // MaxTransferBufferUsageBytes value set in CreateOutputSurface.
     // NOTE: This is now 1/2 due to raster memory limit in TileManager.
     //       Only half the limit will be reached unless the task set
     //       thrashes to a completly new set of tiles.
-    EXPECT_EQ(512 * 1024u,
-              context->GetPeakTransferBufferMemoryUsedBytes());
+    EXPECT_EQ(512 * 1024u, context->GetPeakTransferBufferMemoryUsedBytes());
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   FakeContentLayerClient client_;
 };
 
 // Impl-side painting is a multi-threaded compositor feature.
 MULTI_THREAD_TEST_F(LayerTreeHostTestMaxTransferBufferUsageBytes);
 
 // Test ensuring that memory limits are sent to the prioritized resource
 // manager.
 class LayerTreeHostTestMemoryLimits : public LayerTreeHostTest {
  public:
   LayerTreeHostTestMemoryLimits() : num_commits_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidCommit() OVERRIDE {
     int frame = num_commits_;
     switch (frame) {
       case 0:
         // Verify default values.
-        EXPECT_EQ(
-            PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
-            layer_tree_host()->contents_texture_manager()->
-                MaxMemoryLimitBytes());
-        EXPECT_EQ(
-            PriorityCalculator::AllowEverythingCutoff(),
-            layer_tree_host()->contents_texture_manager()->
-                ExternalPriorityCutoff());
+        EXPECT_EQ(PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
+                  layer_tree_host()
+                      ->contents_texture_manager()
+                      ->MaxMemoryLimitBytes());
+        EXPECT_EQ(PriorityCalculator::AllowEverythingCutoff(),
+                  layer_tree_host()
+                      ->contents_texture_manager()
+                      ->ExternalPriorityCutoff());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
         // The values should remain the same until the commit after the policy
         // is changed.
-        EXPECT_EQ(
-            PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
-            layer_tree_host()->contents_texture_manager()->
-                MaxMemoryLimitBytes());
-        EXPECT_EQ(
-            PriorityCalculator::AllowEverythingCutoff(),
-            layer_tree_host()->contents_texture_manager()->
-                ExternalPriorityCutoff());
+        EXPECT_EQ(PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
+                  layer_tree_host()
+                      ->contents_texture_manager()
+                      ->MaxMemoryLimitBytes());
+        EXPECT_EQ(PriorityCalculator::AllowEverythingCutoff(),
+                  layer_tree_host()
+                      ->contents_texture_manager()
+                      ->ExternalPriorityCutoff());
         break;
       case 2:
         // Verify values were correctly passed.
-        EXPECT_EQ(
-            16u*1024u*1024u,
-            layer_tree_host()->contents_texture_manager()->
-                MaxMemoryLimitBytes());
-        EXPECT_EQ(
-            PriorityCalculator::AllowVisibleAndNearbyCutoff(),
-            layer_tree_host()->contents_texture_manager()->
-                ExternalPriorityCutoff());
+        EXPECT_EQ(16u * 1024u * 1024u,
+                  layer_tree_host()
+                      ->contents_texture_manager()
+                      ->MaxMemoryLimitBytes());
+        EXPECT_EQ(PriorityCalculator::AllowVisibleAndNearbyCutoff(),
+                  layer_tree_host()
+                      ->contents_texture_manager()
+                      ->ExternalPriorityCutoff());
         EndTest();
         break;
       case 3:
         // Make sure no extra commits happen.
         NOTREACHED();
         break;
     }
 
     ++num_commits_;
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     int frame = num_commits_;
     switch (frame) {
       case 0:
         break;
       case 1:
         // This will trigger a commit because the priority cutoff has changed.
         impl->SetMemoryPolicy(ManagedMemoryPolicy(
-            16u*1024u*1024u,
+            16u * 1024u * 1024u,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
             1000));
         break;
       case 2:
         // This will not trigger a commit because the priority cutoff has not
         // changed, and there is already enough memory for all allocations.
         impl->SetMemoryPolicy(ManagedMemoryPolicy(
-            32u*1024u*1024u,
+            32u * 1024u * 1024u,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
             1000));
         break;
       case 3:
         NOTREACHED();
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ skipping 78 matching lines @@
   virtual void SetupTree() OVERRIDE {
     LayerTreeHostTest::SetupTree();
     root_layer_ = FakeContentLayer::Create(&client_);
     root_layer_->SetBounds(gfx::Size(10, 10));
     root_layer_->SetIsDrawable(false);
     root_layer_->SetHaveWheelEventHandlers(true);
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     FakeContentLayerImpl* layer_impl =
-          static_cast<FakeContentLayerImpl*>(impl->RootLayer());
+        static_cast<FakeContentLayerImpl*>(impl->RootLayer());
     EXPECT_FALSE(layer_impl->DrawsContent());
     EXPECT_EQ(0u, layer_impl->append_quads_count());
   }
 
   virtual void DidCommit() OVERRIDE {
     // The layer is not drawable, so it should not be updated.
     EXPECT_EQ(0u, root_layer_->update_count());
     EndTest();
   }
   virtual void AfterTest() OVERRIDE {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoQuadsForEmptyLayer);
 
-
 }  // namespace
 
 class LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface
     : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface()
       : first_output_surface_memory_limit_(4321234),
         second_output_surface_memory_limit_(1234321) {}
 
   virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
       OVERRIDE {
     if (!first_context_provider_) {
       first_context_provider_ = TestContextProvider::Create();
     } else {
       EXPECT_FALSE(second_context_provider_);
       second_context_provider_ = TestContextProvider::Create();
     }
 
-    scoped_ptr<FakeOutputSurface> output_surface(
-        FakeOutputSurface::Create3d(
-            second_context_provider_ ?
-                second_context_provider_ :
-                first_context_provider_));
-    output_surface->SetMemoryPolicyToSetAtBind(make_scoped_ptr(
-        new ManagedMemoryPolicy(
-            second_context_provider_ ?
-                second_output_surface_memory_limit_ :
-                first_output_surface_memory_limit_,
+    scoped_ptr<FakeOutputSurface> output_surface(FakeOutputSurface::Create3d(
+        second_context_provider_ ? second_context_provider_
+                                 : first_context_provider_));
+    output_surface->SetMemoryPolicyToSetAtBind(
+        make_scoped_ptr(new ManagedMemoryPolicy(
+            second_context_provider_ ? second_output_surface_memory_limit_
+                                     : first_output_surface_memory_limit_,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
             ManagedMemoryPolicy::kDefaultNumResourcesLimit)));
     return output_surface.PassAs<OutputSurface>();
   }
 
   virtual void SetupTree() OVERRIDE {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void BeginTest() OVERRIDE {
-    PostSetNeedsCommitToMainThread();
-  }
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     // Lost context sometimes takes two frames to recreate. The third frame
     // is sometimes aborted, so wait until the fourth frame to verify that
     // the memory has been set, and the fifth frame to end the test.
     if (layer_tree_host()->source_frame_number() < 5) {
       layer_tree_host()->SetNeedsCommit();
     } else if (layer_tree_host()->source_frame_number() == 5) {
       EndTest();
     }
   }
 
-  virtual void SwapBuffersOnThread(LayerTreeHostImpl *impl, bool result)
-      OVERRIDE {
+  virtual void SwapBuffersOnThread(LayerTreeHostImpl* impl,
+                                   bool result) OVERRIDE {
     switch (impl->active_tree()->source_frame_number()) {
       case 1:
         EXPECT_EQ(first_output_surface_memory_limit_,
                   impl->memory_allocation_limit_bytes());
         // Lose the output surface.
         first_context_provider_->TestContext3d()->loseContextCHROMIUM(
-            GL_GUILTY_CONTEXT_RESET_ARB,
-            GL_INNOCENT_CONTEXT_RESET_ARB);
+            GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
         break;
       case 4:
         EXPECT_EQ(second_output_surface_memory_limit_,
                   impl->memory_allocation_limit_bytes());
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
   scoped_refptr<TestContextProvider> first_context_provider_;
   scoped_refptr<TestContextProvider> second_context_provider_;
   size_t first_output_surface_memory_limit_;
   size_t second_output_surface_memory_limit_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_;
 };
 
 // No output to copy for delegated renderers.
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface);
 
 struct TestSwapPromiseResult {
-  TestSwapPromiseResult() : did_swap_called(false),
-                            did_not_swap_called(false),
-                            dtor_called(false),
-                            reason(SwapPromise::DID_NOT_SWAP_UNKNOWN) {
-  }
+  TestSwapPromiseResult()
+      : did_swap_called(false),
+        did_not_swap_called(false),
+        dtor_called(false),
+        reason(SwapPromise::DID_NOT_SWAP_UNKNOWN) {}
 
   bool did_swap_called;
   bool did_not_swap_called;
   bool dtor_called;
   SwapPromise::DidNotSwapReason reason;
   base::Lock lock;
 };
 
 class TestSwapPromise : public SwapPromise {
  public:
-  explicit TestSwapPromise(TestSwapPromiseResult* result)
-      : result_(result) {
-  }
+  explicit TestSwapPromise(TestSwapPromiseResult* result) : result_(result) {}
 
   virtual ~TestSwapPromise() {
     base::AutoLock lock(result_->lock);
     result_->dtor_called = true;
   }
 
   virtual void DidSwap(CompositorFrameMetadata* metadata) OVERRIDE {
     base::AutoLock lock(result_->lock);
     EXPECT_FALSE(result_->did_swap_called);
     EXPECT_FALSE(result_->did_not_swap_called);
     result_->did_swap_called = true;
   }
 
   virtual void DidNotSwap(DidNotSwapReason reason) OVERRIDE {
     base::AutoLock lock(result_->lock);
     EXPECT_FALSE(result_->did_swap_called);
     EXPECT_FALSE(result_->did_not_swap_called);
     result_->did_not_swap_called = true;
     result_->reason = reason;
   }
 
  private:
   // Not owned.
   TestSwapPromiseResult* result_;
 };
 
-class LayerTreeHostTestBreakSwapPromise
-    : public LayerTreeHostTest {
+class LayerTreeHostTestBreakSwapPromise : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestBreakSwapPromise()
-      : commit_count_(0), commit_complete_count_(0) {
-  }
+      : commit_count_(0), commit_complete_count_(0) {}
 
   virtual void WillBeginMainFrame() OVERRIDE {
     ASSERT_LE(commit_count_, 2);
-    scoped_ptr<SwapPromise> swap_promise(new TestSwapPromise(
-        &swap_promise_result_[commit_count_]));
+    scoped_ptr<SwapPromise> swap_promise(
+        new TestSwapPromise(&swap_promise_result_[commit_count_]));
     layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidCommit() OVERRIDE {
     commit_count_++;
     if (commit_count_ == 2) {
       // This commit will finish.
       layer_tree_host()->SetNeedsCommit();
@@ skipping 44 matching lines @@
     }
   }
 
   int commit_count_;
   int commit_complete_count_;
   TestSwapPromiseResult swap_promise_result_[3];
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromise);
 
-
 class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
  public:
   SimpleSwapPromiseMonitor(LayerTreeHost* layer_tree_host,
                            LayerTreeHostImpl* layer_tree_host_impl,
                            int* set_needs_commit_count,
                            int* set_needs_redraw_count)
       : SwapPromiseMonitor(layer_tree_host, layer_tree_host_impl),
         set_needs_commit_count_(set_needs_commit_count),
         set_needs_redraw_count_(set_needs_redraw_count) {}
 
   virtual ~SimpleSwapPromiseMonitor() {}
 
   virtual void OnSetNeedsCommitOnMain() OVERRIDE {
     (*set_needs_commit_count_)++;
   }
 
   virtual void OnSetNeedsRedrawOnImpl() OVERRIDE {
     (*set_needs_redraw_count_)++;
   }
 
  private:
   int* set_needs_commit_count_;
   int* set_needs_redraw_count_;
 };
 
-class LayerTreeHostTestSimpleSwapPromiseMonitor
-    : public LayerTreeHostTest {
-
+class LayerTreeHostTestSimpleSwapPromiseMonitor : public LayerTreeHostTest {
+ public:
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void WillBeginMainFrame() OVERRIDE {
     int set_needs_commit_count = 0;
     int set_needs_redraw_count = 0;
 
     {
       scoped_ptr<SimpleSwapPromiseMonitor> swap_promise_monitor(
           new SimpleSwapPromiseMonitor(layer_tree_host(),
                                        NULL,
@@ skipping 34 matching lines @@
 
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestSimpleSwapPromiseMonitor);
 
 }  // namespace cc