Fixing crash in PictureLayerImpl::MarkVisibleResourcesAsRequired when low-res tiles are disabled

cc/layers/picture_layer_impl_unittest.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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 685 matching lines @@
   EXPECT_LT(low_res_factor, 1.f);
 
   pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
                                          1.7f,  // device scale
                                          3.2f,  // page scale
                                          1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,

[enne (OOO), 2014/05/02 17:03:16]

Just make the test set the settings appropriately rather than trying to handle
every case.

[Sergey, 2014/05/07 02:34:25]

Done.

+      pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.3f,
       pending_layer_->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(
-      1.3f * low_res_factor,
-      pending_layer_->tilings()->tiling_at(1)->contents_scale());
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_FLOAT_EQ(
+        1.3f * low_res_factor,
+        pending_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // If we change the layer's CSS scale factor, then we should not get new
   // tilings.
   pending_layer_->CalculateContentsScale(1.8f,  // ideal contents scale
                                          1.7f,  // device scale
                                          3.2f,  // page scale
                                          1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.3f,
       pending_layer_->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(
-      1.3f * low_res_factor,
-      pending_layer_->tilings()->tiling_at(1)->contents_scale());
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_FLOAT_EQ(
+        1.3f * low_res_factor,
+        pending_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // If we change the page scale factor, then we should get new tilings.
   pending_layer_->CalculateContentsScale(1.8f,  // ideal contents scale
                                          1.7f,  // device scale
                                          2.2f,  // page scale
                                          1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 4u : 2u,
+      pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.8f,
       pending_layer_->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(
-      1.8f * low_res_factor,
-      pending_layer_->tilings()->tiling_at(2)->contents_scale());
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_FLOAT_EQ(
+        1.8f * low_res_factor,
+        pending_layer_->tilings()->tiling_at(2)->contents_scale());
 
   // If we change the device scale factor, then we should get new tilings.
   pending_layer_->CalculateContentsScale(1.9f,  // ideal contents scale
                                          1.4f,  // device scale
                                          2.2f,  // page scale
                                          1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 6u : 3u,
+      pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.9f,
       pending_layer_->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(
-      1.9f * low_res_factor,
-      pending_layer_->tilings()->tiling_at(3)->contents_scale());
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_FLOAT_EQ(
+        1.9f * low_res_factor,
+        pending_layer_->tilings()->tiling_at(3)->contents_scale());
 
   // If we change the device scale factor, but end up at the same total scale
   // factor somehow, then we don't get new tilings.
   pending_layer_->CalculateContentsScale(1.9f,  // ideal contents scale
                                          2.2f,  // device scale
                                          1.4f,  // page scale
                                          1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 6u : 3u,
+      pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.9f,
       pending_layer_->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(
-      1.9f * low_res_factor,
-      pending_layer_->tilings()->tiling_at(3)->contents_scale());
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_FLOAT_EQ(
+        1.9f * low_res_factor,
+        pending_layer_->tilings()->tiling_at(3)->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
   // This test makes sure that if a layer can have tilings, then a commit makes
   // it not able to have tilings (empty size), and then a future commit that
   // makes it valid again should be able to create tilings.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> empty_pile =
@@ skipping 14 matching lines @@
 
   SetupPendingTree(valid_pile);
   pending_layer_->CalculateContentsScale(high_res_scale,
                                          device_scale,
                                          page_scale,
                                          maximum_animation_scale,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(high_res_scale,
                   pending_layer_->HighResTiling()->contents_scale());
-  EXPECT_FLOAT_EQ(low_res_scale,
-                  pending_layer_->LowResTiling()->contents_scale());
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_FLOAT_EQ(low_res_scale,
+                    pending_layer_->LowResTiling()->contents_scale());
 
   ActivateTree();
   SetupPendingTree(empty_pile);
   pending_layer_->CalculateContentsScale(high_res_scale,
                                          device_scale,
                                          page_scale,
                                          maximum_animation_scale,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      active_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   ActivateTree();
   active_layer_->CalculateContentsScale(high_res_scale,
                                         device_scale,
                                         page_scale,
                                         maximum_animation_scale,
                                         false,
                                         &result_scale_x,
                                         &result_scale_y,
                                         &result_bounds);
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
 
   SetupPendingTree(valid_pile);
   pending_layer_->CalculateContentsScale(high_res_scale,
                                          device_scale,
                                          page_scale,
                                          maximum_animation_scale,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      pending_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(high_res_scale,
                   pending_layer_->HighResTiling()->contents_scale());
-  EXPECT_FLOAT_EQ(low_res_scale,
-                  pending_layer_->LowResTiling()->contents_scale());
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_FLOAT_EQ(low_res_scale,
+                    pending_layer_->LowResTiling()->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, ZoomOutCrash) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   // Set up the high and low res tilings before pinch zoom.
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
@@ skipping 15 matching lines @@
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   // Set up the high and low res tilings before pinch zoom.
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, false);
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
-  EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
+  EXPECT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.0f,
       active_layer_->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(
-      1.0f * low_res_factor,
-      active_layer_->tilings()->tiling_at(1)->contents_scale());
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_FLOAT_EQ(
+        1.0f * low_res_factor,
+        active_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // Start a pinch gesture.
   host_impl_.PinchGestureBegin();
 
   // Zoom out by a small amount. We should create a tiling at half
   // the scale (1/kMaxScaleRatioDuringPinch).
   SetContentsScaleOnBothLayers(0.90f, 1.0f, 0.9f, 1.0f, false);
-  EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
+  EXPECT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 3u : 2u,
+      active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.0f,
       active_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       0.5f,
       active_layer_->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_FLOAT_EQ(
-      1.0f * low_res_factor,
-      active_layer_->tilings()->tiling_at(2)->contents_scale());
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_FLOAT_EQ(
+        1.0f * low_res_factor,
+        active_layer_->tilings()->tiling_at(2)->contents_scale());
 
   // Zoom out further, close to our low-res scale factor. We should
   // use that tiling as high-res, and not create a new tiling.
   SetContentsScaleOnBothLayers(
       low_res_factor, 1.0f, low_res_factor, 1.0f, false);
   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 
   // Zoom in a lot now. Since we increase by increments of
   // kMaxScaleRatioDuringPinch, this will first use 0.5, then 1.0
   // and then finally create a new tiling at 2.0.
@@ skipping 24 matching lines @@
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   float device_scale = 1.7f;
   float page_scale = 3.2f;
 
   SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, 1.f, false);
-  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      active_layer_->tilings()->num_tilings());
 
   // We only have ideal tilings, so they aren't removed.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      active_layer_->tilings()->num_tilings());
 
   // Changing the ideal but not creating new tilings.
   SetContentsScaleOnBothLayers(1.5f, device_scale, page_scale, 1.f, false);
-  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      active_layer_->tilings()->num_tilings());
 
   // The tilings are still our target scale, so they aren't removed.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      active_layer_->tilings()->num_tilings());
 
   // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
   page_scale = 1.2f;
   SetContentsScaleOnBothLayers(1.2f, device_scale, page_scale, 1.f, false);
-  ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 4u : 2u,
+      active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.f,
       active_layer_->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_FLOAT_EQ(
-      1.f * low_res_factor,
-      active_layer_->tilings()->tiling_at(3)->contents_scale());
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_FLOAT_EQ(
+        1.f * low_res_factor,
+        active_layer_->tilings()->tiling_at(3)->contents_scale());
 
   // Mark the non-ideal tilings as used. They won't be removed.
   used_tilings.clear();
   used_tilings.push_back(active_layer_->tilings()->tiling_at(1));
   used_tilings.push_back(active_layer_->tilings()->tiling_at(3));
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 4u : 2u,
+      active_layer_->tilings()->num_tilings());
 
   // Now move the ideal scale to 0.5. Our target stays 1.2.
   SetContentsScaleOnBothLayers(0.5f, device_scale, page_scale, 1.f, false);
 
   // The high resolution tiling is between target and ideal, so is not
   // removed.  The low res tiling for the old ideal=1.0 scale is removed.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 3u : 2u,
+      active_layer_->tilings()->num_tilings());
 
   // Now move the ideal scale to 1.0. Our target stays 1.2.
   SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, 1.f, false);
 
   // All the tilings are between are target and the ideal, so they are not
   // removed.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 3u : 2u,
+      active_layer_->tilings()->num_tilings());
 
   // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
   active_layer_->CalculateContentsScale(1.1f,
                                         device_scale,
                                         page_scale,
                                         1.f,
                                         false,
                                         &result_scale_x,
                                         &result_scale_y,
                                         &result_bounds);
 
   // Because the pending layer's ideal scale is still 1.0, our tilings fall
   // in the range [1.0,1.2] and are kept.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 3u : 2u,
+      active_layer_->tilings()->num_tilings());
 
   // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
   // 1.2 still.
   pending_layer_->CalculateContentsScale(1.1f,
                                          device_scale,
                                          page_scale,
                                          1.f,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
 
   // Our 1.0 tiling now falls outside the range between our ideal scale and our
   // target raster scale. But it is in our used tilings set, so nothing is
   // deleted.
   used_tilings.clear();
   used_tilings.push_back(active_layer_->tilings()->tiling_at(1));
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 3u : 2u,
+      active_layer_->tilings()->num_tilings());
 
   // If we remove it from our used tilings set, it is outside the range to keep
   // so it is deleted.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      active_layer_->tilings()->num_tilings());
 }
 
 #define EXPECT_BOTH_EQ(expression, x)         \
   do {                                        \
     EXPECT_EQ(pending_layer_->expression, x); \
     EXPECT_EQ(active_layer_->expression, x);  \
   } while (false)
 
 TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
   // Make sure this layer covers multiple tiles, since otherwise low
@@ skipping 21 matching lines @@
   EXPECT_BOTH_EQ(num_tilings(), 1u);
 
   // Stop animating, low res gets created.
   animating_transform = false;
   SetContentsScaleOnBothLayers(contents_scale,
                                device_scale,
                                page_scale,
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
-  EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor);
-  EXPECT_BOTH_EQ(num_tilings(), 2u);
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor);
+  EXPECT_BOTH_EQ(
+      num_tilings(),
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u);
 
   // Page scale animation, new high res, but not new low res because animating.
   contents_scale = 2.f;
   page_scale = 2.f;
   animating_transform = true;
   SetContentsScaleOnBothLayers(contents_scale,
                                device_scale,
                                page_scale,
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
-  EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor);
-  EXPECT_BOTH_EQ(num_tilings(), 3u);
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor);
+  EXPECT_BOTH_EQ(
+      num_tilings(),
+      host_impl_.settings().create_low_res_tiling ? 3u : 2u);
 
   // Stop animating, new low res gets created for final page scale.
   animating_transform = false;
   SetContentsScaleOnBothLayers(contents_scale,
                                device_scale,
                                page_scale,
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
-  EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), 2.f * low_res_factor);
-  EXPECT_BOTH_EQ(num_tilings(), 4u);
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), 2.f * low_res_factor);
+  EXPECT_BOTH_EQ(
+      num_tilings(),
+      host_impl_.settings().create_low_res_tiling ? 4u : 2u);
 }
 
 TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
   gfx::Size tile_size(host_impl_.settings().default_tile_size);
   SetupDefaultTrees(tile_size);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   float device_scale = 1.f;
   float page_scale = 1.f;
   float maximum_animation_scale = 1.f;
