Fixes a bug when the framebuffer is cleared with invalid scissor rect

cc/direct_renderer.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/direct_renderer.h"
 
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
@@ skipping 126 matching lines @@
         const RenderPass* renderPassInFrame = it->second;
         const gfx::Size& requiredSize = renderPassTextureSize(renderPassInFrame);
         GLenum requiredFormat = renderPassTextureFormat(renderPassInFrame);
         CachedResource* texture = passIterator->second;
         DCHECK(texture);
 
         bool sizeAppropriate = texture->size().width() >= requiredSize.width() &&
                                texture->size().height() >= requiredSize.height();
         if (texture->id() && (!sizeAppropriate || texture->format() != requiredFormat))
             texture->Free();
+        else if (texture->size() != requiredSize)

[danakj, 2013/01/24 23:38:04]

What happens if you texture->setIsComplete(false) here instead?

+            texture->setNeedsFullClear(true);

[danakj, 2013/01/24 23:23:18]

Doesn't this clear the whole texture every frame once your surface shrinks down
by 1px?

[danakj, 2013/01/24 23:39:25]

Before it would have reallocated a new texture of the right size, and not
cleared it every frame.

     }
 
     // Delete RenderPass textures from the previous frame that will not be used again.
     for (size_t i = 0; i < passesToDelete.size(); ++i)
         m_renderPassTextures.erase(passesToDelete[i]);
 
     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) {
         if (!m_renderPassTextures.contains(renderPassesInDrawOrder[i]->id)) {
           scoped_ptr<CachedResource> texture = CachedResource::create(m_resourceProvider);
             m_renderPassTextures.set(renderPassesInDrawOrder[i]->id, texture.Pass());
@@ skipping 76 matching lines @@
         return;
 
     bool usingScissorAsOptimization = capabilities().usingPartialSwap;
     gfx::RectF renderPassScissor;
 
     if (usingScissorAsOptimization) {
         renderPassScissor = computeScissorRectForRenderPass(frame);
         setScissorTestRect(moveScissorToWindowSpace(frame, renderPassScissor));
     }
 
-    if (frame.currentRenderPass != frame.rootRenderPass || m_client->shouldClearRootRenderPass())
-        clearFramebuffer(frame);
+    bool isRootPass = frame.currentRenderPass == frame.rootRenderPass;
+    if (!isRootPass || m_client->shouldClearRootRenderPass()) {
+        CachedResource* texture = m_renderPassTextures.get(frame.currentRenderPass->id);
+        DCHECK(texture);
+        bool fullClear = false;
+        if (!isRootPass)
+            fullClear = texture->needsFullClear();
+        clearFramebuffer(frame, fullClear);
+        texture->setNeedsFullClear(false);
+    }
 
     const QuadList& quadList = renderPass->quad_list;
     for (QuadList::constBackToFrontIterator it = quadList.backToFrontBegin(); it != quadList.backToFrontEnd(); ++it) {
         const DrawQuad& quad = *(*it);
         bool shouldSkipQuad = false;
 
         if (usingScissorAsOptimization)
             setScissorStateForQuadWithRenderPassScissor(frame, quad, renderPassScissor, &shouldSkipQuad);
         else
             setScissorStateForQuad(frame, quad);
@@ skipping 43 matching lines @@
     return pass->output_rect.size();
 }
 
 // static
 GLenum DirectRenderer::renderPassTextureFormat(const RenderPass*)
 {
     return GL_RGBA;
 }
 
 }  // namespace cc