cc: Only allow trees created at the current viewport size to draw.

cc/layer_tree_host_impl.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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 216 matching lines @@
     // in the proper places and update the notifyIfCanDrawChanged test.
 
     if (!rootLayer()) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw no root layer");
         return false;
     }
     if (deviceViewportSize().IsEmpty()) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw empty viewport");
         return false;
     }
+    if (deviceViewportSize() != activeTree()->device_viewport_size()) {
+        TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw viewport resize incomplete");
+        return false;
+    }
     if (!m_renderer) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw no renderer");
         return false;
     }
     if (m_activeTree->ContentsTexturesPurged()) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw contents textures purged");
         return false;
     }
     return true;
 }
@@ skipping 32 matching lines @@
 {
     if (!rootScrollLayer())
         return;
 
     gfx::Vector2dF scrollTotal = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
     gfx::SizeF scaledScrollableSize = activeTree()->ScrollableSize();
     if (!m_settings.pageScalePinchZoomEnabled) {
         scrollTotal.Scale(1 / activeTree()->page_scale_factor());
         scaledScrollableSize.Scale(1 / activeTree()->page_scale_factor());
     }
-    gfx::SizeF viewportSize = gfx::ScaleSize(m_deviceViewportSize, 1 / m_deviceScaleFactor);
+    gfx::SizeF viewportSize = gfx::ScaleSize(deviceViewportSize(), 1 / m_deviceScaleFactor);

[danakj, 2013/02/13 06:51:36]

Is this right? The rootScrollLayer() it's using here is from the active tree. Do
you want the active tree's deviceViewportSize here?

[aelias_OOO_until_Jul13, 2013/02/13 07:37:08]

I definitely want pendingTree size here.  pageScaleAnimations can occur when the
keyboard is brought up (to zoom in tiny text boxes) and we want to zoom in using
the post-keyboard viewport to make sure the textbox is not covered.  I checked
it causes a bug on google.com results page bottom search box if we use
activeTree here.

Probably everything else here should use pendingTree as well although it would
rarely come up... I'd rather not touch it in this patch but I'll file a bug.

 
     double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();
     m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, activeTree()->total_page_scale_factor(), viewportSize, scaledScrollableSize, startTimeSeconds);
 
     if (anchorPoint) {
         gfx::Vector2dF anchor(targetOffset);
         if (!m_settings.pageScalePinchZoomEnabled)
             anchor.Scale(1 / pageScale);
         m_pageScaleAnimation->zoomWithAnchor(anchor, pageScale, duration.InSecondsF());
     } else {
@@ skipping 561 matching lines @@
     return m_renderer->capabilities();
 }
 
 bool LayerTreeHostImpl::swapBuffers()
 {
     return m_renderer->swapBuffers();
 }
 
 const gfx::Size& LayerTreeHostImpl::deviceViewportSize() const
 {
-    return m_deviceViewportSize;
+    if (pendingTree())
+        return pendingTree()->device_viewport_size();
+    return activeTree()->device_viewport_size();
+}
+
+const gfx::Size& LayerTreeHostImpl::layoutViewportSize() const
+{
+    if (pendingTree())
+        return pendingTree()->layout_viewport_size();
+    return activeTree()->layout_viewport_size();
 }
 
 const LayerTreeSettings& LayerTreeHostImpl::settings() const
 {
     return m_settings;
 }
 
 void LayerTreeHostImpl::didLoseOutputSurface()
 {
     m_client->didLoseOutputSurfaceOnImplThread();
@@ skipping 202 matching lines @@
     // to be initialized to get max texture size.
     activeTree()->set_needs_update_draw_properties();
     if (pendingTree())
         pendingTree()->set_needs_update_draw_properties();
 
     return true;
 }
 
 void LayerTreeHostImpl::setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize)
 {
-    if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
-        return;
-
-    m_layoutViewportSize = layoutViewportSize;
-    m_deviceViewportSize = deviceViewportSize;
-
-    updateMaxScrollOffset();
-
-    if (m_renderer)
-        m_renderer->viewportChanged();
-
-    m_client->onCanDrawStateChanged(canDraw());
+    if (m_settings.implSidePainting)
+        pendingTree()->SetViewportSize(layoutViewportSize, deviceViewportSize);
+    else
+        activeTree()->SetViewportSize(layoutViewportSize, deviceViewportSize);
 }
 
 static void adjustScrollsForPageScaleChange(LayerImpl* layerImpl, float pageScaleChange)
 {
     if (!layerImpl)
         return;
 
     if (layerImpl->scrollable()) {
         // We need to convert impl-side scroll deltas to pageScale space.
         gfx::Vector2dF scrollDelta = layerImpl->scrollDelta();
@@ skipping 305 matching lines @@
     gfx::Vector2dF scrollBegin = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
     scrollBegin.Scale(activeTree()->page_scale_delta());
     float scaleBegin = activeTree()->total_page_scale_factor();
     float pageScaleDeltaToSend = activeTree()->min_page_scale_factor() / activeTree()->page_scale_factor();
     gfx::SizeF scaledScrollableSize = gfx::ScaleSize(activeTree()->ScrollableSize(), pageScaleDeltaToSend);
 
     gfx::Vector2d anchorOffset = m_previousPinchAnchor.OffsetFromOrigin();
     gfx::Vector2dF scrollEnd = scrollBegin + anchorOffset;
     scrollEnd.Scale(activeTree()->min_page_scale_factor() / scaleBegin);
     scrollEnd -= anchorOffset;
-    scrollEnd.ClampToMax(gfx::RectF(scaledScrollableSize).bottom_right() - gfx::Rect(m_deviceViewportSize).bottom_right());
+    scrollEnd.ClampToMax(gfx::RectF(scaledScrollableSize).bottom_right() - gfx::Rect(deviceViewportSize()).bottom_right());

[danakj, 2013/02/13 06:51:36]

Should this be the active tree's deviceViewportSize()?

[aelias_OOO_until_Jul13, 2013/02/13 07:37:08]

This is dead code due for deletion, doesn't matter.

     scrollEnd.ClampToMin(gfx::Vector2d());
     scrollEnd.Scale(1 / pageScaleDeltaToSend);
     scrollEnd.Scale(m_deviceScaleFactor);
 
     makeScrollAndScaleSet(scrollInfo, gfx::ToRoundedVector2d(scrollEnd), activeTree()->min_page_scale_factor());
 }
 
 static void collectScrollDeltas(ScrollAndScaleSet* scrollInfo, LayerImpl* layerImpl)
 {
     if (!layerImpl)
@@ skipping 269 matching lines @@
     state->SetString("lthi_id", StringPrintf("%p", this));
     state->SetBoolean("visible_resources_ready", pendingTree()->AreVisibleResourcesReady());
     state->Set("tile_manager", m_tileManager->BasicStateAsValue().release());
     return state.PassAs<base::Value>();
 }
 
 scoped_ptr<base::Value> LayerTreeHostImpl::frameStateAsValue() const
 {
     scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
     state->SetString("lthi_id", StringPrintf("%p", this));
-    state->Set("device_viewport_size", MathUtil::asValue(m_deviceViewportSize).release());
+    state->Set("device_viewport_size", MathUtil::asValue(deviceViewportSize()).release());

[danakj, 2013/02/13 06:51:36]

This should be the active tree too right?

I feel like the deviceViewportSize() method returning the pending tree sometimes
is inconsistent with other helper methods on LTHImpl and is confusing things
here. It's a nice trick but only gives the right answer in canDraw().

Can you change the *ViewportSize() methods to return the active tree values, and
have canDraw just do the right thing there?

[aelias_OOO_until_Jul13, 2013/02/13 07:37:08]

If it drew a frame, then active tree and pending tree values are the same
anyway.  But OK, this one I'll change to explicit activeTree in case that ever
changes.
I feel the activeTree value is bad and shouldn't be the default.  Things are
already resized throughout the browser process by the time CC hears about it. 
It's not under CC's control like scroll offset or whatnot.  Weird stuff might
happen if we act as though the old viewport size is still good.

     if (m_tileManager)
         state->Set("tiles", m_tileManager->AllTilesAsValue().release());
     return state.PassAs<base::Value>();
 }
 
 // static
 LayerImpl* LayerTreeHostImpl::getNonCompositedContentLayerRecursive(LayerImpl* layer)
 {
     if (!layer)
         return NULL;
@@ skipping 25 matching lines @@
     if (m_tileManager)
         m_tileManager->SetRecordRenderingStats(m_debugState.recordRenderingStats());
 }
 
 void LayerTreeHostImpl::savePaintTime(const base::TimeDelta& totalPaintTime)
 {
     m_paintTimeCounter->SavePaintTime(totalPaintTime);
 }
 
 }  // namespace cc