Update from https://crrev.com/316786

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 1821 matching lines @@
   DrawFrame();
   {
     CompositorFrameMetadata metadata =
         host_impl_->MakeCompositorFrameMetadata();
     EXPECT_EQ(gfx::Vector2dF(), metadata.root_scroll_offset);
     EXPECT_EQ(1.f, metadata.page_scale_factor);
     EXPECT_EQ(gfx::SizeF(50.f, 50.f), metadata.scrollable_viewport_size);
     EXPECT_EQ(gfx::SizeF(100.f, 100.f), metadata.root_layer_size);
     EXPECT_EQ(0.5f, metadata.min_page_scale_factor);
     EXPECT_EQ(4.f, metadata.max_page_scale_factor);
+    EXPECT_FALSE(metadata.root_overflow_x_hidden);
+    EXPECT_FALSE(metadata.root_overflow_y_hidden);
   }
 
   // Scrolling should update metadata immediately.
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Wheel));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   {
     CompositorFrameMetadata metadata =
         host_impl_->MakeCompositorFrameMetadata();
     EXPECT_EQ(gfx::Vector2dF(0.f, 10.f), metadata.root_scroll_offset);
   }
   host_impl_->ScrollEnd();
   {
     CompositorFrameMetadata metadata =
         host_impl_->MakeCompositorFrameMetadata();
     EXPECT_EQ(gfx::Vector2dF(0.f, 10.f), metadata.root_scroll_offset);
   }
 
+  // Root "overflow: hidden" properties should be reflected.
+  {
+    host_impl_->active_tree()
+        ->InnerViewportScrollLayer()
+        ->set_user_scrollable_horizontal(false);
+    CompositorFrameMetadata metadata =
+        host_impl_->MakeCompositorFrameMetadata();
+    EXPECT_TRUE(metadata.root_overflow_x_hidden);
+    EXPECT_FALSE(metadata.root_overflow_y_hidden);
+
+    host_impl_->active_tree()
+        ->InnerViewportScrollLayer()
+        ->set_user_scrollable_vertical(false);
+    metadata = host_impl_->MakeCompositorFrameMetadata();
+    EXPECT_TRUE(metadata.root_overflow_x_hidden);
+    EXPECT_TRUE(metadata.root_overflow_y_hidden);
+  }
+
   // Page scale should update metadata correctly (shrinking only the viewport).
   host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture);
   host_impl_->PinchGestureBegin();
   host_impl_->PinchGestureUpdate(2.f, gfx::Point());
   host_impl_->PinchGestureEnd();
   host_impl_->ScrollEnd();
   {
     CompositorFrameMetadata metadata =
         host_impl_->MakeCompositorFrameMetadata();
     EXPECT_EQ(gfx::Vector2dF(0.f, 10.f), metadata.root_scroll_offset);
@@ skipping 27 matching lines @@
   }
 
   bool WillDraw(DrawMode draw_mode, ResourceProvider* provider) override {
     will_draw_called_ = true;
     if (will_draw_returns_false_)
       return false;
     return LayerImpl::WillDraw(draw_mode, provider);
   }
 
   void AppendQuads(RenderPass* render_pass,
-                   const Occlusion& occlusion_in_content_space,
                    AppendQuadsData* append_quads_data) override {
     append_quads_called_ = true;
-    LayerImpl::AppendQuads(
-        render_pass, occlusion_in_content_space, append_quads_data);
+    LayerImpl::AppendQuads(render_pass, append_quads_data);
   }
 
   void DidDraw(ResourceProvider* provider) override {
     did_draw_called_ = true;
     LayerImpl::DidDraw(provider);
   }
 
   bool will_draw_called() const { return will_draw_called_; }
   bool append_quads_called() const { return append_quads_called_; }
   bool did_draw_called() const { return did_draw_called_; }
@@ skipping 202 matching lines @@
                                       ResourceProvider* resource_provider) {
     return make_scoped_ptr(new MissingTextureAnimatingLayer(tree_impl,
                                                             id,
                                                             tile_missing,
                                                             had_incomplete_tile,
                                                             animating,
                                                             resource_provider));
   }
 
   void AppendQuads(RenderPass* render_pass,
-                   const Occlusion& occlusion_in_content_space,
                    AppendQuadsData* append_quads_data) override {
-    LayerImpl::AppendQuads(
-        render_pass, occlusion_in_content_space, append_quads_data);
+    LayerImpl::AppendQuads(render_pass, append_quads_data);
     if (had_incomplete_tile_)
       append_quads_data->num_incomplete_tiles++;
     if (tile_missing_)
       append_quads_data->num_missing_tiles++;
   }
 
  private:
   MissingTextureAnimatingLayer(LayerTreeImpl* tree_impl,
                                int id,
                                bool tile_missing,
@@ skipping 301 matching lines @@
     viewport_size_ = gfx::Size(clip_size_.width(),
                                clip_size_.height() + top_controls_height_);
   }
 
   bool CreateHostImpl(const LayerTreeSettings& settings,
                       scoped_ptr<OutputSurface> output_surface) override {
     bool init =
         LayerTreeHostImplTest::CreateHostImpl(settings, output_surface.Pass());
     if (init && settings.calculate_top_controls_position) {
       host_impl_->active_tree()->set_top_controls_height(top_controls_height_);
-      host_impl_->active_tree()->set_top_controls_delta(top_controls_height_);
-      host_impl_->top_controls_manager()->SetTopControlsHeight(
-          top_controls_height_);
-      host_impl_->DidChangeTopControlsPosition();
+      host_impl_->active_tree()->SetCurrentTopControlsShownRatio(1.f);
     }
     return init;
   }
 
   void SetupTopControlsAndScrollLayer() {
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     scoped_ptr<LayerImpl> root_clip =
         LayerImpl::Create(host_impl_->active_tree(), 2);
     root_clip->SetBounds(clip_size_);
@@ skipping 13 matching lines @@
         Layer::INVALID_ID, page_scale_layer_id, inner_viewport_scroll_layer_id,
         Layer::INVALID_ID);
     // Set a viewport size that is large enough to contain both the top controls
     // and some content.
     host_impl_->SetViewportSize(viewport_size_);
     host_impl_->sync_tree()->set_top_controls_shrink_blink_size(true);
 
     host_impl_->DidChangeTopControlsPosition();
 
     host_impl_->CreatePendingTree();
