Make scroll offset type of float in cc

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/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/picture_layer.h"
@@ skipping 34 matching lines @@
     scroll_layer->SetScrollClipLayerId(root_layer->id());
     scroll_layer->SetScrollOffset(initial_scroll_);
     layer_tree_host()->RegisterViewportLayers(root_layer, scroll_layer, NULL);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void Layout() OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
     Layer* scroll_layer = root->children()[0].get();
     if (!layer_tree_host()->source_frame_number()) {
-      EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
+      EXPECT_VECTOR2DF_EQ(initial_scroll_, scroll_layer->scroll_offset());

[danakj, 2014/09/18 21:23:49]

EXPECT_EQ?

[Yufeng Shen (Slow to review), 2014/09/18 22:47:55]

Done.

     } else {
-      EXPECT_VECTOR_EQ(initial_scroll_ + scroll_amount_,
+      EXPECT_VECTOR2DF_EQ(initial_scroll_ + scroll_amount_,
                        scroll_layer->scroll_offset());
 
       // Pretend like Javascript updated the scroll position itself.
       scroll_layer->SetScrollOffset(second_scroll_);
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = root->children()[0];
-    EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
+    EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(), scroll_layer->ScrollDelta());
 
     scroll_layer->SetScrollClipLayer(root->id());
     scroll_layer->SetBounds(
         gfx::Size(root->bounds().width() + 100, root->bounds().height() + 100));
     scroll_layer->ScrollBy(scroll_amount_);
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
-        EXPECT_VECTOR_EQ(scroll_amount_, scroll_layer->ScrollDelta());
+        EXPECT_VECTOR2DF_EQ(initial_scroll_, scroll_layer->scroll_offset());
+        EXPECT_VECTOR2DF_EQ(scroll_amount_, scroll_layer->ScrollDelta());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), second_scroll_);
-        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
+        EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), second_scroll_);
+        EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
         EndTest();
         break;
     }
   }
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
                                    float top_controls_delta) OVERRIDE {
     num_scrolls_++;
   }
@@ skipping 26 matching lines @@
     scroll_layer_->SetIsContainerForFixedPositionLayers(true);
     scroll_layer_->SetScrollClipLayerId(root_layer->id());
     scroll_layer_->SetScrollOffset(initial_scroll_);
     layer_tree_host()->RegisterViewportLayers(root_layer, scroll_layer_, NULL);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(), initial_scroll_);
+        EXPECT_VECTOR2DF_EQ(scroll_layer_->scroll_offset(), initial_scroll_);
         break;
       case 1:
-        EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),
+        EXPECT_VECTOR2DF_EQ(scroll_layer_->scroll_offset(),
                          initial_scroll_ + scroll_amount_ + scroll_amount_);
       case 2:
-        EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),
+        EXPECT_VECTOR2DF_EQ(scroll_layer_->scroll_offset(),
                          initial_scroll_ + scroll_amount_ + scroll_amount_);
         break;
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* scroll_layer =
         impl->active_tree()->LayerById(scroll_layer_->id());
     if (impl->active_tree()->source_frame_number() == 0 &&
         impl->SourceAnimationFrameNumber() == 1) {
       // First draw after first commit.
-      EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
+      EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF());
       scroll_layer->ScrollBy(scroll_amount_);
-      EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
+      EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
 
-      EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
+      EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);
       PostSetNeedsRedrawToMainThread();
     } else if (impl->active_tree()->source_frame_number() == 0 &&
                impl->SourceAnimationFrameNumber() == 2) {
       // Second draw after first commit.
       EXPECT_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
       scroll_layer->ScrollBy(scroll_amount_);
-      EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),
+      EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(),
                        scroll_amount_ + scroll_amount_);
 
-      EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(), initial_scroll_);
+      EXPECT_VECTOR2DF_EQ(scroll_layer_->scroll_offset(), initial_scroll_);
       PostSetNeedsCommitToMainThread();
     } else if (impl->active_tree()->source_frame_number() == 1) {
       // Third or later draw after second commit.
       EXPECT_GE(impl->SourceAnimationFrameNumber(), 3);
-      EXPECT_VECTOR_EQ(scroll_layer_->ScrollDelta(), gfx::Vector2d());
-      EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),
+      EXPECT_VECTOR2DF_EQ(scroll_layer_->ScrollDelta(), gfx::Vector2dF());
+      EXPECT_VECTOR2DF_EQ(scroll_layer_->scroll_offset(),
                        initial_scroll_ + scroll_amount_ + scroll_amount_);
       EndTest();
     }
   }
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
                                    float top_controls_delta) OVERRIDE {
     num_scrolls_++;
   }
 
   virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
 
  private:
