cc: Add tile-free software compositing mode.

cc/output/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/output/direct_renderer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/debug/trace_event.h"
@@ skipping 115 matching lines @@
 
 DirectRenderer::~DirectRenderer() {}
 
 void DirectRenderer::SetEnlargePassTextureAmountForTesting(
     gfx::Vector2d amount) {
   enlarge_pass_texture_amount_ = amount;
 }
 
 void DirectRenderer::DecideRenderPassAllocationsForFrame(
     const RenderPassList& render_passes_in_draw_order) {
+  if (!resource_provider_)
+    return;
+
   base::hash_map<RenderPass::Id, const RenderPass*> render_passes_in_frame;
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i)
     render_passes_in_frame.insert(std::pair<RenderPass::Id, const RenderPass*>(
         render_passes_in_draw_order[i]->id, render_passes_in_draw_order[i]));
 
   std::vector<RenderPass::Id> passes_to_delete;
   ScopedPtrHashMap<RenderPass::Id, CachedResource>::const_iterator pass_iter;
   for (pass_iter = render_pass_textures_.begin();
        pass_iter != render_pass_textures_.end();
        ++pass_iter) {
@@ skipping 164 matching lines @@
   frame->current_render_pass = render_pass;
   frame->current_texture = NULL;
 
   if (render_pass == frame->root_render_pass) {
     BindFramebufferToOutputSurface(frame);
     InitializeMatrices(frame, render_pass->output_rect, FlippedFramebuffer());
     SetDrawViewportSize(render_pass->output_rect.size());
     return true;
   }
 
+  if (!resource_provider_)

[enne (OOO), 2013/05/07 06:11:22]

Does this line imply that you can't have render passes for a software-only
WebView?

[aelias_OOO_until_Jul13, 2013/05/07 23:51:47]

Yes, for now.  We may revisit and add support later if there's a compelling use
case.

[enne (OOO), 2013/05/09 17:35:43]

Ok.  You're the one making the requirements here and I don't think punting on
this adds complication.

I do think that render passes would be trickier to implement in a way that would
also work for capture picture (without rasterizing intermediate bitmaps for the
surfaces) since you'd have to get saveLayer calls in the right place.

+    return false;
+
   CachedResource* texture = render_pass_textures_.get(render_pass->id);
   DCHECK(texture);
 
   gfx::Size size = RenderPassTextureSize(render_pass);
   size.Enlarge(enlarge_pass_texture_amount_.x(),
                enlarge_pass_texture_amount_.y());
   if (!texture->id() &&
       !texture->Allocate(size,
                          RenderPassTextureFormat(render_pass),
                          ResourceProvider::TextureUsageFramebuffer))
@@ skipping 15 matching lines @@
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 // static
 GLenum DirectRenderer::RenderPassTextureFormat(const RenderPass* render_pass) {
   return GL_RGBA;
 }
 
 }  // namespace cc