Remove WebGraphicsContext3D getter from cc::ContextProvider

cc/test/layer_tree_test.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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 35 matching lines @@
 
 // Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
 class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
  public:
   static scoped_ptr<LayerTreeHostImplForTesting> Create(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       Proxy* proxy,
       RenderingStatsInstrumentation* stats_instrumentation) {
-    return make_scoped_ptr(
-        new LayerTreeHostImplForTesting(test_hooks,
-                                        settings,
-                                        host_impl_client,
-                                        proxy,
-                                        stats_instrumentation));
+    return make_scoped_ptr(new LayerTreeHostImplForTesting(
+        test_hooks, settings, host_impl_client, proxy, stats_instrumentation));
   }
 
  protected:
   LayerTreeHostImplForTesting(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       Proxy* proxy,
       RenderingStatsInstrumentation* stats_instrumentation)
       : LayerTreeHostImpl(settings,
@@ skipping 147 matching lines @@
 
   virtual void DidBeginMainFrame() OVERRIDE {
     test_hooks_->DidBeginMainFrame();
   }
 
   virtual void Animate(double monotonic_time) OVERRIDE {
     test_hooks_->Animate(base::TimeTicks::FromInternalValue(
         monotonic_time * base::Time::kMicrosecondsPerSecond));
   }
 
-  virtual void Layout() OVERRIDE {
-    test_hooks_->Layout();
-  }
+  virtual void Layout() OVERRIDE { test_hooks_->Layout(); }
 
   virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta,
                                    float scale) OVERRIDE {
     test_hooks_->ApplyScrollAndScale(scroll_delta, scale);
   }
 
   virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
       OVERRIDE {
     return test_hooks_->CreateOutputSurface(fallback);
   }
 
   virtual void DidInitializeOutputSurface(bool succeeded) OVERRIDE {
     test_hooks_->DidInitializeOutputSurface(succeeded);
   }
 
   virtual void DidFailToInitializeOutputSurface() OVERRIDE {
     test_hooks_->DidFailToInitializeOutputSurface();
   }
 
   virtual void WillCommit() OVERRIDE { test_hooks_->WillCommit(); }
 
-  virtual void DidCommit() OVERRIDE {
-    test_hooks_->DidCommit();
-  }
+  virtual void DidCommit() OVERRIDE { test_hooks_->DidCommit(); }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     test_hooks_->DidCommitAndDrawFrame();
   }
 
   virtual void DidCompleteSwapBuffers() OVERRIDE {
     test_hooks_->DidCompleteSwapBuffers();
   }
 
   virtual void ScheduleComposite() OVERRIDE {
@@ skipping 46 matching lines @@
   }
 
   virtual void SetNeedsCommit() OVERRIDE {
     if (!test_started_)
       return;
     LayerTreeHost::SetNeedsCommit();
   }
 
   void set_test_started(bool started) { test_started_ = started; }
 
-  virtual void DidDeferCommit() OVERRIDE {
-    test_hooks_->DidDeferCommit();
-  }
+  virtual void DidDeferCommit() OVERRIDE { test_hooks_->DidDeferCommit(); }
 
  private:
   LayerTreeHostForTesting(TestHooks* test_hooks,
                           LayerTreeHostClient* client,
                           const LayerTreeSettings& settings)
       : LayerTreeHost(client, NULL, settings),
         test_hooks_(test_hooks),
         test_started_(false) {}
 
   TestHooks* test_hooks_;
@@ skipping 148 matching lines @@
   SetupTree();
   WillBeginTest();
   BeginTest();
   beginning_ = false;
   if (end_when_begin_returns_)
     RealEndTest();
 
   // Allow commits to happen once BeginTest() has had a chance to post tasks
   // so that those tasks will happen before the first commit.
   if (layer_tree_host_) {
-    static_cast<LayerTreeHostForTesting*>(layer_tree_host_.get())->
-        set_test_started(true);
+    static_cast<LayerTreeHostForTesting*>(layer_tree_host_.get())
+        ->set_test_started(true);
   }
 }
 
 void LayerTreeTest::SetupTree() {
   if (!layer_tree_host_->root_layer()) {
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetAnchorPoint(gfx::PointF());
     root_layer->SetBounds(gfx::Size(1, 1));
     root_layer->SetIsDrawable(true);
     layer_tree_host_->SetRootLayer(root_layer);
@@ skipping 28 matching lines @@
   }
 
   base::MessageLoop::current()->Quit();
 }
 
 void LayerTreeTest::DispatchAddAnimation(Layer* layer_to_receive_animation,
                                          double animation_duration) {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
   if (layer_to_receive_animation) {
-    AddOpacityTransitionToLayer(layer_to_receive_animation,
-                                animation_duration,
-                                0,
-                                0.5,
-                                true);
+    AddOpacityTransitionToLayer(
+        layer_to_receive_animation, animation_duration, 0, 0.5, true);
   }
 }
 
 void LayerTreeTest::DispatchSetNeedsCommit() {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetNeedsCommit();
 }
 
@@ skipping 82 matching lines @@
   }
 
   main_task_runner_ = base::MessageLoopProxy::current();
 
   delegating_renderer_ = delegating_renderer;
 
   // Spend less time waiting for BeginImplFrame because the output is
   // mocked out.
   settings_.refresh_rate = 200.0;
   if (impl_side_painting) {
-    DCHECK(threaded) <<
-        "Don't run single thread + impl side painting, it doesn't exist.";
+    DCHECK(threaded)
+        << "Don't run single thread + impl side painting, it doesn't exist.";
     settings_.impl_side_painting = true;
   }
   InitializeSettings(&settings_);
 
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LayerTreeTest::DoBeginTest, base::Unretained(this)));
 
   if (timeout_seconds_) {
     timeout_.Reset(base::Bind(&LayerTreeTest::Timeout, base::Unretained(this)));
@@ skipping 17 matching lines @@
     return;
   }
   AfterTest();
 }
 
 void LayerTreeTest::RunTestWithImplSidePainting() {
   RunTest(true, false, true);
 }
 
 scoped_ptr<OutputSurface> LayerTreeTest::CreateOutputSurface(bool fallback) {
-  scoped_ptr<FakeOutputSurface> output_surface;
-  if (delegating_renderer_)
-    output_surface = FakeOutputSurface::CreateDelegating3d();
-  else
-    output_surface = FakeOutputSurface::Create3d();
+  scoped_ptr<FakeOutputSurface> output_surface =
+      CreateFakeOutputSurfaceForTest(fallback);
+
   output_surface_ = output_surface.get();
   return output_surface.PassAs<OutputSurface>();
 }
 
+scoped_ptr<FakeOutputSurface> LayerTreeTest::CreateFakeOutputSurfaceForTest(
+    bool fallback) {
+  if (delegating_renderer_)
+    return FakeOutputSurface::CreateDelegating3d();
+  else
+    return FakeOutputSurface::Create3d();
+}
+
 scoped_refptr<ContextProvider> LayerTreeTest::OffscreenContextProvider() {
   if (!compositor_contexts_.get() ||
       compositor_contexts_->DestroyedOnMainThread())
     compositor_contexts_ = TestContextProvider::Create();
   return compositor_contexts_;
 }
 
+TestWebGraphicsContext3D* LayerTreeTest::TestContext() {
+  return static_cast<TestContextProvider*>(
+      output_surface_->context_provider().get())->TestContext3d();
+}
+
 }  // namespace cc