Allow using a larger-than-necessary texture as cached render pass backing

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 "cc/math_util.h"
@@ skipping 117 matching lines @@
             passesToDelete.push_back(passIterator->first);
             continue;
         }
 
         const RenderPass* renderPassInFrame = it->second;
         const gfx::Size& requiredSize = renderPassTextureSize(renderPassInFrame);
         GLenum requiredFormat = renderPassTextureFormat(renderPassInFrame);
         CachedResource* texture = passIterator->second;
         DCHECK(texture);
 
-        if (texture->id() && (texture->size() != requiredSize || texture->format() != requiredFormat))
+        bool sizeAppropriate = texture->size().width() >= requiredSize.width() &&
+                               texture->size().height() >= requiredSize.height();
+        if (texture->id() && (!sizeAppropriate || texture->format() != requiredFormat))

[danakj, 2012/11/20 00:26:33]

I'm worried about the texture cacheing code. It makes assumptions that if the
texture size changes, then it knows to redraw the texture, and I'm not certain
if this change will make it not redraw the texture.

I am hoping we have tests that cover this.

[danakj, 2012/11/20 00:36:41]

Is it true that in order for the size of the render pass to change, that some
property must have caused damage to the renderPass, and so
contentsChangedSinceLastFrame() will be non-empty?

If that's the case then I think this is fine, and I can't imagine a good test
for it since the case can't happen.

[enne (OOO), 2012/11/20 00:39:45]

Yeah, I think contentsChangedSinceLastFrame will correctly get this redrawn
without reallocating the texture.

In terms of testing, I think this is another case where a cc pixel test is
really needed.

[danakj, 2012/11/20 00:41:36]

Ya, Okay I've convinced myself that we'll be alright. If the surface's
contentRect() changes, then its surfacePropertyHasChanged = true. Then the
damageTracker sets damage to the entire surface bounds. So we win. LGTM.

             texture->Free();
     }
 
     // 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);
@@ skipping 82 matching lines @@
     return pass->outputRect().size();
 }
 
 // static
 GLenum DirectRenderer::renderPassTextureFormat(const RenderPass*)
 {
     return GL_RGBA;
 }
 
 }  // namespace cc