Update from https://crrev.com/308331

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 4163 matching lines @@
 
     TileDrawQuad* test_blending_draw_quad =
         render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
     test_blending_draw_quad->SetNew(shared_quad_state,
                                     quad_rect_,
                                     opaque_rect,
                                     visible_quad_rect,
                                     resource_id_,
                                     gfx::RectF(0.f, 0.f, 1.f, 1.f),
                                     gfx::Size(1, 1),
+                                    false,
                                     false);
     test_blending_draw_quad->visible_rect = quad_visible_rect_;
     EXPECT_EQ(blend_, test_blending_draw_quad->ShouldDrawWithBlending());
     EXPECT_EQ(has_render_surface_, !!render_surface());
   }
 
   void SetExpectation(bool blend, bool has_render_surface) {
     blend_ = blend;
     has_render_surface_ = has_render_surface;
     quads_appended_ = false;
@@ skipping 3567 matching lines @@
   host_impl_->UpdateAnimationState(true);
 
   EXPECT_VECTOR_EQ(gfx::ScrollOffset(0, 100),
                    scrolling_layer->TotalScrollOffset());
   EXPECT_EQ(NULL, host_impl_->CurrentlyScrollingLayer());
 }
 
 TEST_F(LayerTreeHostImplTest, GetPictureLayerImplPairs) {
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->SetRootLayer(
-      PictureLayerImpl::Create(host_impl_->pending_tree(), 10));
+      PictureLayerImpl::Create(host_impl_->pending_tree(), 10, false));
 
   LayerTreeImpl* pending_tree = host_impl_->pending_tree();
   LayerImpl* pending_layer = pending_tree->root_layer();
 
   std::vector<PictureLayerImpl::Pair> layer_pairs;
   host_impl_->GetPictureLayerImplPairs(&layer_pairs, true);
   EXPECT_EQ(1u, layer_pairs.size());
   EXPECT_EQ(pending_layer, layer_pairs[0].pending);
   EXPECT_EQ(nullptr, layer_pairs[0].active);
 
@@ skipping 20 matching lines @@
   layer_pairs.clear();
   host_impl_->GetPictureLayerImplPairs(&layer_pairs, true);
   EXPECT_EQ(1u, layer_pairs.size());
   EXPECT_EQ(active_layer, layer_pairs[0].active);
   EXPECT_EQ(nullptr, layer_pairs[0].pending);
 
   // Create another layer in the pending tree that's not in the active tree. We
   // should get two pairs.
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->root_layer()->AddChild(
-      PictureLayerImpl::Create(host_impl_->pending_tree(), 11));
+      PictureLayerImpl::Create(host_impl_->pending_tree(), 11, false));
 
   LayerImpl* new_pending_layer = pending_tree->root_layer()->children()[0];
 
   layer_pairs.clear();
   host_impl_->GetPictureLayerImplPairs(&layer_pairs, true);
   EXPECT_EQ(2u, layer_pairs.size());
 
   // The pair ordering is flaky, so make it consistent.
   if (layer_pairs[0].active != active_layer)
     std::swap(layer_pairs[0], layer_pairs[1]);
@@ skipping 105 matching lines @@
   // surface.
   EXPECT_EQ(0, num_lost_surfaces_);
   host_impl_->DidLoseOutputSurface();
   EXPECT_EQ(1, num_lost_surfaces_);
   host_impl_->DidLoseOutputSurface();
   EXPECT_LE(1, num_lost_surfaces_);
 }
 
 }  // namespace
 }  // namespace cc