cc: Save correct frame begin time to FrameRateCounter

cc/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/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 182 matching lines @@
         layer->SetContentBounds(size);
         layer->SetMaxScrollOffset(gfx::Vector2d(size.width() * 2, size.height() * 2));
         return layer.Pass();
     }
 
     void initializeRendererAndDrawFrame()
     {
         m_hostImpl->InitializeRenderer(createOutputSurface());
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
 
     void pinchZoomPanViewportForcesCommitRedraw(const float deviceScaleFactor);
     void pinchZoomPanViewportTest(const float deviceScaleFactor);
     void pinchZoomPanViewportAndScrollTest(const float deviceScaleFactor);
     void pinchZoomPanViewportAndScrollBoundaryTest(const float deviceScaleFactor);
 
 protected:
     virtual scoped_ptr<OutputSurface> createOutputSurface() { return createFakeOutputSurface(); }
@@ skipping 705 matching lines @@
     layer->SetPosition(gfx::PointF(100, 100));
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetContentBounds(gfx::Size(10, 10));
 
     LayerTreeHostImpl::FrameData frame;
 
     EXPECT_FALSE(layer->willDrawCalled());
     EXPECT_FALSE(layer->didDrawCalled());
 
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
 
     EXPECT_FALSE(layer->willDrawCalled());
     EXPECT_FALSE(layer->didDrawCalled());
 
     EXPECT_TRUE(layer->visible_content_rect().IsEmpty());
 
     // Ensure visibleContentRect for layer layer is not empty
     layer->SetPosition(gfx::PointF(0, 0));
 
     EXPECT_FALSE(layer->willDrawCalled());
     EXPECT_FALSE(layer->didDrawCalled());
 
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
 
     EXPECT_TRUE(layer->willDrawCalled());
     EXPECT_TRUE(layer->didDrawCalled());
 
     EXPECT_FALSE(layer->visible_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostImplTest, willDrawNotCalledOnOccludedLayer)
 {
@@ skipping 14 matching lines @@
     topLayer->SetContentsOpaque(true);
 
     LayerTreeHostImpl::FrameData frame;
 
     EXPECT_FALSE(occludedLayer->willDrawCalled());
     EXPECT_FALSE(occludedLayer->didDrawCalled());
     EXPECT_FALSE(topLayer->willDrawCalled());
     EXPECT_FALSE(topLayer->didDrawCalled());
 
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
 
     EXPECT_FALSE(occludedLayer->willDrawCalled());
     EXPECT_FALSE(occludedLayer->didDrawCalled());
     EXPECT_TRUE(topLayer->willDrawCalled());
     EXPECT_TRUE(topLayer->didDrawCalled());
 }
 
 TEST_F(LayerTreeHostImplTest, didDrawCalledOnAllLayers)
 {
     m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
 
     root->AddChild(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 2));
     DidDrawCheckLayer* layer1 = static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
     layer1->AddChild(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 3));
     DidDrawCheckLayer* layer2 = static_cast<DidDrawCheckLayer*>(layer1->children()[0]);
 
     layer1->SetOpacity(0.3f);
     layer1->SetPreserves3d(false);
 
     EXPECT_FALSE(root->didDrawCalled());
     EXPECT_FALSE(layer1->didDrawCalled());
     EXPECT_FALSE(layer2->didDrawCalled());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
 
     EXPECT_TRUE(root->didDrawCalled());
     EXPECT_TRUE(layer1->didDrawCalled());
     EXPECT_TRUE(layer2->didDrawCalled());
 
     EXPECT_NE(root->render_surface(), layer1->render_surface());
     EXPECT_TRUE(!!layer1->render_surface());
 }
 
@@ skipping 25 matching lines @@
 TEST_F(LayerTreeHostImplTest, prepareToDrawFailsWhenAnimationUsesCheckerboard)
 {
     // When the texture is not missing, we draw as usual.
     m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
     root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->active_tree(), 2, false, false, true, m_hostImpl->resource_provider()));
 
     LayerTreeHostImpl::FrameData frame;
 
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // When a texture is missing and we're not animating, we draw as usual with checkerboarding.
     m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 3));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
     root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->active_tree(), 4, true, false, false, m_hostImpl->resource_provider()));
 
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // When a texture is missing and we're animating, we don't want to draw anything.
     m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 5));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
     root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->active_tree(), 6, true, false, true, m_hostImpl->resource_provider()));
 
     EXPECT_FALSE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // When the layer skips draw and we're animating, we still draw the frame.
     m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 7));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
     root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->active_tree(), 8, false, true, true, m_hostImpl->resource_provider()));
 
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest, scrollRootIgnored)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
     root->SetScrollable(false);
     m_hostImpl->active_tree()->SetRootLayer(root.Pass());
     initializeRendererAndDrawFrame();
 