@@ skipping 25 matching lines @@
 
   // Any content bounds that would create more than one tile will
   // generate a low res tiling.
   contents_scale = 2.5f;
   SetContentsScaleOnBothLayers(contents_scale,
                                device_scale,
                                page_scale,
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
-  EXPECT_BOTH_EQ(LowResTiling()->contents_scale(),
-                 contents_scale * low_res_factor);
-  EXPECT_BOTH_EQ(num_tilings(), 2u);
+  if (host_impl_.settings().create_low_res_tiling)
+    EXPECT_BOTH_EQ(LowResTiling()->contents_scale(),
+                   contents_scale * low_res_factor);
+  EXPECT_BOTH_EQ(
+      num_tilings(),
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u);
 
   ResetTilingsAndRasterScales();
 
   // Mask layers dont create low res since they always fit on one tile.
   pending_layer_->SetIsMask(true);
   active_layer_->SetIsMask(true);
   SetContentsScaleOnBothLayers(contents_scale,
                                device_scale,
                                page_scale,
                                maximum_animation_scale,
@@ skipping 18 matching lines @@
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
                                          2.7f,  // device scale
                                          3.2f,  // page scale
                                          1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  EXPECT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      pending_layer_->tilings()->num_tilings());
 
   // All tilings should be removed when losing output surface.
   active_layer_->ReleaseResources();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   pending_layer_->ReleaseResources();
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   // This should create new tilings.
   pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
                                          2.7f,  // device scale
                                          3.2f,  // page scale
                                          1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  EXPECT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
   // The default max tile size is larger than 400x400.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(5000, 5000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->CalculateContentsScale(1.f,
                                          1.f,
                                          1.f,
                                          1.f,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // The default value.
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             host_impl_.settings().default_tile_size.ToString());
 
   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             tile->content_rect().size().ToString());
 
   pending_layer_->ReleaseResources();
 
   // Change the max texture size on the output surface context.
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
   host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
       context.Pass()).PassAs<OutputSurface>());
 
   pending_layer_->CalculateContentsScale(1.f,
                                          1.f,
                                          1.f,
                                          1.f,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
-  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // Verify the tiles are not larger than the context's max texture size.
   tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_GE(140, tile->content_rect().width());
   EXPECT_GE(140, tile->content_rect().height());
 }
 
 TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