+    host_impl_->sync_tree()->set_top_controls_height(top_controls_height_);
     root =
         LayerImpl::Create(host_impl_->sync_tree(), 1);
     root_clip =
         LayerImpl::Create(host_impl_->sync_tree(), 2);
     root_clip->SetBounds(clip_size_);
     root->SetScrollClipLayer(root_clip->id());
     root->SetBounds(layer_size_);
     root->SetContentBounds(layer_size_);
     root->SetPosition(gfx::PointF());
     root->SetDrawsContent(false);
@@ skipping 11 matching lines @@
     host_impl_->sync_tree()->set_top_controls_shrink_blink_size(true);
     host_impl_->DidChangeTopControlsPosition();
   }
 
   void SetupTopControlsAndScrollLayerWithVirtualViewport(
       const gfx::Size& inner_viewport_size,
       const gfx::Size& outer_viewport_size,
       const gfx::Size& scroll_layer_size) {
     CreateHostImpl(settings_, CreateOutputSurface());
     host_impl_->sync_tree()->set_top_controls_shrink_blink_size(true);
+    host_impl_->sync_tree()->set_top_controls_height(top_controls_height_);
     host_impl_->DidChangeTopControlsPosition();
 
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     scoped_ptr<LayerImpl> root_clip =
         LayerImpl::Create(host_impl_->active_tree(), 2);
     scoped_ptr<LayerImpl> page_scale =
         LayerImpl::Create(host_impl_->active_tree(), 3);
 
     scoped_ptr<LayerImpl> outer_scroll =
@@ skipping 58 matching lines @@
   // (3) matches the movement of the top controls.
   gfx::Vector2dF top_controls_scroll_delta(0.f, 5.25f);
   host_impl_->top_controls_manager()->ScrollBegin();
   host_impl_->top_controls_manager()->ScrollBy(top_controls_scroll_delta);
   host_impl_->top_controls_manager()->ScrollEnd();
 
   LayerImpl* inner_viewport_scroll_layer =
       host_impl_->active_tree()->InnerViewportScrollLayer();
   DCHECK(inner_viewport_scroll_layer);
   host_impl_->ScrollEnd();
-  EXPECT_EQ(top_controls_scroll_delta,
-            inner_viewport_scroll_layer->FixedContainerSizeDelta());
+  EXPECT_FLOAT_EQ(top_controls_scroll_delta.y(),
+                  inner_viewport_scroll_layer->FixedContainerSizeDelta().y());
 }
 
 // In this test, the outer viewport is initially unscrollable. We test that a
 // scroll initiated on the inner viewport, causing the top controls to show and
 // thus making the outer viewport scrollable, still scrolls the outer viewport.
 TEST_F(LayerTreeHostImplTopControlsTest,
     TopControlsOuterViewportBecomesScrollable) {
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(10, 50), gfx::Size(10, 50), gfx::Size(10, 100));
   DrawFrame();
@@ skipping 10 matching lines @@
   // Need SetDrawsContent so ScrollBegin's hit test finds an actual layer.
   outer_scroll->SetDrawsContent(true);
   host_impl_->active_tree()->PushPageScaleFromMainThread(2.f, 1.f, 2.f);
 
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, 50.f));
 
   // The entire scroll delta should have been used to hide the top controls.
   // The viewport layers should be resized back to their full sizes.
-  EXPECT_EQ(0.f,
-      host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_EQ(0.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
   EXPECT_EQ(0.f, inner_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(100.f, inner_container->BoundsForScrolling().height());
   EXPECT_EQ(100.f, outer_container->BoundsForScrolling().height());
 
   // The inner viewport should be scrollable by 50px * page_scale.
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, 100.f));
   EXPECT_EQ(50.f, inner_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(0.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(gfx::ScrollOffset(), outer_scroll->MaxScrollOffset());
 
   host_impl_->ScrollEnd();
 
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
   EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), inner_scroll);
 
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, -50.f));
 
   // The entire scroll delta should have been used to show the top controls.
   // The outer viewport should be resized to accomodate and scrolled to the
   // bottom of the document to keep the viewport in place.