@@ skipping 256 matching lines @@
 
     // The page scale delta should only be applied to the scrollable root layer.
     EXPECT_EQ(root->impl_transform(), newPageScaleMatrix);
     EXPECT_EQ(child->impl_transform(), defaultPageScaleMatrix);
     EXPECT_EQ(grandChild->impl_transform(), defaultPageScaleMatrix);
 
     // Make sure all the layers are drawn with the page scale delta applied, i.e., the page scale
     // delta on the root layer is applied hierarchically.
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
 
     EXPECT_EQ(root->draw_transform().matrix().getDouble(0, 0), newPageScale);
     EXPECT_EQ(root->draw_transform().matrix().getDouble(1, 1), newPageScale);
     EXPECT_EQ(child->draw_transform().matrix().getDouble(0, 0), newPageScale);
     EXPECT_EQ(child->draw_transform().matrix().getDouble(1, 1), newPageScale);
     EXPECT_EQ(grandChild->draw_transform().matrix().getDouble(0, 0), newPageScale);
     EXPECT_EQ(grandChild->draw_transform().matrix().getDouble(1, 1), newPageScale);
 }
 
@@ skipping 442 matching lines @@
     root->AddChild(BlendStateCheckLayer::Create(m_hostImpl->active_tree(), 2, m_hostImpl->resource_provider()));
     BlendStateCheckLayer* layer1 = static_cast<BlendStateCheckLayer*>(root->children()[0]);
     layer1->SetPosition(gfx::PointF(2, 2));
 
     LayerTreeHostImpl::FrameData frame;
 
     // Opaque layer, drawn without blending.
     layer1->SetContentsOpaque(true);
     layer1->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Layer with translucent content and painting, so drawn with blending.
     layer1->SetContentsOpaque(false);
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Layer with translucent opacity, drawn with blending.
     layer1->SetContentsOpaque(true);
     layer1->SetOpacity(0.5);
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Layer with translucent opacity and painting, drawn with blending.
     layer1->SetContentsOpaque(true);
     layer1->SetOpacity(0.5);
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     layer1->AddChild(BlendStateCheckLayer::Create(m_hostImpl->active_tree(), 3, m_hostImpl->resource_provider()));
     BlendStateCheckLayer* layer2 = static_cast<BlendStateCheckLayer*>(layer1->children()[0]);
     layer2->SetPosition(gfx::PointF(4, 4));
 
     // 2 opaque layers, drawn without blending.
     layer1->SetContentsOpaque(true);
     layer1->SetOpacity(1);
     layer1->setExpectation(false, false);
     layer2->SetContentsOpaque(true);
     layer2->SetOpacity(1);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Parent layer with translucent content, drawn with blending.
     // Child layer with opaque content, drawn without blending.
     layer1->SetContentsOpaque(false);
     layer1->setExpectation(true, false);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Parent layer with translucent content but opaque painting, drawn without blending.
     // Child layer with opaque content, drawn without blending.
     layer1->SetContentsOpaque(true);
     layer1->setExpectation(false, false);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Parent layer with translucent opacity and opaque content. Since it has a
     // drawing child, it's drawn to a render surface which carries the opacity,
     // so it's itself drawn without blending.
     // Child layer with opaque content, drawn without blending (parent surface
     // carries the inherited opacity).
     layer1->SetContentsOpaque(true);
     layer1->SetOpacity(0.5);
     layer1->setExpectation(false, true);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Draw again, but with child non-opaque, to make sure
     // layer1 not culled.
     layer1->SetContentsOpaque(true);
     layer1->SetOpacity(1);
     layer1->setExpectation(false, false);
     layer2->SetContentsOpaque(true);
     layer2->SetOpacity(0.5);
     layer2->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // A second way of making the child non-opaque.
     layer1->SetContentsOpaque(true);
     layer1->SetOpacity(1);
     layer1->setExpectation(false, false);
     layer2->SetContentsOpaque(false);
     layer2->SetOpacity(1);
     layer2->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // And when the layer says its not opaque but is painted opaque, it is not blended.
     layer1->SetContentsOpaque(true);
     layer1->SetOpacity(1);
     layer1->setExpectation(false, false);
     layer2->SetContentsOpaque(true);
     layer2->SetOpacity(1);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Layer with partially opaque contents, drawn with blending.
     layer1->SetContentsOpaque(false);
     layer1->setQuadRect(gfx::Rect(5, 5, 5, 5));
     layer1->setQuadVisibleRect(gfx::Rect(5, 5, 5, 5));
     layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Layer with partially opaque contents partially culled, drawn with blending.
     layer1->SetContentsOpaque(false);
     layer1->setQuadRect(gfx::Rect(5, 5, 5, 5));
     layer1->setQuadVisibleRect(gfx::Rect(5, 5, 5, 2));
     layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Layer with partially opaque contents culled, drawn with blending.
     layer1->SetContentsOpaque(false);
     layer1->setQuadRect(gfx::Rect(5, 5, 5, 5));
     layer1->setQuadVisibleRect(gfx::Rect(7, 5, 3, 5));
     layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
     // Layer with partially opaque contents and translucent contents culled, drawn without blending.
     layer1->SetContentsOpaque(false);
     layer1->setQuadRect(gfx::Rect(5, 5, 5, 5));
     layer1->setQuadVisibleRect(gfx::Rect(5, 5, 2, 5));
     layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
     layer1->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->DidDrawAllLayers(frame);
 
 }
 
 TEST_F(LayerTreeHostImplTest, viewportCovered)
 {
     m_hostImpl->InitializeRenderer(createOutputSurface());
     m_hostImpl->active_tree()->set_background_color(SK_ColorGRAY);
 
@@ skipping 111 matching lines @@
 
     scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::Create(m_hostImpl->active_tree(), 1);
     root->SetAnchorPoint(gfx::PointF(0, 0));
     root->SetBounds(gfx::Size(10, 10));
     root->SetDrawsContent(true);
     m_hostImpl->active_tree()->SetRootLayer(root.Pass());
     EXPECT_FALSE(reshapeTracker->reshapeCalled());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     EXPECT_TRUE(reshapeTracker->reshapeCalled());
     m_hostImpl->DidDrawAllLayers(frame);
 }
 
 class PartialSwapTrackerContext : public TestWebGraphicsContext3D {
 public:
     virtual void postSubBufferCHROMIUM(int x, int y, int width, int height)
     {
         m_partialSwapRect = gfx::Rect(x, y, width, height);
     }
@@ skipping 38 matching lines @@
     root->SetBounds(gfx::Size(500, 500));
     root->SetContentBounds(gfx::Size(500, 500));
     root->SetDrawsContent(true);
     root->AddChild(child.Pass());
     layerTreeHostImpl->active_tree()->SetRootLayer(root.Pass());
 
     LayerTreeHostImpl::FrameData frame;
 
     // First frame, the entire screen should get swapped.
     EXPECT_TRUE(layerTreeHostImpl->PrepareToDraw(&frame));
-    layerTreeHostImpl->DrawLayers(&frame);
+    layerTreeHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     layerTreeHostImpl->DidDrawAllLayers(frame);
     layerTreeHostImpl->SwapBuffers();
     gfx::Rect actualSwapRect = partialSwapTracker->partialSwapRect();
     gfx::Rect expectedSwapRect = gfx::Rect(gfx::Point(), gfx::Size(500, 500));
     EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
     EXPECT_EQ(expectedSwapRect.y(), actualSwapRect.y());
     EXPECT_EQ(expectedSwapRect.width(), actualSwapRect.width());
     EXPECT_EQ(expectedSwapRect.height(), actualSwapRect.height());
 
     // Second frame, only the damaged area should get swapped. Damage should be the union
     // of old and new child rects.
     // expected damage rect: gfx::Rect(gfx::Point(), gfx::Size(26, 28));
     // expected swap rect: vertically flipped, with origin at bottom left corner.
     layerTreeHostImpl->active_tree()->root_layer()->children()[0]->SetPosition(gfx::PointF(0, 0));
     EXPECT_TRUE(layerTreeHostImpl->PrepareToDraw(&frame));
-    layerTreeHostImpl->DrawLayers(&frame);
+    layerTreeHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
     layerTreeHostImpl->SwapBuffers();
     actualSwapRect = partialSwapTracker->partialSwapRect();
     expectedSwapRect = gfx::Rect(gfx::Point(0, 500-28), gfx::Size(26, 28));
     EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
     EXPECT_EQ(expectedSwapRect.y(), actualSwapRect.y());
     EXPECT_EQ(expectedSwapRect.width(), actualSwapRect.width());
     EXPECT_EQ(expectedSwapRect.height(), actualSwapRect.height());
 
     // Make sure that partial swap is constrained to the viewport dimensions
     // expected damage rect: gfx::Rect(gfx::Point(), gfx::Size(500, 500));
     // expected swap rect: flipped damage rect, but also clamped to viewport
     layerTreeHostImpl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
     layerTreeHostImpl->active_tree()->root_layer()->SetOpacity(0.7f); // this will damage everything
     EXPECT_TRUE(layerTreeHostImpl->PrepareToDraw(&frame));
-    layerTreeHostImpl->DrawLayers(&frame);
+    layerTreeHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
     layerTreeHostImpl->SwapBuffers();
     actualSwapRect = partialSwapTracker->partialSwapRect();
     expectedSwapRect = gfx::Rect(gfx::Point(), gfx::Size(10, 10));
     EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
     EXPECT_EQ(expectedSwapRect.y(), actualSwapRect.y());
     EXPECT_EQ(expectedSwapRect.width(), actualSwapRect.width());
     EXPECT_EQ(expectedSwapRect.height(), actualSwapRect.height());
 }
 
