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);
 
     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());
     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(m_activeTree->device_viewport_size()).release());
     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