-  EXPECT_EQ(50.f,
-      host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
   EXPECT_EQ(50.f, outer_container->BoundsForScrolling().height());
   EXPECT_EQ(50.f, inner_container->BoundsForScrolling().height());
   EXPECT_EQ(25.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(25.f, inner_scroll->CurrentScrollOffset().y());
 
   // Now when we continue scrolling, make sure the outer viewport gets scrolled
   // since it wasn't scrollable when the scroll began.
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, -20.f));
   EXPECT_EQ(15.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(25.f, inner_scroll->CurrentScrollOffset().y());
@@ skipping 25 matching lines @@
   host_impl_->active_tree()->PushPageScaleFromMainThread(page_scale, 1.f, 2.f);
 
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
 
   // Scroll down, the top controls hiding should expand the viewport size so
   // the delta should be equal to the scroll distance.
   gfx::Vector2dF top_controls_scroll_delta(0.f, 20.f);
   host_impl_->top_controls_manager()->ScrollBegin();
   host_impl_->top_controls_manager()->ScrollBy(top_controls_scroll_delta);
-  EXPECT_EQ(top_controls_height_ - top_controls_scroll_delta.y(),
-            host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_FLOAT_EQ(top_controls_height_ - top_controls_scroll_delta.y(),
+                  host_impl_->top_controls_manager()->ContentTopOffset());
   EXPECT_VECTOR_EQ(top_controls_scroll_delta,
                    outer_viewport_scroll_layer->FixedContainerSizeDelta());
   host_impl_->ScrollEnd();
 
   // Scroll past the maximum extent. The delta shouldn't be greater than the
   // top controls height.
   host_impl_->top_controls_manager()->ScrollBegin();
   host_impl_->top_controls_manager()->ScrollBy(top_controls_scroll_delta);
   host_impl_->top_controls_manager()->ScrollBy(top_controls_scroll_delta);
   host_impl_->top_controls_manager()->ScrollBy(top_controls_scroll_delta);
@@ skipping 16 matching lines @@
 // Test that if a scrollable sublayer doesn't consume the scroll,
 // top controls should hide when scrolling down.
 TEST_F(LayerTreeHostImplTopControlsTest, TopControlsScrollableSublayer) {
   gfx::Size sub_content_size(100, 400);
   gfx::Size sub_content_layer_size(100, 300);
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 50), gfx::Size(100, 100), gfx::Size(100, 100));
   DrawFrame();
 
   // Show top controls
-  EXPECT_EQ(top_controls_height_,
-            host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
 
   LayerImpl* outer_viewport_scroll_layer =
       host_impl_->active_tree()->OuterViewportScrollLayer();
   int id = outer_viewport_scroll_layer->id();
 
   scoped_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl_->active_tree(), id + 2);
   scoped_ptr<LayerImpl> child_clip =
       LayerImpl::Create(host_impl_->active_tree(), id + 3);
 
@@ skipping 13 matching lines @@
   // Scroll 25px to hide top controls
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
   host_impl_->ScrollEnd();
 
   // Top controls should be hidden
   EXPECT_EQ(scroll_delta.y(),
             top_controls_height_ -
-                host_impl_->active_tree()->total_top_controls_content_offset());
+                host_impl_->top_controls_manager()->ContentTopOffset());
 }
 
 // Ensure setting the top controls position explicitly using the setters on the
 // TreeImpl correctly affects the top controls manager and viewport bounds.
 TEST_F(LayerTreeHostImplTopControlsTest, PositionTopControlsExplicitly) {
   CreateHostImpl(settings_, CreateOutputSurface());
   SetupTopControlsAndScrollLayer();
   DrawFrame();
 
-  host_impl_->active_tree()->set_top_controls_delta(0.f);
-  host_impl_->active_tree()->set_top_controls_content_offset(30.f);
-  EXPECT_EQ(30.f, host_impl_->top_controls_manager()->ContentTopOffset());
-  EXPECT_EQ(-20.f, host_impl_->top_controls_manager()->ControlsTopOffset());
+  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(0.f);
+  host_impl_->active_tree()->top_controls_shown_ratio()->PushFromMainThread(
+      30.f / top_controls_height_);
+  host_impl_->active_tree()->top_controls_shown_ratio()->PushPendingToActive();
+  EXPECT_FLOAT_EQ(30.f, host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_FLOAT_EQ(-20.f,
+                  host_impl_->top_controls_manager()->ControlsTopOffset());
 
-  host_impl_->active_tree()->set_top_controls_delta(-30.f);
-  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
-  EXPECT_EQ(-50.f, host_impl_->top_controls_manager()->ControlsTopOffset());
+  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(0.f);
+  EXPECT_FLOAT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_FLOAT_EQ(-50.f,
+                  host_impl_->top_controls_manager()->ControlsTopOffset());
 
   host_impl_->DidChangeTopControlsPosition();
 
   // Now that top controls have moved, expect the clip to resize.
   LayerImpl* root_clip_ptr = host_impl_->active_tree()->root_layer();
   EXPECT_EQ(viewport_size_, root_clip_ptr->bounds());
 }
 
 // Test that the top_controls delta and sent delta are appropriately
 // applied on sync tree activation. The total top controls offset shouldn't
 // change after the activation.
 TEST_F(LayerTreeHostImplTopControlsTest, ApplyDeltaOnTreeActivation) {
   CreateHostImpl(settings_, CreateOutputSurface());
   SetupTopControlsAndScrollLayer();
   DrawFrame();
 
-  host_impl_->sync_tree()->set_top_controls_content_offset(15.f);
-
-  host_impl_->active_tree()->set_top_controls_content_offset(20.f);
-  host_impl_->active_tree()->set_top_controls_delta(-20.f);
-  host_impl_->active_tree()->set_sent_top_controls_delta(-5.f);
+  host_impl_->active_tree()->top_controls_shown_ratio()->PushFromMainThread(
+      20.f / top_controls_height_);
+  host_impl_->active_tree()->top_controls_shown_ratio()->PushPendingToActive();
+  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(
+      15.f / top_controls_height_);
+  host_impl_->active_tree()
+      ->top_controls_shown_ratio()
+      ->PullDeltaForMainThread();
+  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(0.f);
+  host_impl_->sync_tree()->PushTopControlsFromMainThread(15.f /
+                                                         top_controls_height_);
 
   host_impl_->DidChangeTopControlsPosition();
   LayerImpl* root_clip_ptr = host_impl_->active_tree()->root_layer();
   EXPECT_EQ(viewport_size_, root_clip_ptr->bounds());
   EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
-  EXPECT_EQ(0.f,
-      host_impl_->active_tree()->total_top_controls_content_offset());
 
   host_impl_->ActivateSyncTree();
 
   root_clip_ptr = host_impl_->active_tree()->root_layer();
   EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
   EXPECT_EQ(viewport_size_, root_clip_ptr->bounds());
 
-  EXPECT_EQ(0.f, host_impl_->active_tree()->sent_top_controls_delta());
-  EXPECT_EQ(-15.f, host_impl_->active_tree()->top_controls_delta());
-  EXPECT_EQ(15.f, host_impl_->active_tree()->top_controls_content_offset());
-  EXPECT_EQ(0.f,
-      host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_FLOAT_EQ(
+      -15.f, host_impl_->active_tree()->top_controls_shown_ratio()->Delta() *
+                 top_controls_height_);
+  EXPECT_FLOAT_EQ(
+      15.f,
+      host_impl_->active_tree()->top_controls_shown_ratio()->ActiveBase() *
+          top_controls_height_);
 }
 
 // Test that changing the top controls layout height is correctly applied to
 // the inner viewport container bounds. That is, the top controls layout
 // height is the amount that the inner viewport container was shrunk outside
 // the compositor to accommodate the top controls.
 TEST_F(LayerTreeHostImplTopControlsTest, TopControlsLayoutHeightChanged) {
   CreateHostImpl(settings_, CreateOutputSurface());
   SetupTopControlsAndScrollLayer();
   DrawFrame();
 
-  host_impl_->sync_tree()->set_top_controls_content_offset(50.f);
+  host_impl_->sync_tree()->PushTopControlsFromMainThread(1.f);
   host_impl_->sync_tree()->set_top_controls_shrink_blink_size(true);
 
-  host_impl_->active_tree()->set_top_controls_content_offset(50.f);
-  host_impl_->active_tree()->set_top_controls_delta(-50.f);
+  host_impl_->active_tree()->top_controls_shown_ratio()->PushFromMainThread(
+      1.f);
+  host_impl_->active_tree()->top_controls_shown_ratio()->PushPendingToActive();
+  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(0.f);
 
   host_impl_->DidChangeTopControlsPosition();
   LayerImpl* root_clip_ptr = host_impl_->active_tree()->root_layer();
   EXPECT_EQ(viewport_size_, root_clip_ptr->bounds());
   EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
 
   host_impl_->sync_tree()->root_layer()->SetBounds(
       gfx::Size(root_clip_ptr->bounds().width(),
                 root_clip_ptr->bounds().height() - 50.f));
 
   host_impl_->ActivateSyncTree();
 
   root_clip_ptr = host_impl_->active_tree()->root_layer();
   EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ContentTopOffset());
 
   // The total bounds should remain unchanged since the bounds delta should
   // account for the difference between the layout height and the current
   // top controls offset.
   EXPECT_EQ(viewport_size_, root_clip_ptr->bounds());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0.f, 50.f), root_clip_ptr->bounds_delta());
 