@@ skipping 142 matching lines @@
     // Run test case
     createLayerTreeHost(false, outputSurface.Pass());
     setupRootLayerImpl(FakeLayerWithQuads::Create(m_hostImpl->active_tree(), 1));
 
     // without partial swap, and no clipping, no scissor is set.
     harness.mustDrawSolidQuad();
     harness.mustSetNoScissor();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 
     // without partial swap, but a layer does clip its subtree, one scissor is set.
     m_hostImpl->active_tree()->root_layer()->SetMasksToBounds(true);
     harness.mustDrawSolidQuad();
     harness.mustSetScissor(0, 0, 10, 10);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
 TEST_F(LayerTreeHostImplTest, partialSwap)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new MockContext)).PassAs<OutputSurface>();
     MockContext* mockContext = static_cast<MockContext*>(outputSurface->context3d());
     MockContextHarness harness(mockContext);
 
     createLayerTreeHost(true, outputSurface.Pass());
     setupRootLayerImpl(FakeLayerWithQuads::Create(m_hostImpl->active_tree(), 1));
 
     // The first frame is not a partially-swapped one.
     harness.mustSetScissor(0, 0, 10, 10);
     harness.mustDrawSolidQuad();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 
     // Damage a portion of the frame.
     m_hostImpl->active_tree()->root_layer()->set_update_rect(gfx::Rect(0, 0, 2, 3));
 
     // The second frame will be partially-swapped (the y coordinates are flipped).
     harness.mustSetScissor(0, 7, 2, 3);
     harness.mustDrawSolidQuad();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
 class PartialSwapContext : public TestWebGraphicsContext3D {
 public:
     virtual WebKit::WebString getString(WebKit::WGC3Denum name)
     {
         if (name == GL_EXTENSIONS)
@@ skipping 90 matching lines @@
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Verify all quads have been computed
         ASSERT_EQ(2U, frame.render_passes.size());
         ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.render_passes[0]->quad_list[0]->material);
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, contributingLayerEmptyScissorNoPartialSwap)
 {
     scoped_ptr<LayerTreeHostImpl> myHostImpl = setupLayersForOpacity(false, this, &m_proxy);
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Verify all quads have been computed
         ASSERT_EQ(2U, frame.render_passes.size());
         ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.render_passes[0]->quad_list[0]->material);
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 // Fake WebKit::WebGraphicsContext3D that tracks the number of textures in use.
 class TrackingWebGraphicsContext3D : public TestWebGraphicsContext3D {
 public:
     TrackingWebGraphicsContext3D()
         : TestWebGraphicsContext3D()
         , m_numTextures(0)
@@ skipping 77 matching lines @@
     ioSurfaceLayer->SetDrawsContent(true);
     ioSurfaceLayer->setIOSurfaceProperties(1, gfx::Size(10, 10));
     rootLayer->AddChild(ioSurfaceLayer.PassAs<LayerImpl>());
 
     m_hostImpl->active_tree()->SetRootLayer(rootLayer.Pass());
 
     EXPECT_EQ(0u, context3d->NumTextures());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
     m_hostImpl->SwapBuffers();
 
     EXPECT_GT(context3d->NumTextures(), 0u);
 
     // Kill the layer tree.
     m_hostImpl->active_tree()->SetRootLayer(LayerImpl::Create(m_hostImpl->active_tree(), 100));
     // There should be no textures left in use after.
     EXPECT_EQ(0u, context3d->NumTextures());
 }