-  gfx::Vector2d initial_scroll_;
-  gfx::Vector2d scroll_amount_;
+  gfx::Vector2dF initial_scroll_;
+  gfx::Vector2dF scroll_amount_;
   int num_scrolls_;
   scoped_refptr<Layer> scroll_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollMultipleRedraw);
 
 class LayerTreeHostScrollTestScrollAbortedCommit
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollAbortedCommit()
@@ skipping 28 matching lines @@
 
   virtual void WillBeginMainFrame() OVERRIDE {
     num_will_begin_main_frames_++;
     Layer* root_scroll_layer =
         layer_tree_host()->root_layer()->children()[0].get();
     switch (num_will_begin_main_frames_) {
       case 1:
         // This will not be aborted because of the initial prop changes.
         EXPECT_EQ(0, num_impl_scrolls_);
         EXPECT_EQ(0, layer_tree_host()->source_frame_number());
-        EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(), initial_scroll_);
+        EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),
+                            initial_scroll_);
         EXPECT_EQ(1.f, layer_tree_host()->page_scale_factor());
         break;
       case 2:
         // This commit will be aborted, and another commit will be
         // initiated from the redraw.
         EXPECT_EQ(1, num_impl_scrolls_);
         EXPECT_EQ(1, layer_tree_host()->source_frame_number());
-        EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
+        EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),
                          initial_scroll_ + impl_scroll_);
         EXPECT_EQ(impl_scale_, layer_tree_host()->page_scale_factor());
         PostSetNeedsRedrawToMainThread();
         break;
       case 3:
         // This commit will not be aborted because of the scroll change.
         EXPECT_EQ(2, num_impl_scrolls_);
         // The source frame number still increases even with the abort.
         EXPECT_EQ(2, layer_tree_host()->source_frame_number());
-        EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
+        EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),
                          initial_scroll_ + impl_scroll_ + impl_scroll_);
         EXPECT_EQ(impl_scale_ * impl_scale_,
                   layer_tree_host()->page_scale_factor());
         root_scroll_layer->SetScrollOffset(root_scroll_layer->scroll_offset() +
                                            second_main_scroll_);
         break;
       case 4:
         // This commit will also be aborted.
         EXPECT_EQ(3, num_impl_scrolls_);
         EXPECT_EQ(3, layer_tree_host()->source_frame_number());
-        EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
+        EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),
                          initial_scroll_ + impl_scroll_ + impl_scroll_ +
                              impl_scroll_ + second_main_scroll_);
         // End the test by drawing to verify this commit is also aborted.
         PostSetNeedsRedrawToMainThread();
         break;
     }
   }
 
   virtual void DidBeginMainFrame() OVERRIDE { num_did_begin_main_frames_++; }
 
   virtual void WillCommit() OVERRIDE { num_will_commits_++; }
 
   virtual void DidCommit() OVERRIDE { num_did_commits_++; }
 
   virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_impl_commits_++;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root_scroll_layer =
         impl->active_tree()->root_layer()->children()[0];
 
     if (impl->active_tree()->source_frame_number() == 0 &&
         impl->SourceAnimationFrameNumber() == 1) {
       // First draw
-      EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
+      EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2dF());
       root_scroll_layer->ScrollBy(impl_scroll_);
-      EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
-      EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(), initial_scroll_);
+      EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
+      EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(), initial_scroll_);
 
       EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(1.f, impl->active_tree()->total_page_scale_factor());
       impl->active_tree()->SetPageScaleDelta(impl_scale_);
       EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(impl_scale_, impl->active_tree()->total_page_scale_factor());
 
       // To simplify the testing flow, don't redraw here, just commit.
       impl->SetNeedsCommit();
     } else if (impl->active_tree()->source_frame_number() == 0 &&
                impl->SourceAnimationFrameNumber() == 2) {
       // Test a second draw after an aborted commit.
       // The scroll/scale values should be baked into the offset/scale factor
       // since the main thread consumed but aborted the begin frame.
-      EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
+      EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2dF());
       root_scroll_layer->ScrollBy(impl_scroll_);