@@ skipping 175 matching lines @@
     }
   }
 
   EXPECT_GT(num_visible, 0);
   EXPECT_GT(num_offscreen, 0);
 }
 
 TEST_F(PictureLayerImplTest, HighResRequiredWhenUnsharedActiveAllReady) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
+
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
 
   // No tiles shared.
   pending_layer_->set_invalidation(gfx::Rect(layer_bounds));
 
   CreateHighLowResAndSetAllTilesVisible();
 
   active_layer_->SetAllTilesReady();
 
   // No shared tiles and all active tiles ready, so pending can only
   // activate with all high res tiles.
   pending_layer_->MarkVisibleResourcesAsRequired();
   AssertAllTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  if (host_impl_.settings().create_low_res_tiling)
+    AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, HighResRequiredWhenMissingHighResFlagOn) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
 
   // All tiles shared (no invalidation).
   CreateHighLowResAndSetAllTilesVisible();
 
   // Verify active tree not ready.
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
 
   // When high res are required, even if the active tree is not ready,
   // the high res tiles must be ready.
   host_impl_.active_tree()->SetRequiresHighResToDraw();
   pending_layer_->MarkVisibleResourcesAsRequired();
   AssertAllTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  if (host_impl_.settings().create_low_res_tiling)
+    AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, NothingRequiredIfAllHighResTilesShared) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
 
   CreateHighLowResAndSetAllTilesVisible();
 
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
 
   // All tiles shared (no invalidation), so even though the active tree's
   // tiles aren't ready, there is nothing required.
   pending_layer_->MarkVisibleResourcesAsRequired();