-  host_impl_->active_tree()->set_top_controls_delta(0.f);
+  host_impl_->active_tree()->SetCurrentTopControlsShownRatio(1.f);
   host_impl_->DidChangeTopControlsPosition();
 
+  EXPECT_EQ(1.f, host_impl_->top_controls_manager()->TopControlsShownRatio());
+  EXPECT_EQ(50.f, host_impl_->top_controls_manager()->TopControlsHeight());
   EXPECT_EQ(50.f, host_impl_->top_controls_manager()->ContentTopOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0.f, 0.f), root_clip_ptr->bounds_delta());
   EXPECT_EQ(gfx::Size(viewport_size_.width(), viewport_size_.height() - 50.f),
             root_clip_ptr->bounds());
 }
 
 // Test that showing/hiding the top controls when the viewport is fully scrolled
 // doesn't incorrectly change the viewport offset due to clamping from changing
 // viewport bounds.
 TEST_F(LayerTreeHostImplTopControlsTest, TopControlsViewportOffsetClamping) {
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400));
   DrawFrame();
 
-  EXPECT_EQ(top_controls_height_,
-            host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
 
   LayerImpl* outer_scroll = host_impl_->OuterViewportScrollLayer();
   LayerImpl* inner_scroll = host_impl_->InnerViewportScrollLayer();
 
   // Scroll the viewports to max scroll offset.
   outer_scroll->SetScrollDelta(gfx::Vector2dF(0, 200.f));
   inner_scroll->SetScrollDelta(gfx::Vector2dF(100, 100.f));
 
   gfx::ScrollOffset viewport_offset =
       host_impl_->active_tree()->TotalScrollOffset();
   EXPECT_EQ(host_impl_->active_tree()->TotalMaxScrollOffset(), viewport_offset);
 
   // Hide the top controls by 25px.
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
 
   // scrolling down at the max extents no longer hides the top controls
-  EXPECT_EQ(0.f,
-            top_controls_height_ -
-                host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
 
   // forcefully hide the top controls by 25px
   host_impl_->top_controls_manager()->ScrollBy(scroll_delta);
   host_impl_->ScrollEnd();
 
-  EXPECT_EQ(scroll_delta.y(),
-            top_controls_height_ -
-                host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_FLOAT_EQ(scroll_delta.y(),
+                  top_controls_height_ -
+                      host_impl_->top_controls_manager()->ContentTopOffset());
 
   inner_scroll->ClampScrollToMaxScrollOffset();
   outer_scroll->ClampScrollToMaxScrollOffset();
 
   // We should still be fully scrolled.
   EXPECT_EQ(host_impl_->active_tree()->TotalMaxScrollOffset(),
             host_impl_->active_tree()->TotalScrollOffset());
 
   viewport_offset = host_impl_->active_tree()->TotalScrollOffset();
 
@@ skipping 15 matching lines @@
             host_impl_->active_tree()->TotalScrollOffset());
 }
 
 // Test that the top controls coming in and out maintains the same aspect ratio
 // between the inner and outer viewports.
 TEST_F(LayerTreeHostImplTopControlsTest, TopControlsAspectRatio) {
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400));
   DrawFrame();
 
