Update from https://crrev.com/314320

cc/trees/layer_tree_host_unittest_context.cc

 // Copyright 2012 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 "base/basictypes.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
@@ skipping 386 matching lines @@
 
   void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
   void AfterTest() override {}
 
   int request_count_;
 };
 
 SINGLE_THREAD_NOIMPL_TEST_F(MultipleCompositeDoesNotCreateOutputSurface);
 
+// This test makes sure that once a SingleThreadProxy issues a
+// DidFailToInitializeOutputSurface, that future Composite calls will not
+// trigger additional requests for output surfaces.
 class FailedCreateDoesNotCreateExtraOutputSurface
     : public LayerTreeHostContextTest {
  public:
   FailedCreateDoesNotCreateExtraOutputSurface()
-      : LayerTreeHostContextTest(), request_count_(0) {}
+      : LayerTreeHostContextTest(), num_requests_(0), has_failed_(false) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
   }
 
   void RequestNewOutputSurface() override {
-    if (request_count_ == 0) {
-      ExpectCreateToFail();
-      layer_tree_host()->SetOutputSurface(
-          make_scoped_ptr(new FailureOutputSurface(false)));
-    }
+    num_requests_++;
+    // There should be one initial request and then one request from
+    // the LayerTreeTest test hooks DidFailToInitializeOutputSurface (which is
+    // hard to skip).  This second request is just ignored and is test cruft.
+    EXPECT_LE(num_requests_, 2);
+    if (num_requests_ > 1)
+      return;
+    ExpectCreateToFail();
+    layer_tree_host()->SetOutputSurface(
+        make_scoped_ptr(new FailureOutputSurface(false)));
   }
 
   void BeginTest() override {
+    // First composite tries to create a surface.
     layer_tree_host()->Composite(base::TimeTicks());
+    EXPECT_EQ(num_requests_, 2);
+    EXPECT_TRUE(has_failed_);
+
+    // Second composite should not request or fail.
     layer_tree_host()->Composite(base::TimeTicks());
+    EXPECT_EQ(num_requests_, 2);
+    EndTest();
   }
 
   void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
   void DidFailToInitializeOutputSurface() override {
     LayerTreeHostContextTest::DidFailToInitializeOutputSurface();
-    EXPECT_GE(2, ++request_count_);
-    EndTest();
+    EXPECT_FALSE(has_failed_);
+    has_failed_ = true;
   }
 
   void AfterTest() override {}
 
-  int request_count_;
+  int num_requests_;
+  bool has_failed_;
 };
 
 SINGLE_THREAD_NOIMPL_TEST_F(FailedCreateDoesNotCreateExtraOutputSurface);
 
 class LayerTreeHostContextTestCommitAfterDelayedOutputSurface
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestCommitAfterDelayedOutputSurface()
       : LayerTreeHostContextTest(), creating_output_(false) {}
 
@@ skipping 1236 matching lines @@
     deferred_ = false;
     PostSetNeedsCommitToMainThread();
   }
 
   void ScheduledActionWillSendBeginMainFrame() override {
     if (deferred_)
       return;
     deferred_ = true;
 
     // Defer commits before the BeginFrame arrives, causing it to be delayed.
-    MainThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LayerTreeHostContextTestLoseAfterSendingBeginMainFrame::
-                       DeferCommitsOnMainThread,
-                   base::Unretained(this),
-                   true));
+    PostSetDeferCommitsToMainThread(true);
     // Meanwhile, lose the context while we are in defer commits.
     ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostContextTestLoseAfterSendingBeginMainFrame::
                        LoseContextOnImplThread,
                    base::Unretained(this)));
   }
 
   void LoseContextOnImplThread() {
     LoseContext();
 
     // After losing the context, stop deferring commits.
-    MainThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LayerTreeHostContextTestLoseAfterSendingBeginMainFrame::
-                       DeferCommitsOnMainThread,
-                   base::Unretained(this),
-                   false));
-  }
-
-  void DeferCommitsOnMainThread(bool defer_commits) {
-    layer_tree_host()->SetDeferCommits(defer_commits);
+    PostSetDeferCommitsToMainThread(false);
   }
 
   void WillBeginMainFrame() override {
     // Don't begin a frame with a lost surface.
     EXPECT_FALSE(layer_tree_host()->output_surface_lost());
   }
 
   void DidCommitAndDrawFrame() override { EndTest(); }
 
   void AfterTest() override {}
 
   bool deferred_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc