cc: Remove most methods from RendererClient.

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 4981 matching lines @@
   EXPECT_FALSE(did_request_commit_);
 }
 
 struct RenderPassRemovalTestData : public LayerTreeHostImpl::FrameData {
   base::ScopedPtrHashMap<RenderPass::Id, TestRenderPass> render_pass_cache;
   scoped_ptr<SharedQuadState> shared_quad_state;
 };
 
 class TestRenderer : public GLRenderer, public RendererClient {
  public:
-  static scoped_ptr<TestRenderer> Create(ResourceProvider* resource_provider,
+  static scoped_ptr<TestRenderer> Create(const LayerTreeSettings* settings,
+                                         ResourceProvider* resource_provider,
                                          OutputSurface* output_surface,
                                          Proxy* proxy) {
-    scoped_ptr<TestRenderer> renderer(new TestRenderer(resource_provider,
-                                                       output_surface,
-                                                       proxy));
+    scoped_ptr<TestRenderer> renderer(
+        new TestRenderer(settings, resource_provider, output_surface, proxy));
     if (!renderer->Initialize())
       return scoped_ptr<TestRenderer>();
 
     return renderer.Pass();
   }
 
   void ClearCachedTextures() { textures_.clear(); }
   void SetHaveCachedResourcesForRenderPassId(RenderPass::Id id) {
     textures_.insert(id);
   }
 
   virtual bool HaveCachedResourcesForRenderPassId(RenderPass::Id id) const
       OVERRIDE {
     return textures_.count(id);
   }
 
   // RendererClient implementation.
   virtual gfx::Rect DeviceViewport() const OVERRIDE {
     return gfx::Rect(viewport_size_);
   }
-  virtual gfx::Rect DeviceClip() const OVERRIDE {
-    return DeviceViewport();
+  virtual gfx::Rect DeviceClip() const OVERRIDE { return DeviceViewport(); }
+  virtual void SetFullRootLayerDamage() OVERRIDE {}
+  virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE {
+    return CompositorFrameMetadata();
   }
-  virtual float DeviceScaleFactor() const OVERRIDE {
-    return 1.f;
-  }
-  virtual const LayerTreeSettings& Settings() const OVERRIDE {
-    return settings_;
-  }
-  virtual void SetFullRootLayerDamage() OVERRIDE {}
-  virtual bool HasImplThread() const OVERRIDE { return false; }
-  virtual bool ShouldClearRootRenderPass() const OVERRIDE { return true; }
-  virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const
-      OVERRIDE { return CompositorFrameMetadata(); }
-  virtual bool AllowPartialSwap() const OVERRIDE {
-    return true;
-  }
-  virtual bool ExternalStencilTestEnabled() const OVERRIDE { return false; }
 
  protected:
-  TestRenderer(ResourceProvider* resource_provider,
+  TestRenderer(const LayerTreeSettings* settings,
+               ResourceProvider* resource_provider,
                OutputSurface* output_surface,
                Proxy* proxy)
-      : GLRenderer(this, output_surface, resource_provider, 0) {}
+      : GLRenderer(this, settings, output_surface, resource_provider, 0) {}
 
  private:
   LayerTreeSettings settings_;
   gfx::Size viewport_size_;
   base::hash_set<RenderPass::Id> textures_;
 };
 
 static void ConfigureRenderPassTestData(const char* test_script,
                                         RenderPassRemovalTestData* test_data,
                                         TestRenderer* renderer) {
@@ skipping 299 matching lines @@
 static void VerifyRenderPassTestData(
     const TestCase& test_case,
     const RenderPassRemovalTestData& test_data) {
   char actual_result[1024];
   DumpRenderPassTestData(test_data, actual_result);
   EXPECT_STREQ(test_case.expected_result, actual_result) << "In test case: " <<
       test_case.name;
 }
 
 TEST_F(LayerTreeHostImplTest, TestRemoveRenderPasses) {
+  LayerTreeSettings settings;
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(CreateOutputSurface());
   ASSERT_TRUE(output_surface->BindToClient(&output_surface_client));
   ASSERT_TRUE(output_surface->context_provider());
 
   scoped_ptr<ResourceProvider> resource_provider =
       ResourceProvider::Create(output_surface.get(), 0);
 
-  scoped_ptr<TestRenderer> renderer =
-      TestRenderer::Create(resource_provider.get(),
-                           output_surface.get(),
-                           &proxy_);
+  scoped_ptr<TestRenderer> renderer = TestRenderer::Create(
+      &settings, resource_provider.get(), output_surface.get(), &proxy_);
 
   int test_case_index = 0;
   while (remove_render_passes_cases[test_case_index].name) {
     RenderPassRemovalTestData test_data;
     ConfigureRenderPassTestData(
         remove_render_passes_cases[test_case_index].init_script,
         &test_data,
         renderer.get());
     LayerTreeHostImpl::RemoveRenderPasses(
         LayerTreeHostImpl::CullRenderPassesWithCachedTextures(renderer.get()),
@@ skipping 1192 matching lines @@
   EXPECT_EQ(0u, host_impl_->ResourceIdForUIResource(ui_resource_id));
   EXPECT_EQ(0u, context3d->NumTextures());
 
   // Should not change state for multiple deletion on one UIResourceId
   host_impl_->DeleteUIResource(ui_resource_id);
   EXPECT_EQ(0u, context3d->NumTextures());
 }
 
 }  // namespace
 }  // namespace cc