+  VLOG(0) << "NothingRequiredIfAllHighResTilesShared::AssertNoTilesRequired";
   AssertNoTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  if (host_impl_.settings().create_low_res_tiling) {
+    VLOG(0) << "NothingRequiredIfAllHighResTilesShared::AssertNoTilesRequired -> low-res";
+    AssertNoTilesRequired(pending_layer_->LowResTiling());
+  }
 }
 
 TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   // This pile will create tilings, but has no recordings so will not create any
   // tiles.  This is attempting to simulate scrolling past the end of recorded
   // content on the active layer, where the recordings are so far away that
   // no tiles are created.
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
           tile_size, layer_bounds);
   SetupTrees(pending_pile, active_pile);
   pending_layer_->set_fixed_tile_size(tile_size);
   active_layer_->set_fixed_tile_size(tile_size);
 
   CreateHighLowResAndSetAllTilesVisible();
 
   // Active layer has tilings, but no tiles due to missing recordings.
   EXPECT_TRUE(active_layer_->CanHaveTilings());
-  EXPECT_EQ(active_layer_->tilings()->num_tilings(), 2u);
+  EXPECT_EQ(
+      active_layer_->tilings()->num_tilings(),
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u);
   EXPECT_EQ(active_layer_->HighResTiling()->AllTilesForTesting().size(), 0u);
 
   // Since the active layer has no tiles at all, the pending layer doesn't
   // need content in order to activate.
   pending_layer_->MarkVisibleResourcesAsRequired();
   AssertNoTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  if (host_impl_.settings().create_low_res_tiling)
+    AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   SetupTrees(pending_pile, active_pile);
   pending_layer_->set_fixed_tile_size(tile_size);
   active_layer_->set_fixed_tile_size(tile_size);
 
   CreateHighLowResAndSetAllTilesVisible();
 
   // Active layer can't have tiles.
   EXPECT_FALSE(active_layer_->CanHaveTilings());
 
   // All high res tiles required.  This should be considered identical
   // to the case where there is no active layer, to avoid flashing content.
   // This can happen if a layer exists for a while and switches from
   // not being able to have content to having content.
   pending_layer_->MarkVisibleResourcesAsRequired();
   AssertAllTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  if (host_impl_.settings().create_low_res_tiling)
+    AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   host_impl_.CreatePendingTree();
   LayerTreeImpl* pending_tree = host_impl_.pending_tree();
@@ skipping 100 matching lines @@
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
   pending_layer_->CalculateContentsScale(1.f,
                                          1.f,
                                          1.f,
                                          1.f,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   // Should have a low-res and a high-res tiling.
-  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(
+      host_impl_.settings().create_low_res_tiling ? 2u : 1u,
+      pending_layer_->tilings()->num_tilings());
 
   pending_layer_->SetUseGpuRasterization(true);
   EXPECT_TRUE(pending_layer_->ShouldUseGpuRasterization());
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
   pending_layer_->CalculateContentsScale(1.f,
                                          1.f,
                                          1.f,
                                          1.f,
                                          false,
                                          &result_scale_x,
@@ skipping 555 matching lines @@
         occluded,
         &partially_occluded_count);
     // The layer outputs one quad, which is partially occluded.
     EXPECT_EQ(100u - 10u, impl.quad_list().size());
     EXPECT_EQ(10u + 10u, partially_occluded_count);
   }
 }
 
 }  // namespace
 }  // namespace cc