cc: Remove DelegatingRendererLayerClient

cc/trees/layer_tree_host_unittest_delegated.cc

 // Copyright 2013 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/bind.h"
 #include "base/location.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/layers/delegated_renderer_layer.h"
-#include "cc/layers/delegated_renderer_layer_client.h"
 #include "cc/layers/delegated_renderer_layer_impl.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/test/fake_delegated_renderer_layer.h"
 #include "cc/test/fake_delegated_renderer_layer_impl.h"
@@ skipping 203 matching lines @@
     CompositorFrameAck ack;
     for (size_t i = 0; i < resources_to_return.size(); ++i)
       output_surface()->ReturnResource(resources_to_return[i], &ack);
     host_impl->ReclaimResources(&ack);
     host_impl->OnSwapBuffersComplete();
   }
 };
 
 class LayerTreeHostDelegatedTestCaseSingleDelegatedLayer
     : public LayerTreeHostDelegatedTest,
-      public DelegatedRendererLayerClient,
       public DelegatedFrameResourceCollectionClient {
  public:
   LayerTreeHostDelegatedTestCaseSingleDelegatedLayer()
       : resource_collection_(new DelegatedFrameResourceCollection),
         available_(false) {
     resource_collection_->SetClient(this);
   }
 
   virtual void SetupTree() OVERRIDE {
     root_ = Layer::Create();
@@ skipping 26 matching lines @@
 
     frame_provider_ = new DelegatedFrameProvider(resource_collection_.get(),
                                                  frame_data.Pass());
 
     delegated_ = CreateDelegatedLayer(frame_provider_.get());
   }
 
   scoped_refptr<DelegatedRendererLayer> CreateDelegatedLayer(
       DelegatedFrameProvider* frame_provider) {
     scoped_refptr<DelegatedRendererLayer> delegated =
-        FakeDelegatedRendererLayer::Create(this, frame_provider);
+        FakeDelegatedRendererLayer::Create(frame_provider);
     delegated->SetAnchorPoint(gfx::PointF());
     delegated->SetBounds(gfx::Size(10, 10));
     delegated->SetIsDrawable(true);
 
     root_->AddChild(delegated);
     return delegated;
   }
 
   virtual void AfterTest() OVERRIDE { resource_collection_->SetClient(NULL); }
 
-  // DelegatedRendererLayerClient implementation.
-  virtual void DidCommitFrameData() OVERRIDE {}
-
   // DelegatedFrameProviderClient implementation.
   virtual void UnusedResourcesAreAvailable() OVERRIDE { available_ = true; }
 
   bool TestAndResetAvailable() {
     bool available = available_;
     available_ = false;
     return available;
   }
 
  protected:
   scoped_refptr<DelegatedFrameResourceCollection> resource_collection_;
   scoped_refptr<DelegatedFrameProvider> frame_provider_;
   scoped_refptr<Layer> root_;
   scoped_refptr<DelegatedRendererLayer> delegated_;
   bool available_;
 };
 
-class LayerTreeHostDelegatedTestClientDidCommitCallback
-    : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
- public:
-  LayerTreeHostDelegatedTestClientDidCommitCallback()
-      : LayerTreeHostDelegatedTestCaseSingleDelegatedLayer(),
-        num_did_commit_frame_data_(0) {}
-
-  virtual void DidCommit() OVERRIDE {
-    if (TestEnded())
-      return;
-
-    EXPECT_EQ(1, num_did_commit_frame_data_);
-    EndTest();
-  }
-
-  virtual void BeginTest() OVERRIDE {
-    SetFrameData(CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)));
-    PostSetNeedsCommitToMainThread();
-  }
-
-  virtual void DidCommitFrameData() OVERRIDE {
-    num_did_commit_frame_data_++;
-  }
-
- protected:
-  int num_did_commit_frame_data_;
-};
-
-SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostDelegatedTestClientDidCommitCallback);
-
 class LayerTreeHostDelegatedTestCreateChildId
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
   LayerTreeHostDelegatedTestCreateChildId()
       : LayerTreeHostDelegatedTestCaseSingleDelegatedLayer(),
         num_activates_(0),
         did_reset_child_id_(false) {}
 
   virtual void DidCommit() OVERRIDE {
     if (TestEnded())
@@ skipping 1953 matching lines @@
   }
 
   scoped_refptr<DelegatedRendererLayer> delegated_thief_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostDelegatedTestRemoveAndChangeResources);
 
 }  // namespace
 }  // namespace cc