@@ skipping 15 matching lines @@
     m_hostImpl->active_tree()->set_background_color(SK_ColorWHITE);
 
     // Verify one quad is drawn when transparent background set is not set.
     m_hostImpl->active_tree()->set_has_transparent_background(false);
     EXPECT_CALL(*mockContext, useProgram(_))
         .Times(1);
     EXPECT_CALL(*mockContext, drawElements(_, _, _, _))
         .Times(1);
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
     Mock::VerifyAndClearExpectations(&mockContext);
 
     // Verify no quads are drawn when transparent background is set.
     m_hostImpl->active_tree()->set_has_transparent_background(true);
     EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
-    m_hostImpl->DrawLayers(&frame);
+    m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
     m_hostImpl->DidDrawAllLayers(frame);
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
 static void addDrawingLayerTo(LayerImpl* parent, int id, const gfx::Rect& layerRect, LayerImpl** result)
 {
     scoped_ptr<LayerImpl> layer = FakeLayerWithQuads::Create(parent->layer_tree_impl(), id);
     LayerImpl* layerPtr = layer.get();
     layerPtr->SetAnchorPoint(gfx::PointF(0, 0));
     layerPtr->SetPosition(gfx::PointF(layerRect.origin()));
@@ skipping 102 matching lines @@
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive 3 render passes.
         // For Root, there are 2 quads; for S1, there are 2 quads (1 is occluded); for S2, there is 2 quads.
         ASSERT_EQ(3U, frame.render_passes.size());
 
         EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
         EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // "Unocclude" surface S1 and repeat draw.
     // Must remove S2's render pass since it's cached;
     // Must keep S1 quads because texture contained external occlusion.
     gfx::Transform transform = layerS2Ptr->transform();
     transform.Translate(150, 150);
     layerS2Ptr->SetTransform(transform);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive 2 render passes.
         // For Root, there are 2 quads
         // For S1, the number of quads depends on what got unoccluded, so not asserted beyond being positive.
         // For S2, there is no render pass
         ASSERT_EQ(2U, frame.render_passes.size());
 
         EXPECT_GT(frame.render_passes[0]->quad_list.size(), 0U);
         EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // "Re-occlude" surface S1 and repeat draw.
     // Must remove S1's render pass since it is now available in full.
     // S2 has no change so must also be removed.
     transform = layerS2Ptr->transform();
     transform.Translate(-15, -15);
     layerS2Ptr->SetTransform(transform);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive 1 render pass - for the root.
         ASSERT_EQ(1U, frame.render_passes.size());
 
         EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
 }
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.cacheRenderPassContents = true;
@@ skipping 53 matching lines @@
         // Must receive 3 render passes.
         // For Root, there are 2 quads; for S1, there are 3 quads; for S2, there is 1 quad.
         ASSERT_EQ(3U, frame.render_passes.size());
 
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
         // L14 is culled, so only 3 quads.
         EXPECT_EQ(3U, frame.render_passes[1]->quad_list.size());
         EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // "Unocclude" surface S1 and repeat draw.
     // Must remove S2's render pass since it's cached;
     // Must keep S1 quads because texture contained external occlusion.
     gfx::Transform transform = layerS2Ptr->transform();
     transform.Translate(100, 100);
     layerS2Ptr->SetTransform(transform);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive 2 render passes.
         // For Root, there are 2 quads
         // For S1, the number of quads depends on what got unoccluded, so not asserted beyond being positive.
         // For S2, there is no render pass
         ASSERT_EQ(2U, frame.render_passes.size());
 
         EXPECT_GT(frame.render_passes[0]->quad_list.size(), 0U);
         EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // "Re-occlude" surface S1 and repeat draw.
     // Must remove S1's render pass since it is now available in full.
     // S2 has no change so must also be removed.
     transform = layerS2Ptr->transform();
     transform.Translate(-15, -15);
     layerS2Ptr->SetTransform(transform);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive 1 render pass - for the root.
         ASSERT_EQ(1U, frame.render_passes.size());
 
         EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithOcclusionExternalOverInternal)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.cacheRenderPassContents = true;
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
@@ skipping 44 matching lines @@
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive 3 render passes.
         // For Root, there are 2 quads; for S1, there are 3 quads; for S2, there is 1 quad.
         ASSERT_EQ(3U, frame.render_passes.size());
 
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(3U, frame.render_passes[1]->quad_list.size());
         EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // "Unocclude" surface S1 and repeat draw.
     // Must remove S2's render pass since it's cached;
     // Must keep S1 quads because texture contained external occlusion.
     gfx::Transform transform = layerS2Ptr->transform();
     transform.Translate(300, 0);
     layerS2Ptr->SetTransform(transform);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive 2 render passes.
         // For Root, there are 2 quads
         // For S1, the number of quads depends on what got unoccluded, so not asserted beyond being positive.
         // For S2, there is no render pass
         ASSERT_EQ(2U, frame.render_passes.size());
 
         EXPECT_GT(frame.render_passes[0]->quad_list.size(), 0U);
         EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithOcclusionExternalNotAligned)
 {
     LayerTreeSettings settings;
     settings.cacheRenderPassContents = true;
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
 
@@ skipping 37 matching lines @@
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive 2 render passes.
         ASSERT_EQ(2U, frame.render_passes.size());
 
         EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Change opacity and draw. Verify we used cached texture.
     layerS1Ptr->SetOpacity(0.2f);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // One render pass must be gone due to cached texture.
         ASSERT_EQ(1U, frame.render_passes.size());
 
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithOcclusionPartialSwap)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.partialSwapEnabled = true;
     settings.cacheRenderPassContents = true;
