Update from https://crrev.com/306901

cc/trees/layer_tree_host_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.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 1021 matching lines @@
     scroll_layer_->SetScrollOffset(ScrollOffsetWithDelta(offset,
                                                          scroll_delta));
     layer_tree_host()->SetPageScaleFactorAndLimits(scale, 0.5f, 2.f);
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     // We get one commit before the first draw, and the animation doesn't happen
     // until the second draw.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_EQ(1.f, impl->active_tree()->page_scale_factor());
+        EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
         // We'll start an animation when we get back to the main thread.
         break;
       case 1:
-        EXPECT_EQ(1.f, impl->active_tree()->page_scale_factor());
+        EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
         break;
       case 2:
-        EXPECT_EQ(1.25f, impl->active_tree()->page_scale_factor());
+        EXPECT_EQ(1.25f, impl->active_tree()->current_page_scale_factor());
         EndTest();
         break;
       default:
         NOTREACHED();
     }
   }
 
   void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
@@ skipping 4480 matching lines @@
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     float quad_scale_delta = FrameQuadScaleDeltaFromIdeal(frame_data);
     switch (frame_) {
       case 1:
         // Drew at page scale 1 before any pinching.
-        EXPECT_EQ(1.f, host_impl->active_tree()->total_page_scale_factor());
+        EXPECT_EQ(1.f, host_impl->active_tree()->current_page_scale_factor());
         EXPECT_EQ(1.f, quad_scale_delta);
         PostNextAfterDraw(host_impl);
         break;
       case 2:
         if (quad_scale_delta != 1.f)
           break;
         // Drew at page scale 1.5 after pinching in.
-        EXPECT_EQ(1.5f, host_impl->active_tree()->total_page_scale_factor());
+        EXPECT_EQ(1.5f, host_impl->active_tree()->current_page_scale_factor());
         EXPECT_EQ(1.f, quad_scale_delta);
         PostNextAfterDraw(host_impl);
         break;
       case 3:
         // By pinching out, we will create a new tiling and raster it. This may
         // cause some additional draws, though we should still be drawing with
         // the old 1.5 tiling.
         if (frame_data->has_no_damage)
           break;
         // Drew at page scale 1 with the 1.5 tiling while pinching out.
-        EXPECT_EQ(1.f, host_impl->active_tree()->total_page_scale_factor());
+        EXPECT_EQ(1.f, host_impl->active_tree()->current_page_scale_factor());
         EXPECT_EQ(1.5f, quad_scale_delta);
         // We don't PostNextAfterDraw here, instead we wait for the new tiling
         // to finish rastering so we don't get any noise in further steps.
         break;
       case 4:
         // Drew at page scale 1 with the 1.5 tiling after pinching out completed
         // while waiting for texture uploads to complete.
-        EXPECT_EQ(1.f, host_impl->active_tree()->total_page_scale_factor());
+        EXPECT_EQ(1.f, host_impl->active_tree()->current_page_scale_factor());
         // This frame will not have any damage, since it's actually the same as
         // the last frame, and should contain no incomplete tiles. We just want
         // to make sure we drew here at least once after the pinch ended to be
         // sure that drawing after pinch doesn't leave us at the wrong scale
         EXPECT_TRUE(frame_data->has_no_damage);
         PostNextAfterDraw(host_impl);
         break;
       case 5:
         if (quad_scale_delta != 1.f)
           break;
         // Drew at scale 1 after texture uploads are done.
-        EXPECT_EQ(1.f, host_impl->active_tree()->total_page_scale_factor());
+        EXPECT_EQ(1.f, host_impl->active_tree()->current_page_scale_factor());
         EXPECT_EQ(1.f, quad_scale_delta);
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void PostNextAfterDraw(LayerTreeHostImpl* host_impl) {
     if (posted_)
       return;
@@ skipping 150 matching lines @@
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     float quad_scale_delta = FrameQuadScaleDeltaFromIdeal(frame_data);
     switch (step_) {
       case 1:
         // Drew at scale 1 before any pinching.
-        EXPECT_EQ(1.f, host_impl->active_tree()->total_page_scale_factor());
+        EXPECT_EQ(1.f, host_impl->active_tree()->current_page_scale_factor());
         EXPECT_EQ(1.f, quad_scale_delta);
         break;
       case 2:
         if (quad_scale_delta != 1.f / 1.5f)
           break;
         // Drew at scale 1 still though the ideal is 1.5.
-        EXPECT_EQ(1.5f, host_impl->active_tree()->total_page_scale_factor());
+        EXPECT_EQ(1.5f, host_impl->active_tree()->current_page_scale_factor());
         EXPECT_EQ(1.f / 1.5f, quad_scale_delta);
         break;
       case 3:
         // Continuous draws are attempted.
-        EXPECT_EQ(1.5f, host_impl->active_tree()->total_page_scale_factor());
+        EXPECT_EQ(1.5f, host_impl->active_tree()->current_page_scale_factor());
         if (!frame_data->has_no_damage)
           EXPECT_EQ(1.f / 1.5f, quad_scale_delta);
         break;
       case 4:
         if (quad_scale_delta != 1.f)
           break;
         // Drew at scale 1.5 when all the tiles completed.
-        EXPECT_EQ(1.5f, host_impl->active_tree()->total_page_scale_factor());
+        EXPECT_EQ(1.5f, host_impl->active_tree()->current_page_scale_factor());
         EXPECT_EQ(1.f, quad_scale_delta);
         break;
       case 5:
         // TODO(danakj): We get more draws before the NotifyReadyToDraw
         // because it is asynchronous from the previous draw and happens late.
         break;
       case 6:
         // NotifyReadyToDraw happened. If we were already inside a frame, we may
         // try to draw once more.
         break;
@@ skipping 121 matching lines @@
 
  protected:
   FakeContentLayerClient client_;
   size_t notify_ready_to_activate_count_;
   size_t scheduled_manage_tiles_count_;
 };
 
 MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestOneActivatePerManageTiles);
 
 }  // namespace cc