-      EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
-      EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
+      EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
+      EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),
                        initial_scroll_ + impl_scroll_);
 
       EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(impl_scale_, impl->active_tree()->total_page_scale_factor());
       impl->active_tree()->SetPageScaleDelta(impl_scale_);
       EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(impl_scale_ * impl_scale_,
                 impl->active_tree()->total_page_scale_factor());
 
       impl->SetNeedsCommit();
     } else if (impl->active_tree()->source_frame_number() == 1) {
       // Commit for source frame 1 is aborted.
       NOTREACHED();
     } else if (impl->active_tree()->source_frame_number() == 2 &&
                impl->SourceAnimationFrameNumber() == 3) {
       // Third draw after the second full commit.
-      EXPECT_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
+      EXPECT_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2dF());
       root_scroll_layer->ScrollBy(impl_scroll_);
       impl->SetNeedsCommit();
-      EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
-      EXPECT_VECTOR_EQ(
+      EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
+      EXPECT_VECTOR2DF_EQ(
           root_scroll_layer->scroll_offset(),
           initial_scroll_ + impl_scroll_ + impl_scroll_ + second_main_scroll_);
     } else if (impl->active_tree()->source_frame_number() == 2 &&
                impl->SourceAnimationFrameNumber() == 4) {
       // Final draw after the second aborted commit.
-      EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
-      EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
+      EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2dF());
+      EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),
                        initial_scroll_ + impl_scroll_ + impl_scroll_ +
                            impl_scroll_ + second_main_scroll_);
       EndTest();
     } else {
       // Commit for source frame 3 is aborted.
       NOTREACHED();
     }
   }
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
@@ skipping 54 matching lines @@
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = root->children()[0];
 
     // Check that a fractional scroll delta is correctly accumulated over
     // multiple commits.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), gfx::Vector2d(0, 0));
