cc: Decouple LayerTreeTests from FakeOutputSurface expectations.

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 "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 482 matching lines @@
                           CompositorMode mode)
       : LayerTreeHost(params, mode),
         test_hooks_(test_hooks),
         test_started_(false) {}
 
   TestHooks* test_hooks_;
   bool test_started_;
 };
 
 LayerTreeTest::LayerTreeTest()
-    : output_surface_(nullptr),
-      external_begin_frame_source_(nullptr),
+    : external_begin_frame_source_(nullptr),
       remote_proto_channel_bridge_(this),
       image_serialization_processor_(
           base::WrapUnique(new FakeImageSerializationProcessor)),
       beginning_(false),
       end_when_begin_returns_(false),
       timed_out_(false),
       scheduled_(false),
       started_(false),
       ended_(false),
       delegating_renderer_(false),
@@ skipping 383 matching lines @@
   ASSERT_FALSE(layer_tree_host_.get());
   client_ = nullptr;
   if (timed_out_) {
     FAIL() << "Test timed out";
     return;
   }
   AfterTest();
 }
 
 void LayerTreeTest::RequestNewOutputSurface() {
+  if (settings_.use_external_begin_frame_source &&
+      settings_.wait_for_beginframe_interval) {
+    DCHECK(external_begin_frame_source_);
+  }
   SetOutputSurfaceOnLayerTreeHost(CreateOutputSurface());
 }
 
 std::unique_ptr<OutputSurface> LayerTreeTest::CreateOutputSurface() {
-  std::unique_ptr<FakeOutputSurface> output_surface = CreateFakeOutputSurface();
-  DCHECK_EQ(delegating_renderer_,
-            output_surface->capabilities().delegated_rendering);
-  output_surface_ = output_surface.get();
-
-  if (settings_.use_external_begin_frame_source &&
-      settings_.wait_for_beginframe_interval) {
-    DCHECK(external_begin_frame_source_);
-  }
-  return std::move(output_surface);
-}
-
-std::unique_ptr<FakeOutputSurface> LayerTreeTest::CreateFakeOutputSurface() {
-  if (delegating_renderer_)
-    return FakeOutputSurface::CreateDelegating3d();
-  else
-    return FakeOutputSurface::Create3d();
-}
-
-TestWebGraphicsContext3D* LayerTreeTest::TestContext() {
-  return static_cast<TestContextProvider*>(output_surface_->context_provider())
-      ->TestContext3d();
+  return delegating_renderer_ ? FakeOutputSurface::CreateDelegating3d()
+                              : FakeOutputSurface::Create3d();
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
   if (layer_tree_host_ && layer_tree_host_->root_layer())
     layer_tree_host_->root_layer()->SetLayerTreeHost(NULL);
   layer_tree_host_ = nullptr;
 
   DCHECK(!remote_proto_channel_bridge_.channel_main.HasReceiver());
 
   // Destroying the LayerTreeHost should destroy the remote client
@@ skipping 95 matching lines @@
 
 RemoteChannelImplForTest* LayerTreeTest::GetRemoteChannelImplForTest() const {
   DCHECK(IsRemoteTest());
   DCHECK(remote_client_layer_tree_host_);
 
   return static_cast<RemoteChannelImplForTest*>(
       remote_client_layer_tree_host_->proxy());
 }
 
 }  // namespace cc