-  EXPECT_EQ(top_controls_height_,
-            host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_FLOAT_EQ(top_controls_height_,
+                  host_impl_->top_controls_manager()->ContentTopOffset());
 
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
   host_impl_->ScrollEnd();
 
-  EXPECT_EQ(scroll_delta.y(),
-            top_controls_height_ -
-                host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_FLOAT_EQ(scroll_delta.y(),
+                  top_controls_height_ -
+                      host_impl_->top_controls_manager()->ContentTopOffset());
 
   // Top controls were hidden by 25px so the inner viewport should have expanded
   // by that much.
   LayerImpl* outer_container =
             host_impl_->active_tree()->OuterViewportContainerLayer();
   LayerImpl* inner_container =
             host_impl_->active_tree()->InnerViewportContainerLayer();
   EXPECT_EQ(gfx::Size(100, 100+25), inner_container->BoundsForScrolling());
 
   // Outer viewport should match inner's aspect ratio. The bounds are ceiled.
   float aspect_ratio = inner_container->BoundsForScrolling().width() /
                        inner_container->BoundsForScrolling().height();
   gfx::Size expected = gfx::ToCeiledSize(gfx::SizeF(200, 200 / aspect_ratio));
   EXPECT_EQ(expected, outer_container->BoundsForScrolling());
   EXPECT_EQ(expected,
             host_impl_->InnerViewportScrollLayer()->BoundsForScrolling());
 }
 
 // Test that scrolling the outer viewport affects the top controls.
 TEST_F(LayerTreeHostImplTopControlsTest, TopControlsScrollOuterViewport) {
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400));
   DrawFrame();
 
   EXPECT_EQ(top_controls_height_,
-            host_impl_->active_tree()->total_top_controls_content_offset());
+            host_impl_->top_controls_manager()->ContentTopOffset());
 
   // Send a gesture scroll that will scroll the outer viewport, make sure the
   // top controls get scrolled.
   gfx::Vector2dF scroll_delta(0.f, 15.f);
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
   EXPECT_EQ(host_impl_->OuterViewportScrollLayer(),
             host_impl_->CurrentlyScrollingLayer());
   host_impl_->ScrollEnd();
 