@@ skipping 52 matching lines @@
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive 3 render passes.
         // For Root, there are 2 quads; for S1, there are 2 quads (one is occluded); for S2, there is 2 quads.
         ASSERT_EQ(3U, frame.render_passes.size());
 
         EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
         EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // "Unocclude" surface S1 and repeat draw.
     // Must remove S2's render pass since it's cached;
     // Must keep S1 quads because texture contained external occlusion.
     gfx::Transform transform = layerS2Ptr->transform();
     transform.Translate(150, 150);
     layerS2Ptr->SetTransform(transform);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive 2 render passes.
         // For Root, there are 2 quads.
         // For S1, there are 2 quads.
         // For S2, there is no render pass
         ASSERT_EQ(2U, frame.render_passes.size());
 
         EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // "Re-occlude" surface S1 and repeat draw.
     // Must remove S1's render pass since it is now available in full.
     // S2 has no change so must also be removed.
     transform = layerS2Ptr->transform();
     transform.Translate(-15, -15);
     layerS2Ptr->SetTransform(transform);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Root render pass only.
         ASSERT_EQ(1U, frame.render_passes.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithScissor)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.cacheRenderPassContents = true;
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
@@ skipping 59 matching lines @@
     child->AddChild(grandChild.Pass());
     root->AddChild(child.PassAs<LayerImpl>());
     myHostImpl->active_tree()->SetRootLayer(root.Pass());
     myHostImpl->SetViewportSize(rootRect.size(), rootRect.size());
 
     EXPECT_FALSE(myHostImpl->renderer()->HaveCachedResourcesForRenderPassId(childPassId));
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // We should have cached textures for surface 2.
     EXPECT_TRUE(myHostImpl->renderer()->HaveCachedResourcesForRenderPassId(childPassId));
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // We should still have cached textures for surface 2 after drawing with no damage.
     EXPECT_TRUE(myHostImpl->renderer()->HaveCachedResourcesForRenderPassId(childPassId));
 
     // Damage a single tile of surface 2.
     childPtr->set_update_rect(gfx::Rect(10, 10, 10, 10));
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // We should have a cached texture for surface 2 again even though it was damaged.
     EXPECT_TRUE(myHostImpl->renderer()->HaveCachedResourcesForRenderPassId(childPassId));
 }
 
 TEST_F(LayerTreeHostImplTest, surfaceTextureCaching)
 {
     LayerTreeSettings settings;
@@ skipping 17 matching lines @@
         ASSERT_EQ(2U, frame.render_passes.size());
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
         RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
         ASSERT_TRUE(targetPass);
         EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Draw without any change
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive one render pass, as the other one should be culled
         ASSERT_EQ(1U, frame.render_passes.size());
 
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Change opacity and draw
     surfaceLayerPtr->SetOpacity(0.6f);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive one render pass, as the other one should be culled
         ASSERT_EQ(1U, frame.render_passes.size());
 
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Change less benign property and draw - should have contents changed flag
     surfaceLayerPtr->SetStackingOrderChanged(true);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive two render passes, each with one quad
         ASSERT_EQ(2U, frame.render_passes.size());
 
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.render_passes[0]->quad_list[0]->material);
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
         RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
         ASSERT_TRUE(targetPass);
         EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Change opacity again, and evict the cached surface texture.
     surfaceLayerPtr->SetOpacity(0.5f);
     static_cast<GLRendererWithReleaseTextures*>(myHostImpl->renderer())->ReleaseRenderPassTextures();
 
     // Change opacity and draw
     surfaceLayerPtr->SetOpacity(0.6f);
     {
@@ skipping 10 matching lines @@
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
         RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
         ASSERT_TRUE(targetPass);
         EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
 
         // Was our surface evicted?
         EXPECT_FALSE(myHostImpl->renderer()->HaveCachedResourcesForRenderPassId(targetPass->id));
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Draw without any change, to make sure the state is clear
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive one render pass, as the other one should be culled
         ASSERT_EQ(1U, frame.render_passes.size());
 
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Change location of the intermediate layer
     gfx::Transform transform = intermediateLayerPtr->transform();
     transform.matrix().setDouble(0, 3, 1.0001);
     intermediateLayerPtr->SetTransform(transform);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive one render pass, as the other one should be culled.
         ASSERT_EQ(1U, frame.render_passes.size());
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.cacheRenderPassContents = true;
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
@@ skipping 18 matching lines @@
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
         RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
         EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
 
         EXPECT_FALSE(frame.render_passes[0]->damage_rect.IsEmpty());
         EXPECT_FALSE(frame.render_passes[1]->damage_rect.IsEmpty());
 
         EXPECT_FALSE(frame.render_passes[0]->has_occlusion_from_outside_target_surface);
         EXPECT_FALSE(frame.render_passes[1]->has_occlusion_from_outside_target_surface);
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Draw without any change
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Even though there was no change, we set the damage to entire viewport.
         // One of the passes should be culled as a result, since contents didn't change
         // and we have cached texture.
         ASSERT_EQ(1U, frame.render_passes.size());
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
         EXPECT_TRUE(frame.render_passes[0]->damage_rect.IsEmpty());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Change opacity and draw
     surfaceLayerPtr->SetOpacity(0.6f);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive one render pass, as the other one should be culled
         ASSERT_EQ(1U, frame.render_passes.size());
 
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Change less benign property and draw - should have contents changed flag
     surfaceLayerPtr->SetStackingOrderChanged(true);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive two render passes, each with one quad
         ASSERT_EQ(2U, frame.render_passes.size());
 
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.render_passes[0]->quad_list[0]->material);
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
         RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
         ASSERT_TRUE(targetPass);
         EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Change opacity again, and evict the cached surface texture.
     surfaceLayerPtr->SetOpacity(0.5f);
     static_cast<GLRendererWithReleaseTextures*>(myHostImpl->renderer())->ReleaseRenderPassTextures();
 
     // Change opacity and draw
     surfaceLayerPtr->SetOpacity(0.6f);
     {
@@ skipping 10 matching lines @@
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
         RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
         ASSERT_TRUE(targetPass);
         EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
 
         // Was our surface evicted?
         EXPECT_FALSE(myHostImpl->renderer()->HaveCachedResourcesForRenderPassId(targetPass->id));
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Draw without any change, to make sure the state is clear
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Even though there was no change, we set the damage to entire viewport.
         // One of the passes should be culled as a result, since contents didn't change
         // and we have cached texture.
         ASSERT_EQ(1U, frame.render_passes.size());
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 
     // Change location of the intermediate layer
     gfx::Transform transform = intermediateLayerPtr->transform();
     transform.matrix().setDouble(0, 3, 1.0001);
     intermediateLayerPtr->SetTransform(transform);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Must receive one render pass, as the other one should be culled.
         ASSERT_EQ(1U, frame.render_passes.size());
         EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
 
-        myHostImpl->DrawLayers(&frame);
+        myHostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, releaseContentsTextureShouldTriggerCommit)
 {
     setReduceMemoryResult(false);
 
     // Even if changing the memory limit didn't result in anything being
     // evicted, we need to re-commit because the new value may result in us
@@ skipping 373 matching lines @@
 
         // Verify the damage rect for the root render pass.
         const RenderPass* rootRenderPass = frame.render_passes.back();
         EXPECT_RECT_EQ(expectedDamage, rootRenderPass->damage_rect);
 
         // Verify the root layer's quad is generated and not being culled.
         ASSERT_EQ(1u, rootRenderPass->quad_list.size());
         gfx::Rect expectedVisibleRect(m_hostImpl->active_tree()->root_layer()->content_bounds());
         EXPECT_RECT_EQ(expectedVisibleRect, rootRenderPass->quad_list[0]->visible_rect);
 
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
 };
 
 TEST_F(LayerTreeHostImplTestWithDelegatingRenderer, FrameIncludesDamageRect)
 {
     scoped_ptr<SolidColorLayerImpl> root = SolidColorLayerImpl::Create(m_hostImpl->active_tree(), 1);
     root->SetAnchorPoint(gfx::PointF(0.f, 0.f));
     root->SetPosition(gfx::PointF(0.f, 0.f));
     root->SetBounds(gfx::Size(10, 10));
@@ skipping 84 matching lines @@
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
 
         ASSERT_EQ(1u, frame.render_passes.size());
         ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), renderPassQuad->rect.ToString());
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
 
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
 
 
     // Applying a DSF should change the render surface size, but won't affect
     // which part of the mask is used.
     deviceScaleFactor = 2.f;
     gfx::Size deviceViewport(gfx::ToFlooredSize(gfx::ScaleSize(rootSize, deviceScaleFactor)));
     m_hostImpl->SetViewportSize(rootSize, deviceViewport);
     m_hostImpl->SetDeviceScaleFactor(deviceScaleFactor);
     m_hostImpl->active_tree()->set_needs_update_draw_properties();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
 
         ASSERT_EQ(1u, frame.render_passes.size());
         ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(), renderPassQuad->rect.ToString());
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
 
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
 
 
     // Applying an equivalent content scale on the content layer and the mask
     // should still result in the same part of the mask being used.
     gfx::Size contentsBounds(gfx::ToRoundedSize(gfx::ScaleSize(scalingLayerSize, deviceScaleFactor)));
     contentLayer->SetContentBounds(contentsBounds);
     contentLayer->SetContentsScale(deviceScaleFactor, deviceScaleFactor);
     maskLayer->SetContentBounds(contentsBounds);
     maskLayer->SetContentsScale(deviceScaleFactor, deviceScaleFactor);
     m_hostImpl->active_tree()->set_needs_update_draw_properties();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
 
         ASSERT_EQ(1u, frame.render_passes.size());
         ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(), renderPassQuad->rect.ToString());
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
 
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, maskLayerWithDifferentBounds)
 {
     // The mask layer has bounds 100x100 but is attached to a layer with bounds 50x50.
 
     scoped_ptr<LayerImpl> scopedRoot = LayerImpl::Create(m_hostImpl->active_tree(), 1);
     LayerImpl* root = scopedRoot.get();
@@ skipping 36 matching lines @@
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
 
         ASSERT_EQ(1u, frame.render_passes.size());
         ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(), renderPassQuad->rect.ToString());
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
 
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
 
 
     // Applying a DSF should change the render surface size, but won't affect
     // which part of the mask is used.
     deviceScaleFactor = 2.f;
     gfx::Size deviceViewport(gfx::ToFlooredSize(gfx::ScaleSize(rootSize, deviceScaleFactor)));
     m_hostImpl->SetViewportSize(rootSize, deviceViewport);
     m_hostImpl->SetDeviceScaleFactor(deviceScaleFactor);
     m_hostImpl->active_tree()->set_needs_update_draw_properties();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
 
         ASSERT_EQ(1u, frame.render_passes.size());
         ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), renderPassQuad->rect.ToString());
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
 
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
 
 
     // Applying an equivalent content scale on the content layer and the mask
     // should still result in the same part of the mask being used.
     gfx::Size layerSizeLarge(gfx::ToRoundedSize(gfx::ScaleSize(layerSize, deviceScaleFactor)));
     contentLayer->SetContentBounds(layerSizeLarge);
     contentLayer->SetContentsScale(deviceScaleFactor, deviceScaleFactor);
     gfx::Size maskSizeLarge(gfx::ToRoundedSize(gfx::ScaleSize(maskSize, deviceScaleFactor)));
     maskLayer->SetContentBounds(maskSizeLarge);
     maskLayer->SetContentsScale(deviceScaleFactor, deviceScaleFactor);
     m_hostImpl->active_tree()->set_needs_update_draw_properties();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
 
         ASSERT_EQ(1u, frame.render_passes.size());
         ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), renderPassQuad->rect.ToString());
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
 
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
 
     // Applying a different contents scale to the mask layer will still result
     // in the mask covering the owning layer.
     maskLayer->SetContentBounds(maskSize);
     maskLayer->SetContentsScale(deviceScaleFactor, deviceScaleFactor);
     m_hostImpl->active_tree()->set_needs_update_draw_properties();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
 
         ASSERT_EQ(1u, frame.render_passes.size());
         ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
         const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
         EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), renderPassQuad->rect.ToString());
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
 
-        m_hostImpl->DrawLayers(&frame);
+        m_hostImpl->DrawLayers(&frame, base::TimeTicks::Now());
         m_hostImpl->DidDrawAllLayers(frame);
     }
 }
 
 }  // namespace
 }  // namespace cc