cc: Create a LayerScrollClient interface and an adapter class in compositor_bindings.

cc/trees/layer_tree_host_unittest_scroll.cc

 // Copyright 2012 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 "base/memory/weak_ptr.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/layer_tree_impl.h"
-#include "third_party/WebKit/public/platform/WebLayerScrollClient.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace cc {
 namespace {
 
 class LayerTreeHostScrollTest : public LayerTreeTest {};
 
 class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
@@ skipping 188 matching lines @@
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   gfx::Vector2dF scroll_amount_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestFractionalScroll);
 
-class LayerTreeHostScrollTestCaseWithChild
-    : public LayerTreeHostScrollTest,
-      public WebKit::WebLayerScrollClient {
+class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestCaseWithChild()
       : initial_offset_(10, 20),
         javascript_scroll_(40, 5),
         scroll_amount_(2, -1),
         num_scrolls_(0) {}
 
   virtual void SetupTree() OVERRIDE {
     layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
 
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(gfx::Size(10, 10));
 
     root_scroll_layer_ = ContentLayer::Create(&fake_content_layer_client_);
     root_scroll_layer_->SetBounds(gfx::Size(110, 110));
 
     root_scroll_layer_->SetPosition(gfx::Point(0, 0));
     root_scroll_layer_->SetAnchorPoint(gfx::PointF());
 
     root_scroll_layer_->SetIsDrawable(true);
     root_scroll_layer_->SetScrollable(true);
     root_scroll_layer_->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     root_layer->AddChild(root_scroll_layer_);
 
     child_layer_ = ContentLayer::Create(&fake_content_layer_client_);
-    child_layer_->set_layer_scroll_client(this);
+    child_layer_->set_did_scroll_callback(
+        base::Bind(&LayerTreeHostScrollTestCaseWithChild::DidScroll,
+                   base::Unretained(this)));
     child_layer_->SetBounds(gfx::Size(110, 110));
 
     // Scrolls on the child layer will happen at 5, 5. If they are treated
     // like device pixels, and device scale factor is 2, then they will
     // be considered at 2.5, 2.5 in logical pixels, and will miss this layer.
     child_layer_->SetPosition(gfx::Point(5, 5));
     child_layer_->SetAnchorPoint(gfx::PointF());
 
     child_layer_->SetIsDrawable(true);
     child_layer_->SetScrollable(true);
     child_layer_->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     root_scroll_layer_->AddChild(child_layer_);
 
     if (scroll_child_layer_) {
       expected_scroll_layer_ = child_layer_;
       expected_no_scroll_layer_ = root_scroll_layer_;
     } else {
       expected_scroll_layer_ = root_scroll_layer_;
       expected_no_scroll_layer_ = child_layer_;
     }
 
     expected_scroll_layer_->SetScrollOffset(initial_offset_);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostScrollTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual void didScroll() OVERRIDE {
+  void DidScroll() {
     final_scroll_offset_ = expected_scroll_layer_->scroll_offset();
   }
 
   virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta, float scale)
       OVERRIDE {
     gfx::Vector2d offset = root_scroll_layer_->scroll_offset();
     root_scroll_layer_->SetScrollOffset(offset + scroll_delta);
     num_scrolls_++;
   }
 
@@ skipping 499 matching lines @@
   virtual void DidScroll(Layer* layer) {
     if (scroll_destroy_whole_tree_) {
       layer_tree_host()->SetRootLayer(NULL);
       EndTest();
       return;
     }
     layer->RemoveFromParent();
   }
 
  protected:
-  class FakeWebLayerScrollClient : public WebKit::WebLayerScrollClient {
+  class FakeLayerScrollClient {

[danakj, 2013/06/28 16:06:54]

Can this class just go away here, and we set the callback to the DidScroll
method above?

[tfarina, 2013/06/28 16:13:33]

I'll try this when I get back to home later tonight. But I don't think we will
be able to use "virtual void DidScroll(Layer* layer);" directly because it
doesn't match the declaration of base::Closure which is
base::Callback<void(void)>

[danakj, 2013/06/28 16:46:43]

Oh, that's true. LGTM

    public:
-    virtual void didScroll() OVERRIDE {
+    void DidScroll() {
       owner_->DidScroll(layer_);
     }
     LayerTreeHostScrollTestLayerStructureChange* owner_;
     Layer* layer_;
   };
 
-  Layer* CreateScrollLayer(Layer* parent, FakeWebLayerScrollClient* client) {
+  Layer* CreateScrollLayer(Layer* parent, FakeLayerScrollClient* client) {
     scoped_refptr<Layer> scroll_layer =
         ContentLayer::Create(&fake_content_layer_client_);
     scroll_layer->SetBounds(gfx::Size(110, 110));
     scroll_layer->SetPosition(gfx::Point(0, 0));
     scroll_layer->SetAnchorPoint(gfx::PointF());
     scroll_layer->SetIsDrawable(true);
     scroll_layer->SetScrollable(true);
     scroll_layer->SetMaxScrollOffset(gfx::Vector2d(100, 100));
-    scroll_layer->set_layer_scroll_client(client);
+    scroll_layer->set_did_scroll_callback(base::Bind(
+        &FakeLayerScrollClient::DidScroll, base::Unretained(client)));
     client->owner_ = this;
     client->layer_ = scroll_layer.get();
     parent->AddChild(scroll_layer);
     return scroll_layer.get();
   }
 
-  FakeWebLayerScrollClient root_scroll_layer_client_;
-  FakeWebLayerScrollClient sibling_scroll_layer_client_;
-  FakeWebLayerScrollClient child_scroll_layer_client_;
+  FakeLayerScrollClient root_scroll_layer_client_;
+  FakeLayerScrollClient sibling_scroll_layer_client_;
+  FakeLayerScrollClient child_scroll_layer_client_;
 
   FakeContentLayerClient fake_content_layer_client_;
 
   bool scroll_destroy_whole_tree_;
 };
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyLayer) {
     RunTest(true, false, false);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
     scroll_destroy_whole_tree_ = true;
     RunTest(true, false, false);
 }
 
 }  // namespace
 }  // namespace cc