-  EXPECT_EQ(scroll_delta.y(),
-            top_controls_height_ -
-                host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_FLOAT_EQ(scroll_delta.y(),
+                  top_controls_height_ -
+                      host_impl_->top_controls_manager()->ContentTopOffset());
 
   scroll_delta = gfx::Vector2dF(0.f, 50.f);
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
 
-  EXPECT_EQ(0, host_impl_->active_tree()->total_top_controls_content_offset());
+  EXPECT_EQ(0, host_impl_->top_controls_manager()->ContentTopOffset());
   EXPECT_EQ(host_impl_->OuterViewportScrollLayer(),
             host_impl_->CurrentlyScrollingLayer());
 
   host_impl_->ScrollEnd();
 
   // Position the viewports such that the inner viewport will be scrolled.
   gfx::Vector2dF inner_viewport_offset(0.f, 25.f);
   host_impl_->OuterViewportScrollLayer()->SetScrollDelta(gfx::Vector2dF());
   host_impl_->InnerViewportScrollLayer()->SetScrollDelta(inner_viewport_offset);
 
   scroll_delta = gfx::Vector2dF(0.f, -65.f);
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
 
   EXPECT_EQ(top_controls_height_,
-            host_impl_->active_tree()->total_top_controls_content_offset());
-  EXPECT_EQ(
+            host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_FLOAT_EQ(
       inner_viewport_offset.y() + (scroll_delta.y() + top_controls_height_),
       host_impl_->InnerViewportScrollLayer()->ScrollDelta().y());
 
   host_impl_->ScrollEnd();
 }
 
 TEST_F(LayerTreeHostImplTopControlsTest,
        ScrollNonScrollableRootWithTopControls) {
   CreateHostImpl(settings_, CreateOutputSurface());
   SetupTopControlsAndScrollLayer();
@@ skipping 12 matching lines @@
 
   host_impl_->ScrollEnd();
 
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
 
   float scroll_increment_y = -25.f;
   host_impl_->top_controls_manager()->ScrollBegin();
   host_impl_->top_controls_manager()->ScrollBy(
       gfx::Vector2dF(0.f, scroll_increment_y));
-  EXPECT_EQ(-scroll_increment_y,
-            host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_FLOAT_EQ(-scroll_increment_y,
+                  host_impl_->top_controls_manager()->ContentTopOffset());
   // Now that top controls have moved, expect the clip to resize.
   EXPECT_EQ(gfx::Size(viewport_size_.width(),
                       viewport_size_.height() + scroll_increment_y),
             root_clip_ptr->bounds());
 
   host_impl_->top_controls_manager()->ScrollBy(
       gfx::Vector2dF(0.f, scroll_increment_y));
   host_impl_->top_controls_manager()->ScrollEnd();
-  EXPECT_EQ(-2 * scroll_increment_y,
-            host_impl_->top_controls_manager()->ContentTopOffset());
+  EXPECT_FLOAT_EQ(-2 * scroll_increment_y,
+                  host_impl_->top_controls_manager()->ContentTopOffset());
   // Now that top controls have moved, expect the clip to resize.
   EXPECT_EQ(clip_size_, root_clip_ptr->bounds());
 
   host_impl_->ScrollEnd();
 
   // Verify the layer is once-again non-scrollable.
   EXPECT_EQ(
       gfx::ScrollOffset(),
       host_impl_->active_tree()->InnerViewportScrollLayer()->MaxScrollOffset());
 
@@ skipping 1316 matching lines @@
 class BlendStateCheckLayer : public LayerImpl {
  public:
   static scoped_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl,
                                       int id,
                                       ResourceProvider* resource_provider) {
     return make_scoped_ptr(
         new BlendStateCheckLayer(tree_impl, id, resource_provider));
   }
 
   void AppendQuads(RenderPass* render_pass,
-                   const Occlusion& occlusion_in_content_space,
                    AppendQuadsData* append_quads_data) override {
     quads_appended_ = true;
 
     gfx::Rect opaque_rect;
     if (contents_opaque())
       opaque_rect = quad_rect_;
     else
       opaque_rect = opaque_content_rect_;
     gfx::Rect visible_quad_rect = quad_rect_;
 
@@ skipping 704 matching lines @@
   host_impl_->DidDrawAllLayers(frame);
 }
 
 class FakeLayerWithQuads : public LayerImpl {
  public:
   static scoped_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
     return make_scoped_ptr(new FakeLayerWithQuads(tree_impl, id));
   }
 
   void AppendQuads(RenderPass* render_pass,
-                   const Occlusion& occlusion_in_content_space,
                    AppendQuadsData* append_quads_data) override {
     SharedQuadState* shared_quad_state =
         render_pass->CreateAndAppendSharedQuadState();
     PopulateSharedQuadState(shared_quad_state);
 
     SkColor gray = SkColorSetRGB(100, 100, 100);
     gfx::Rect quad_rect(content_bounds());
     gfx::Rect visible_quad_rect(quad_rect);
     SolidColorDrawQuad* my_quad =
         render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ skipping 1433 matching lines @@
 
 
 TEST_F(LayerTreeHostImplTestDeferredInitialize, Success) {
   // Software draw.
   DrawFrame();
 
   EXPECT_FALSE(host_impl_->output_surface()->context_provider());
 
   // DeferredInitialize and hardware draw.
   did_update_renderer_capabilities_ = false;
-  EXPECT_TRUE(
-      output_surface_->InitializeAndSetContext3d(onscreen_context_provider_));
+  EXPECT_TRUE(output_surface_->InitializeAndSetContext3d(
+      onscreen_context_provider_, nullptr));
   EXPECT_EQ(onscreen_context_provider_.get(),
             host_impl_->output_surface()->context_provider());
   EXPECT_TRUE(did_update_renderer_capabilities_);
 
   // Defer intialized GL draw.
   DrawFrame();
 
   // Revert back to software.
   did_update_renderer_capabilities_ = false;
   output_surface_->ReleaseGL();
   EXPECT_FALSE(host_impl_->output_surface()->context_provider());
   EXPECT_TRUE(did_update_renderer_capabilities_);
 
   // Software draw again.
   DrawFrame();
 }
 
 TEST_F(LayerTreeHostImplTestDeferredInitialize, Fails) {
   // Software draw.
   DrawFrame();
 
   // Fail initialization of the onscreen context before the OutputSurface binds
   // it to the thread.
   onscreen_context_provider_->UnboundTestContext3d()->set_context_lost(true);
 
   EXPECT_FALSE(host_impl_->output_surface()->context_provider());
 
   // DeferredInitialize fails.
   did_update_renderer_capabilities_ = false;
-  EXPECT_FALSE(
-      output_surface_->InitializeAndSetContext3d(onscreen_context_provider_));
+  EXPECT_FALSE(output_surface_->InitializeAndSetContext3d(
+      onscreen_context_provider_, nullptr));
   EXPECT_FALSE(host_impl_->output_surface()->context_provider());
   EXPECT_FALSE(did_update_renderer_capabilities_);
 
   // Software draw again.
   DrawFrame();
 }
 
 // Checks that we have a non-0 default allocation if we pass a context that
 // doesn't support memory management extensions.
 TEST_F(LayerTreeHostImplTest, DefaultMemoryAllocation) {
@@ skipping 767 matching lines @@
   }
 }
 
 class LayerTreeHostImplWithTopControlsTest : public LayerTreeHostImplTest {
  public:
   void SetUp() override {
     LayerTreeSettings settings = DefaultSettings();
     settings.calculate_top_controls_position = true;
     CreateHostImpl(settings, CreateOutputSurface());
     host_impl_->active_tree()->set_top_controls_height(top_controls_height_);
-    host_impl_->active_tree()->set_top_controls_delta(top_controls_height_);
-    host_impl_->top_controls_manager()->SetTopControlsHeight(
-        top_controls_height_);
+    host_impl_->sync_tree()->set_top_controls_height(top_controls_height_);
+    host_impl_->active_tree()->SetCurrentTopControlsShownRatio(1.f);
   }
 
  protected:
   static const int top_controls_height_;
 };
 
 const int LayerTreeHostImplWithTopControlsTest::top_controls_height_ = 50;
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, NoIdleAnimations) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100))
       ->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 10));
   host_impl_->Animate(base::TimeTicks());
   EXPECT_FALSE(did_request_redraw_);
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsHeightIsCommitted) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   EXPECT_FALSE(did_request_redraw_);
   host_impl_->CreatePendingTree();
   host_impl_->sync_tree()->set_top_controls_height(100);
   host_impl_->ActivateSyncTree();
-  EXPECT_EQ(100, host_impl_->top_controls_manager()->top_controls_height());
+  EXPECT_EQ(100, host_impl_->top_controls_manager()->TopControlsHeight());
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest,
        TopControlsStayFullyVisibleOnHeightChange) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  EXPECT_EQ(0.f, host_impl_->ControlsTopOffset());
+  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ControlsTopOffset());
 
   host_impl_->CreatePendingTree();
   host_impl_->sync_tree()->set_top_controls_height(0);
   host_impl_->ActivateSyncTree();
-  EXPECT_EQ(0.f, host_impl_->ControlsTopOffset());
+  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ControlsTopOffset());
 
   host_impl_->CreatePendingTree();
   host_impl_->sync_tree()->set_top_controls_height(50);
   host_impl_->ActivateSyncTree();
-  EXPECT_EQ(0.f, host_impl_->ControlsTopOffset());
+  EXPECT_EQ(0.f, host_impl_->top_controls_manager()->ControlsTopOffset());
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsAnimationScheduling) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100))
       ->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 10));
   host_impl_->DidChangeTopControlsPosition();
   EXPECT_TRUE(did_request_animate_);
   EXPECT_TRUE(did_request_redraw_);
 }
 
