Queue latency info swap promises in a separate already-active queue.

cc/layers/surface_layer_unittest.cc

 // Copyright 2014 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 <set>
 #include <vector>
 
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 125 matching lines @@
     layer_tree_host()->SetRootLayer(layer_);
 
     // Should have SurfaceSequence from first tree.
     SurfaceSequence expected(1u, 1u);
     EXPECT_TRUE(required_id_ == SurfaceId(1));
     EXPECT_EQ(1u, required_set_.size());
     EXPECT_TRUE(required_set_.count(expected));
 
     gfx::Size bounds(100, 100);
     layer_tree_host()->SetViewportSize(bounds);
+
+    blank_layer_ = SolidColorLayer::Create(layer_settings());
+    blank_layer_->SetIsDrawable(true);
+    blank_layer_->SetBounds(gfx::Size(10, 10));
+
     PostSetNeedsCommitToMainThread();
   }
 
+  virtual void ChangeTree() = 0;
+
   void DidCommitAndDrawFrame() override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&SurfaceLayerSwapPromise::ChangeTree,
                               base::Unretained(this)));
   }
 
-  void ChangeTree() {
+ protected:
+  int commit_count_;
+  bool sequence_was_satisfied_;
+  scoped_refptr<SurfaceLayer> layer_;
+  scoped_refptr<Layer> blank_layer_;
+  SurfaceSequence satisfied_sequence_;
+
+  SurfaceId required_id_;
+  std::set<SurfaceSequence> required_set_;
+};
+
+// Check that SurfaceSequence is sent through swap promise.
+class SurfaceLayerSwapPromiseWithDraw : public SurfaceLayerSwapPromise {
+ public:
+  SurfaceLayerSwapPromiseWithDraw() : SurfaceLayerSwapPromise() {}
+
+  void ChangeTree() override {
     ++commit_count_;
     switch (commit_count_) {
       case 1:
         // Remove SurfaceLayer from tree to cause SwapPromise to be created.
-        blank_layer_ = SolidColorLayer::Create(layer_settings());
-        blank_layer_->SetIsDrawable(true);
-        blank_layer_->SetBounds(gfx::Size(10, 10));
         layer_tree_host()->SetRootLayer(blank_layer_);
         break;
       case 2:
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
@@ skipping 13 matching lines @@
     }
   }
 
   void AfterTest() override {
     EXPECT_TRUE(required_id_ == SurfaceId(1));
     EXPECT_EQ(1u, required_set_.size());
     // Sequence should have been satisfied through Swap, not with the
     // callback.
     EXPECT_TRUE(satisfied_sequence_.is_null());
   }
-
- private:
-  int commit_count_;
-  bool sequence_was_satisfied_;
-  scoped_refptr<SurfaceLayer> layer_;
-  scoped_refptr<Layer> blank_layer_;
-  SurfaceSequence satisfied_sequence_;
-
-  SurfaceId required_id_;
-  std::set<SurfaceSequence> required_set_;
 };
 
 // TODO(jbauman): Reenable on single thread once http://crbug.com/421923 is
 // fixed.
-MULTI_THREAD_TEST_F(SurfaceLayerSwapPromise);
+MULTI_THREAD_TEST_F(SurfaceLayerSwapPromiseWithDraw);
+
+// Check that SurfaceSequence is sent through swap promise and resolved when
+// swap fails.
+class SurfaceLayerSwapPromiseWithoutDraw : public SurfaceLayerSwapPromise {
+ public:
+  SurfaceLayerSwapPromiseWithoutDraw() : SurfaceLayerSwapPromise() {}
+
+  DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+                                   LayerTreeHostImpl::FrameData* frame,
+                                   DrawResult draw_result) override {
+    return DRAW_ABORTED_MISSING_HIGH_RES_CONTENT;
+  }
+
+  void ChangeTree() override {
+    ++commit_count_;
+    switch (commit_count_) {
+      case 1:
+        // Remove SurfaceLayer from tree to cause SwapPromise to be created.
+        layer_tree_host()->SetRootLayer(blank_layer_);
+        break;
+      case 2:
+        layer_tree_host()->SetNeedsCommit();
+        break;
+      default:
+        EndTest();
+        break;
+    }
+  }
+
+  void AfterTest() override {
+    EXPECT_TRUE(required_id_ == SurfaceId(1));
+    EXPECT_EQ(1u, required_set_.size());
+    // Sequence should have been satisfied with the callback.
+    EXPECT_TRUE(satisfied_sequence_ == SurfaceSequence(1u, 1u));
+  }
+};
+
+MULTI_THREAD_TEST_F(SurfaceLayerSwapPromiseWithoutDraw);
 
 }  // namespace
 }  // namespace cc