-        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d(0, 0));
+        EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(),
+                            gfx::Vector2dF(0, 0));
+        EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF(0, 0));
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),
-                         gfx::ToFlooredVector2d(scroll_amount_));
-        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),
-                         gfx::Vector2dF(fmod(scroll_amount_.x(), 1.0f), 0.0f));
+        EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), scroll_amount_);
+        EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF(0, 0));
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
-        EXPECT_VECTOR_EQ(
-            scroll_layer->scroll_offset(),
-            gfx::ToFlooredVector2d(scroll_amount_ + scroll_amount_));
-        EXPECT_VECTOR_EQ(
-            scroll_layer->ScrollDelta(),
-            gfx::Vector2dF(fmod(2.0f * scroll_amount_.x(), 1.0f), 0.0f));
+        EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(),
+                            scroll_amount_ + scroll_amount_);
+        EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF(0, 0));
         EndTest();
         break;
     }
     scroll_layer->ScrollBy(scroll_amount_);
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   gfx::Vector2dF scroll_amount_;
@@ skipping 76 matching lines @@
     final_scroll_offset_ = expected_scroll_layer_->scroll_offset();
   }
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
                                    float top_controls_delta) OVERRIDE {
     num_scrolls_++;
   }
 
   virtual void Layout() OVERRIDE {
-    EXPECT_VECTOR_EQ(gfx::Vector2d(),
+    EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(),
                      expected_no_scroll_layer_->scroll_offset());
 
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(initial_offset_,
+        EXPECT_VECTOR2DF_EQ(initial_offset_,
                          expected_scroll_layer_->scroll_offset());
         break;
       case 1:
-        EXPECT_VECTOR_EQ(initial_offset_ + scroll_amount_,
+        EXPECT_VECTOR2DF_EQ(initial_offset_ + scroll_amount_,
                          expected_scroll_layer_->scroll_offset());
 
         // Pretend like Javascript updated the scroll position itself.
         expected_scroll_layer_->SetScrollOffset(javascript_scroll_);
         break;
       case 2:
-        EXPECT_VECTOR_EQ(javascript_scroll_ + scroll_amount_,
+        EXPECT_VECTOR2DF_EQ(javascript_scroll_ + scroll_amount_,
                          expected_scroll_layer_->scroll_offset());
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root_impl = impl->active_tree()->root_layer();
     FakePictureLayerImpl* root_scroll_layer_impl =
         static_cast<FakePictureLayerImpl*>(root_impl->children()[0]);
     FakePictureLayerImpl* child_layer_impl = static_cast<FakePictureLayerImpl*>(
         root_scroll_layer_impl->children()[0]);
 
     LayerImpl* expected_scroll_layer_impl = NULL;
     LayerImpl* expected_no_scroll_layer_impl = NULL;
     if (scroll_child_layer_) {
       expected_scroll_layer_impl = child_layer_impl;
       expected_no_scroll_layer_impl = root_scroll_layer_impl;
     } else {
       expected_scroll_layer_impl = root_scroll_layer_impl;
       expected_no_scroll_layer_impl = child_layer_impl;
     }
 
-    EXPECT_VECTOR_EQ(gfx::Vector2d(), root_impl->ScrollDelta());
-    EXPECT_VECTOR_EQ(gfx::Vector2d(),
+    EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(), root_impl->ScrollDelta());
+    EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(),
                      expected_no_scroll_layer_impl->ScrollDelta());
 
     // Ensure device scale factor is affecting the layers.
     EXPECT_FLOAT_EQ(device_scale_factor_,
                     root_scroll_layer_impl->HighResTiling()->contents_scale());
 
     EXPECT_FLOAT_EQ(device_scale_factor_,
                     child_layer_impl->HighResTiling()->contents_scale());
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0: {
         // Gesture scroll on impl thread.
         InputHandler::ScrollStatus status = impl->ScrollBegin(
             gfx::ToCeiledPoint(expected_scroll_layer_impl->position() -
                                gfx::Vector2dF(0.5f, 0.5f)),
             InputHandler::Gesture);
         EXPECT_EQ(InputHandler::ScrollStarted, status);
         impl->ScrollBy(gfx::Point(), scroll_amount_);
         impl->ScrollEnd();
 
         // Check the scroll is applied as a delta.
-        EXPECT_VECTOR_EQ(initial_offset_,
+        EXPECT_VECTOR2DF_EQ(initial_offset_,
                          expected_scroll_layer_impl->scroll_offset());
-        EXPECT_VECTOR_EQ(scroll_amount_,
+        EXPECT_VECTOR2DF_EQ(scroll_amount_,
                          expected_scroll_layer_impl->ScrollDelta());
         break;
       }
       case 1: {
         // Wheel scroll on impl thread.
         InputHandler::ScrollStatus status = impl->ScrollBegin(
             gfx::ToCeiledPoint(expected_scroll_layer_impl->position() +
                                gfx::Vector2dF(0.5f, 0.5f)),
             InputHandler::Wheel);
         EXPECT_EQ(InputHandler::ScrollStarted, status);
         impl->ScrollBy(gfx::Point(), scroll_amount_);
         impl->ScrollEnd();
 
         // Check the scroll is applied as a delta.
-        EXPECT_VECTOR_EQ(javascript_scroll_,
+        EXPECT_VECTOR2DF_EQ(javascript_scroll_,
                          expected_scroll_layer_impl->scroll_offset());
-        EXPECT_VECTOR_EQ(scroll_amount_,
+        EXPECT_VECTOR2DF_EQ(scroll_amount_,
                          expected_scroll_layer_impl->ScrollDelta());
         break;
       }
       case 2:
 
-        EXPECT_VECTOR_EQ(javascript_scroll_ + scroll_amount_,
+        EXPECT_VECTOR2DF_EQ(javascript_scroll_ + scroll_amount_,
                          expected_scroll_layer_impl->scroll_offset());
-        EXPECT_VECTOR_EQ(gfx::Vector2d(),
+        EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(),
                          expected_scroll_layer_impl->ScrollDelta());
 
         EndTest();
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {
     if (scroll_child_layer_) {
       EXPECT_EQ(0, num_scrolls_);
       EXPECT_VECTOR_EQ(javascript_scroll_ + scroll_amount_,
                        final_scroll_offset_);
     } else {
       EXPECT_EQ(2, num_scrolls_);
-      EXPECT_VECTOR_EQ(gfx::Vector2d(), final_scroll_offset_);
+      EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(), final_scroll_offset_);
     }
   }
 
  protected:
   float device_scale_factor_;
   bool scroll_child_layer_;
 
-  gfx::Vector2d initial_offset_;
-  gfx::Vector2d javascript_scroll_;
-  gfx::Vector2d scroll_amount_;
+  gfx::Vector2dF initial_offset_;
+  gfx::Vector2dF javascript_scroll_;
+  gfx::Vector2dF scroll_amount_;
   int num_scrolls_;
-  gfx::Vector2d final_scroll_offset_;
+  gfx::Vector2dF final_scroll_offset_;
 
   FakeContentLayerClient fake_content_layer_client_;
 
   scoped_refptr<Layer> root_scroll_layer_;
   scoped_refptr<Layer> child_layer_;
   scoped_refptr<Layer> expected_scroll_layer_;
   scoped_refptr<Layer> expected_no_scroll_layer_;
 };
 
 TEST_F(LayerTreeHostScrollTestCaseWithChild,
@@ skipping 120 matching lines @@
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void Layout() OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
     Layer* scroll_layer = root->children()[0].get();
     if (!layer_tree_host()->source_frame_number()) {
-      EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
+      EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);
     } else {
-      EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),
+      EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(),
                        initial_scroll_ + impl_thread_scroll1_);
 
       // Pretend like Javascript updated the scroll position itself with a
       // change of main_thread_scroll.
       scroll_layer->SetScrollOffset(initial_scroll_ + main_thread_scroll_ +
                                     impl_thread_scroll1_);
     }
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // We force a second draw here of the first commit before activating
     // the second commit.
     if (impl->active_tree()->source_frame_number() == 0)
       impl->SetNeedsRedraw();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
 
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = root->children()[0];
     LayerImpl* pending_root =
         impl->active_tree()->FindPendingTreeLayerById(root->id());
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         if (!impl->pending_tree()) {
           impl->BlockNotifyReadyToActivateForTesting(true);
-          EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
+          EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF());
           scroll_layer->ScrollBy(impl_thread_scroll1_);
 
-          EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
-          EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll1_);
-          EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
+          EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);
+          EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(),
+                              impl_thread_scroll1_);
+          EXPECT_VECTOR2DF_EQ(scroll_layer->sent_scroll_delta(),
+                              gfx::Vector2dF());
           PostSetNeedsCommitToMainThread();
 
           // CommitCompleteOnThread will trigger this function again
           // and cause us to take the else clause.
         } else {
           impl->BlockNotifyReadyToActivateForTesting(false);
           ASSERT_TRUE(pending_root);
           EXPECT_EQ(impl->pending_tree()->source_frame_number(), 1);
 
           scroll_layer->ScrollBy(impl_thread_scroll2_);
-          EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
-          EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),
+          EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);
+          EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(),
                            impl_thread_scroll1_ + impl_thread_scroll2_);