@@ skipping 544 matching lines @@
                    scrolling_layer->CurrentScrollOffset());
   EXPECT_EQ(NULL, host_impl_->CurrentlyScrollingLayer());
 }
 
 TEST_F(LayerTreeHostImplTest, GetPictureLayerImplPairs) {
   host_impl_->CreatePendingTree();
 
   scoped_ptr<PictureLayerImpl> layer =
       FakePictureLayerImpl::Create(host_impl_->pending_tree(), 10);
   layer->SetBounds(gfx::Size(10, 10));
+  scoped_ptr<FakePictureLayerImpl> nondraw_layer =
+      FakePictureLayerImpl::Create(host_impl_->pending_tree(), 12);
+  nondraw_layer->SetBounds(gfx::Size(10, 10));
 
   scoped_refptr<RasterSource> pile(FakePicturePileImpl::CreateEmptyPile(
       gfx::Size(10, 10), gfx::Size(10, 10)));
   Region empty_invalidation;
   const PictureLayerTilingSet* null_tiling_set = nullptr;
   layer->UpdateRasterSource(pile, &empty_invalidation, null_tiling_set);
+  nondraw_layer->UpdateRasterSource(pile, &empty_invalidation, null_tiling_set);
 
+  layer->AddChild(nondraw_layer.Pass());
   host_impl_->pending_tree()->SetRootLayer(layer.Pass());
 
   LayerTreeImpl* pending_tree = host_impl_->pending_tree();
   LayerImpl* pending_layer = pending_tree->root_layer();
+  FakePictureLayerImpl* pending_nondraw_layer =
+      static_cast<FakePictureLayerImpl*>(pending_layer->children()[0]);
+
+  pending_nondraw_layer->SetIsDrawnRenderSurfaceLayerListMember(false);
 
   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);
 
   host_impl_->ActivateSyncTree();
 
   LayerTreeImpl* active_tree = host_impl_->active_tree();
   LayerImpl* active_layer = active_tree->root_layer();
+  FakePictureLayerImpl* active_nondraw_layer =
+      static_cast<FakePictureLayerImpl*>(active_layer->children()[0]);
   EXPECT_NE(active_tree, pending_tree);
   EXPECT_NE(active_layer, pending_layer);
+  EXPECT_NE(active_nondraw_layer, pending_nondraw_layer);
   EXPECT_NE(nullptr, active_tree);
   EXPECT_NE(nullptr, active_layer);
+  EXPECT_NE(nullptr, active_nondraw_layer);
+
+  active_nondraw_layer->SetIsDrawnRenderSurfaceLayerListMember(false);
 
   host_impl_->CreatePendingTree();
 
   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(pending_layer, layer_pairs[0].pending);
 
   // Activate, the active layer has no twin now.
   host_impl_->ActivateSyncTree();
 
   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(
       FakePictureLayerImpl::Create(host_impl_->pending_tree(), 11));
 
-  LayerImpl* new_pending_layer = pending_tree->root_layer()->children()[0];
+  LayerImpl* new_pending_layer = pending_tree->root_layer()->children()[1];
 
   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]);
-
   EXPECT_EQ(active_layer, layer_pairs[0].active);
   EXPECT_EQ(pending_layer, layer_pairs[0].pending);
   EXPECT_EQ(new_pending_layer, layer_pairs[1].pending);
   EXPECT_EQ(nullptr, layer_pairs[1].active);
