Update from https://crrev.com/306655

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 1094 matching lines @@
   void SetTestLayer(Layer* test_layer) { test_layer_ = test_layer; }
 
   void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& clip,
       ContentLayerClient::GraphicsContextStatus gc_status) override {
     // Set layer opacity to 0.
     if (test_layer_)
       test_layer_->SetOpacity(0.f);
   }
+  scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+      const gfx::Rect& clip,
+      GraphicsContextStatus gc_status) override {
+    NOTIMPLEMENTED();
+    return DisplayItemList::Create();
+  }
   bool FillsBoundsCompletely() const override { return false; }
 
  private:
   Layer* test_layer_;
 };
 
 class ContentLayerWithUpdateTracking : public ContentLayer {
  public:
   static scoped_refptr<ContentLayerWithUpdateTracking> Create(
       ContentLayerClient* client) {
@@ skipping 1189 matching lines @@
     int paint_count() const { return paint_count_; }
 
     void PaintContents(
         SkCanvas* canvas,
         const gfx::Rect& clip,
         ContentLayerClient::GraphicsContextStatus gc_status) override {
       FakeContentLayerClient::PaintContents(canvas, clip, gc_status);
       ++paint_count_;
     }
 
+    scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+        const gfx::Rect& clip,
+        GraphicsContextStatus gc_status) override {
+      NOTIMPLEMENTED();
+      return DisplayItemList::Create();
+    }
+
     bool FillsBoundsCompletely() const override { return false; }
 
    private:
     int paint_count_;
   };
 
   void SetupTree() override {
     num_tiles_rastered_ = 0;
 
     scoped_refptr<Layer> root_layer;
@@ skipping 250 matching lines @@
 
     void set_layer(Layer* layer) { layer_ = layer; }
 
     void PaintContents(
         SkCanvas* canvas,
         const gfx::Rect& clip,
         ContentLayerClient::GraphicsContextStatus gc_status) override {
       layer_->SetBounds(gfx::Size(2, 2));
     }
 
+    scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+        const gfx::Rect& clip,
+        GraphicsContextStatus gc_status) override {
+      NOTIMPLEMENTED();
+      return DisplayItemList::Create();
+    }
+
     bool FillsBoundsCompletely() const override { return false; }
 
    private:
     Layer* layer_;
   };
 
   LayerTreeHostTestChangeLayerPropertiesInPaintContents() : num_commits_(0) {}
 
   void SetupTree() override {
     if (layer_tree_host()->settings().impl_side_painting) {
@@ skipping 3042 matching lines @@
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->use_one_copy = true;
   }
 
   scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(
       bool fallback) override {
     scoped_ptr<TestWebGraphicsContext3D> context3d =
         TestWebGraphicsContext3D::Create();
     context3d->set_support_image(true);
     context3d->set_support_sync_query(true);
+#if defined(OS_MACOSX)
+    context3d->set_support_texture_rectangle(true);
+#endif
 
     if (delegating_renderer())
       return FakeOutputSurface::CreateDelegating3d(context3d.Pass());
     else
       return FakeOutputSurface::Create3d(context3d.Pass());
   }
 };
 
 MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestCrispUpAfterPinchEndsWithOneCopy);
 
@@ skipping 167 matching lines @@
   void AfterTest() override { EXPECT_GT(continuous_draws_, 5); }
 
   FakeContentLayerClient client_;
   int step_;
   int continuous_draws_;
   base::WaitableEvent playback_allowed_event_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousDrawWhenCreatingVisibleTiles);
 
+class LayerTreeHostTestOneActivatePerManageTiles : public LayerTreeHostTest {
+ public:
+  LayerTreeHostTestOneActivatePerManageTiles()
+      : notify_ready_to_activate_count_(0u), scheduled_manage_tiles_count_(0) {}
+
+  void SetupTree() override {
+    client_.set_fill_with_nonsolid_color(true);
+    scoped_refptr<FakePictureLayer> root_layer =
+        FakePictureLayer::Create(&client_);
+    root_layer->SetBounds(gfx::Size(1500, 1500));
+    root_layer->SetIsDrawable(true);
+
+    layer_tree_host()->SetRootLayer(root_layer);
+    LayerTreeHostTest::SetupTree();
+  }
+
+  void BeginTest() override {
+    layer_tree_host()->SetViewportSize(gfx::Size(16, 16));
+    PostSetNeedsCommitToMainThread();
+  }
+
+  void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
+                                   bool success) override {
+    ASSERT_TRUE(success);
+    host_impl->tile_manager()->SetScheduledRasterTaskLimitForTesting(1);
+  }
+
+  void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
+    ++notify_ready_to_activate_count_;
+    EndTestAfterDelayMs(100);
+  }
+
+  void ScheduledActionManageTiles() override {
+    ++scheduled_manage_tiles_count_;
+  }
+
+  void AfterTest() override {
+    // Expect at most a notification for each scheduled manage tiles, plus one
+    // for the initial commit (which doesn't go through scheduled actions).
+    // The reason this is not an equality is because depending on timing, we
+    // might get a manage tiles but not yet get a notification that we're
+    // ready to activate. The intent of a test is to ensure that we don't
+    // get more than one notification per manage tiles, so this is OK.
+    EXPECT_LE(notify_ready_to_activate_count_,
+              1u + scheduled_manage_tiles_count_);
+  }
+
+ protected:
+  FakeContentLayerClient client_;
+  size_t notify_ready_to_activate_count_;
+  size_t scheduled_manage_tiles_count_;
+};
+
+MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestOneActivatePerManageTiles);
+
 }  // namespace cc