-          EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(),
+          EXPECT_VECTOR2DF_EQ(scroll_layer->sent_scroll_delta(),
                            impl_thread_scroll1_);
 
           LayerImpl* pending_scroll_layer = pending_root->children()[0];
-          EXPECT_VECTOR_EQ(
+          EXPECT_VECTOR2DF_EQ(
               pending_scroll_layer->scroll_offset(),
               initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
-          EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),
+          EXPECT_VECTOR2DF_EQ(pending_scroll_layer->ScrollDelta(),
                            impl_thread_scroll2_);
-          EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
-                           gfx::Vector2d());
+          EXPECT_VECTOR2DF_EQ(pending_scroll_layer->sent_scroll_delta(),
+                           gfx::Vector2dF());
         }
         break;
       case 1:
         EXPECT_FALSE(impl->pending_tree());
-        EXPECT_VECTOR_EQ(
+        EXPECT_VECTOR2DF_EQ(
             scroll_layer->scroll_offset(),
             initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
-        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll2_);
-        EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
+        EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll2_);
+        EXPECT_VECTOR2DF_EQ(scroll_layer->sent_scroll_delta(),
+                            gfx::Vector2dF());
         EndTest();
         break;
     }
   }
 
   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
                                    float scale,
                                    float top_controls_delta) OVERRIDE {
     num_scrolls_++;
   }