+
+  host_impl_->pending_tree()->root_layer()->RemoveChild(new_pending_layer);
+
+  // Have the pending layer be part of the RSLL now. It should appear in the
+  // list without an active twin.
+  pending_nondraw_layer->SetIsDrawnRenderSurfaceLayerListMember(true);
+
+  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]);
+  EXPECT_EQ(active_layer, layer_pairs[0].active);
+  EXPECT_EQ(pending_layer, layer_pairs[0].pending);
+  EXPECT_EQ(pending_nondraw_layer, layer_pairs[1].pending);
+  EXPECT_EQ(nullptr, layer_pairs[1].active);
+
+  // Have the active layer be part of the RSLL now instead. It should appear in
+  // the list without a pending twin.
+  pending_nondraw_layer->SetIsDrawnRenderSurfaceLayerListMember(false);
+  active_nondraw_layer->SetIsDrawnRenderSurfaceLayerListMember(true);
+
+  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]);
+  EXPECT_EQ(active_layer, layer_pairs[0].active);
+  EXPECT_EQ(pending_layer, layer_pairs[0].pending);
+  EXPECT_EQ(nullptr, layer_pairs[1].pending);
+  EXPECT_EQ(active_nondraw_layer, layer_pairs[1].active);
+}
+
+TEST_F(LayerTreeHostImplTest, GetPictureLayerImplPairsWithNonRSLLMembers) {
+  host_impl_->CreatePendingTree();
+
+  scoped_ptr<PictureLayerImpl> layer =
+      FakePictureLayerImpl::Create(host_impl_->pending_tree(), 10);
+  layer->SetBounds(gfx::Size(10, 10));
+  scoped_ptr<FakePictureLayerImpl> nondraw_layer =
+      FakePictureLayerImpl::Create(host_impl_->pending_tree(), 12);
+  nondraw_layer->SetBounds(gfx::Size(10, 10));
+
+  scoped_refptr<RasterSource> pile(FakePicturePileImpl::CreateEmptyPile(
+      gfx::Size(10, 10), gfx::Size(10, 10)));
+  Region empty_invalidation;
+  const PictureLayerTilingSet* null_tiling_set = nullptr;
+  layer->UpdateRasterSource(pile, &empty_invalidation, null_tiling_set);
+  nondraw_layer->UpdateRasterSource(pile, &empty_invalidation, null_tiling_set);
+
+  layer->AddChild(nondraw_layer.Pass());
+  host_impl_->pending_tree()->SetRootLayer(layer.Pass());
+
+  LayerTreeImpl* pending_tree = host_impl_->pending_tree();
+  LayerImpl* pending_layer = pending_tree->root_layer();
+  FakePictureLayerImpl* pending_nondraw_layer =
+      static_cast<FakePictureLayerImpl*>(pending_layer->children()[0]);
+
+  pending_nondraw_layer->SetIsDrawnRenderSurfaceLayerListMember(false);
+
+  std::vector<PictureLayerImpl::Pair> layer_pairs;
+  host_impl_->GetPictureLayerImplPairs(&layer_pairs, false);
+  EXPECT_EQ(2u, layer_pairs.size());
+  // The pair ordering is flaky, so make it consistent.
+  if (layer_pairs[0].pending != pending_layer)
+    std::swap(layer_pairs[0], layer_pairs[1]);
+  EXPECT_EQ(pending_layer, layer_pairs[0].pending);
+  EXPECT_EQ(nullptr, layer_pairs[0].active);
+  EXPECT_EQ(pending_nondraw_layer, layer_pairs[1].pending);
+  EXPECT_EQ(nullptr, layer_pairs[1].active);
+
+  host_impl_->ActivateSyncTree();
+
+  LayerTreeImpl* active_tree = host_impl_->active_tree();
+  LayerImpl* active_layer = active_tree->root_layer();
+  FakePictureLayerImpl* active_nondraw_layer =
+      static_cast<FakePictureLayerImpl*>(active_layer->children()[0]);
+  EXPECT_NE(active_tree, pending_tree);
+  EXPECT_NE(active_layer, pending_layer);
+  EXPECT_NE(active_nondraw_layer, pending_nondraw_layer);
+  EXPECT_NE(nullptr, active_tree);
+  EXPECT_NE(nullptr, active_layer);
+  EXPECT_NE(nullptr, active_nondraw_layer);
+
+  active_nondraw_layer->SetIsDrawnRenderSurfaceLayerListMember(false);
+
+  host_impl_->CreatePendingTree();
+
+  layer_pairs.clear();
+  host_impl_->GetPictureLayerImplPairs(&layer_pairs, false);
+  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]);
+  EXPECT_EQ(active_layer, layer_pairs[0].active);
+  EXPECT_EQ(pending_layer, layer_pairs[0].pending);
+  EXPECT_EQ(pending_nondraw_layer, layer_pairs[1].pending);
+  EXPECT_EQ(active_nondraw_layer, layer_pairs[1].active);
+
+  // Activate, the active layer has no twin now.
+  host_impl_->ActivateSyncTree();
+
+  layer_pairs.clear();
+  host_impl_->GetPictureLayerImplPairs(&layer_pairs, false);
+  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]);
+  EXPECT_EQ(active_layer, layer_pairs[0].active);
+  EXPECT_EQ(nullptr, layer_pairs[0].pending);
+  EXPECT_EQ(active_nondraw_layer, layer_pairs[1].active);
+  EXPECT_EQ(nullptr, layer_pairs[1].pending);
+
+  // Create another layer in the pending tree that's not in the active tree. We
+  // should get three pairs including the nondraw layers.
+  host_impl_->CreatePendingTree();
+  host_impl_->pending_tree()->root_layer()->AddChild(
+      FakePictureLayerImpl::Create(host_impl_->pending_tree(), 11));
+
+  LayerImpl* new_pending_layer = pending_tree->root_layer()->children()[1];
+
+  layer_pairs.clear();
+  host_impl_->GetPictureLayerImplPairs(&layer_pairs, false);
+  EXPECT_EQ(3u, 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]);
+  if (layer_pairs[0].active != active_layer)
+    std::swap(layer_pairs[0], layer_pairs[2]);
+  if (layer_pairs[1].pending != new_pending_layer)
+    std::swap(layer_pairs[1], layer_pairs[2]);
+  EXPECT_EQ(active_layer, layer_pairs[0].active);
+  EXPECT_EQ(pending_layer, layer_pairs[0].pending);
+  EXPECT_EQ(new_pending_layer, layer_pairs[1].pending);
+  EXPECT_EQ(nullptr, layer_pairs[1].active);
+  EXPECT_EQ(active_nondraw_layer, layer_pairs[2].active);
+  EXPECT_EQ(pending_nondraw_layer, layer_pairs[2].pending);
+
+  host_impl_->pending_tree()->root_layer()->RemoveChild(new_pending_layer);
+
+  // Have the pending layer be part of the RSLL now. It should appear in the
+  // list, as should its active twin since we don't request only layers with
+  // valid draw properties.
+  pending_nondraw_layer->SetIsDrawnRenderSurfaceLayerListMember(true);
+
+  layer_pairs.clear();
+  host_impl_->GetPictureLayerImplPairs(&layer_pairs, false);
+  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]);
+  EXPECT_EQ(active_layer, layer_pairs[0].active);
+  EXPECT_EQ(pending_layer, layer_pairs[0].pending);
+  EXPECT_EQ(pending_nondraw_layer, layer_pairs[1].pending);
+  EXPECT_EQ(active_nondraw_layer, layer_pairs[1].active);
+
+  // Have the active layer be part of the RSLL now instead. It should appear in
+  // the list, as should its pending twin since we don't request only layers
+  // with valid draw properties.
+  pending_nondraw_layer->SetIsDrawnRenderSurfaceLayerListMember(false);
+  active_nondraw_layer->SetIsDrawnRenderSurfaceLayerListMember(true);
+
+  layer_pairs.clear();
+  host_impl_->GetPictureLayerImplPairs(&layer_pairs, false);
+  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]);
+  EXPECT_EQ(active_layer, layer_pairs[0].active);
+  EXPECT_EQ(pending_layer, layer_pairs[0].pending);
+  EXPECT_EQ(active_nondraw_layer, layer_pairs[1].active);
+  EXPECT_EQ(pending_nondraw_layer, layer_pairs[1].pending);
 }
 
 TEST_F(LayerTreeHostImplTest, DidBecomeActive) {
   host_impl_->CreatePendingTree();
   host_impl_->ActivateSyncTree();
   host_impl_->CreatePendingTree();
 
   LayerTreeImpl* pending_tree = host_impl_->pending_tree();
 
   scoped_ptr<FakePictureLayerImpl> pending_layer =
@@ skipping 88 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