Update from https://crrev.com/306901

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 288 matching lines @@
 
     if (impl->active_tree()->source_frame_number() == 0 &&
         impl->SourceAnimationFrameNumber() == 1) {
       // First draw
       EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
       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_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(1.f, impl->active_tree()->current_page_scale_factor());
+      impl->SetPageScaleOnActiveTree(impl_scale_);
       EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
-      EXPECT_EQ(impl_scale_, impl->active_tree()->total_page_scale_factor());
+      EXPECT_EQ(impl_scale_, impl->active_tree()->current_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());
       root_scroll_layer->ScrollBy(impl_scroll_);
       EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
       EXPECT_VECTOR_EQ(
           root_scroll_layer->scroll_offset(),
           gfx::ScrollOffsetWithDelta(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()->current_page_scale_factor());
+      impl->SetPageScaleOnActiveTree(impl_scale_ * 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->active_tree()->current_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());
       root_scroll_layer->ScrollBy(impl_scroll_);
@@ skipping 546 matching lines @@
 MULTI_THREAD_TEST_F(ImplSidePaintingScrollTestSimple);
 
 // This test makes sure that layers pick up scrolls that occur between
 // beginning a commit and finishing a commit (aka scroll deltas not
 // included in sent scroll delta) still apply to layers that don't
 // push properties.
 class ImplSidePaintingScrollTestImplOnlyScroll
     : public ImplSidePaintingScrollTest {
  public:
   ImplSidePaintingScrollTestImplOnlyScroll()
-      : initial_scroll_(20, 10), impl_thread_scroll_(-2, 3) {}
+      : initial_scroll_(20, 10), impl_thread_scroll_(-2, 3), impl_scale_(2.f) {}
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
     Layer* root_layer = layer_tree_host()->root_layer();
     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
     root_scroll_layer->SetScrollClipLayerId(root_layer->id());
     root_scroll_layer->SetScrollOffset(initial_scroll_);
     root_scroll_layer->SetBounds(
         gfx::Size(root_layer->bounds().width() + 100,
                   root_layer->bounds().height() + 100));
@@ skipping 25 matching lines @@
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     // Scroll after the 2nd commit has started.
     if (impl->active_tree()->source_frame_number() == 0) {
       LayerImpl* active_root = impl->active_tree()->root_layer();
       LayerImpl* active_scroll_layer = active_root->children()[0];
       ASSERT_TRUE(active_root);
       ASSERT_TRUE(active_scroll_layer);
       active_scroll_layer->ScrollBy(impl_thread_scroll_);
+      impl->SetPageScaleOnActiveTree(impl_scale_);
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     // We force a second draw here of the first commit before activating
     // the second commit.
     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();
@@ skipping 27 matching lines @@
                          gfx::Vector2d());
         break;
       case 2:
         // On the next commit, this delta should have been sent and applied.
         EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
                          gfx::ScrollOffsetWithDelta(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());
-        EndTest();
         break;
     }
   }
 
   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_EQ(1.f, impl->active_tree()->page_scale_delta());
+        EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
         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_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
+        EXPECT_EQ(impl_scale_,
+                  impl->active_tree()->current_page_scale_factor());
         PostSetNeedsCommitToMainThread();
         break;
+      case 2:
+        EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
+        EXPECT_EQ(impl_scale_,
+                  impl->active_tree()->current_page_scale_factor());
+        EndTest();
+        break;
     }
   }
 
   void AfterTest() override {}
 
  private:
   gfx::ScrollOffset initial_scroll_;
   gfx::Vector2dF impl_thread_scroll_;
+  float impl_scale_;
 };
 
 MULTI_THREAD_TEST_F(ImplSidePaintingScrollTestImplOnlyScroll);
 
 class LayerTreeHostScrollTestScrollZeroMaxScrollOffset
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollZeroMaxScrollOffset() {}
 
   void SetupTree() override {
@@ skipping 192 matching lines @@
   RunTest(true, false, true);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
   scroll_destroy_whole_tree_ = true;
   RunTest(true, false, true);
 }
 
 }  // namespace
 }  // namespace cc