@@ skipping 75 matching lines @@
     LayerImpl* active_root = impl->active_tree()->root_layer();
     LayerImpl* active_scroll_layer =
         active_root ? active_root->children()[0] : NULL;
     LayerImpl* pending_root = impl->pending_tree()->root_layer();
     LayerImpl* pending_scroll_layer = pending_root->children()[0];
 
     ASSERT_TRUE(pending_root);
     ASSERT_TRUE(pending_scroll_layer);
     switch (impl->pending_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
+        EXPECT_VECTOR2DF_EQ(pending_scroll_layer->scroll_offset(),
                          initial_scroll_);
-        EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(), gfx::Vector2d());
-        EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
-                         gfx::Vector2d());
+        EXPECT_VECTOR2DF_EQ(pending_scroll_layer->ScrollDelta(),
+                            gfx::Vector2dF());
+        EXPECT_VECTOR2DF_EQ(pending_scroll_layer->sent_scroll_delta(),
+                         gfx::Vector2dF());
         EXPECT_FALSE(active_root);
         break;
       case 1:
         // Even though the scroll happened during the commit, both layers
         // should have the appropriate scroll delta.
-        EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
+        EXPECT_VECTOR2DF_EQ(pending_scroll_layer->scroll_offset(),
                          initial_scroll_);
-        EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),
+        EXPECT_VECTOR2DF_EQ(pending_scroll_layer->ScrollDelta(),
                          impl_thread_scroll_);
-        EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
-                         gfx::Vector2d());
+        EXPECT_VECTOR2DF_EQ(pending_scroll_layer->sent_scroll_delta(),
+                         gfx::Vector2dF());
         ASSERT_TRUE(active_root);
-        EXPECT_VECTOR_EQ(active_scroll_layer->scroll_offset(), initial_scroll_);
-        EXPECT_VECTOR_EQ(active_scroll_layer->ScrollDelta(),
+        EXPECT_VECTOR2DF_EQ(active_scroll_layer->scroll_offset(),
+                            initial_scroll_);
+        EXPECT_VECTOR2DF_EQ(active_scroll_layer->ScrollDelta(),
                          impl_thread_scroll_);
-        EXPECT_VECTOR_EQ(active_scroll_layer->sent_scroll_delta(),
-                         gfx::Vector2d());
+        EXPECT_VECTOR2DF_EQ(active_scroll_layer->sent_scroll_delta(),
+                         gfx::Vector2dF());
         break;
       case 2:
         // On the next commit, this delta should have been sent and applied.
-        EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
+        EXPECT_VECTOR2DF_EQ(pending_scroll_layer->scroll_offset(),
                          initial_scroll_ + impl_thread_scroll_);
-        EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(), gfx::Vector2d());
-        EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
-                         gfx::Vector2d());
+        EXPECT_VECTOR2DF_EQ(pending_scroll_layer->ScrollDelta(),
+                            gfx::Vector2dF());
+        EXPECT_VECTOR2DF_EQ(pending_scroll_layer->sent_scroll_delta(),
+                         gfx::Vector2dF());
         EndTest();
         break;
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
 
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = root->children()[0];
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
-        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
-        EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
+        EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);
+        EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF());
+        EXPECT_VECTOR2DF_EQ(scroll_layer->sent_scroll_delta(),
+                            gfx::Vector2dF());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
-        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll_);
-        EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
+        EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);
+        EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll_);
+        EXPECT_VECTOR2DF_EQ(scroll_layer->sent_scroll_delta(),
+                            gfx::Vector2dF());
         PostSetNeedsCommitToMainThread();
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   gfx::Vector2d initial_scroll_;
   gfx::Vector2d impl_thread_scroll_;
@@ skipping 210 matching lines @@
   RunTest(true, false, true);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
   scroll_destroy_whole_tree_ = true;
   RunTest(true, false, true);
 }
 
 }  // namespace
 }  // namespace cc