Optimize render passes with single quads

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 <stddef.h>
 
 #include <unordered_map>
 #include <utility>
@@ skipping 123 matching lines @@
                                ResourceProvider* resource_provider)
     : Renderer(client, settings),
       output_surface_(output_surface),
       resource_provider_(resource_provider),
       overlay_processor_(new OverlayProcessor(output_surface)) {
   overlay_processor_->Initialize();
 }
 
 DirectRenderer::~DirectRenderer() {}
 
+const TileDrawQuad* DirectRenderer::CanPassBeDrawnDirectly(
+    const RenderPass* pass) {
+  return nullptr;
+}
+
 void DirectRenderer::DecideRenderPassAllocationsForFrame(
     const RenderPassList& render_passes_in_draw_order) {
+  render_pass_bypass_quads_.clear();
+
   std::unordered_map<RenderPassId, gfx::Size, RenderPassIdHash>
       render_passes_in_frame;
-  for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i)
+  RenderPass* root_render_pass = render_passes_in_draw_order.back().get();
+  for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i) {
+    RenderPass* pass = render_passes_in_draw_order[i].get();
+    if (pass != root_render_pass) {

[enne (OOO), 2016/06/13 18:41:17]

Maybe we shouldn't drop the root render pass?

This fixes the context menu issue.

+      if (const TileDrawQuad* tile_quad = CanPassBeDrawnDirectly(pass)) {
+        render_pass_bypass_quads_[pass->id] = *tile_quad;
+        continue;
+      }
+    }
     render_passes_in_frame.insert(std::pair<RenderPassId, gfx::Size>(
-        render_passes_in_draw_order[i]->id,
-        RenderPassTextureSize(render_passes_in_draw_order[i].get())));
+        pass->id, RenderPassTextureSize(pass)));
+  }
 
   std::vector<RenderPassId> passes_to_delete;
   for (auto pass_iter = render_pass_textures_.begin();
        pass_iter != render_pass_textures_.end(); ++pass_iter) {
     auto it = render_passes_in_frame.find(pass_iter->first);
     if (it == render_passes_in_frame.end()) {
       passes_to_delete.push_back(pass_iter->first);
       continue;
     }
 
@@ skipping 236 matching lines @@
   BspTree bsp_tree(poly_list);
   BspWalkActionDrawPolygon action_handler(this, frame, render_pass_scissor,
                                           use_render_pass_scissor);
   bsp_tree.TraverseWithActionHandler(&action_handler);
   DCHECK(poly_list->empty());
 }
 
 void DirectRenderer::DrawRenderPassAndExecuteCopyRequests(
     DrawingFrame* frame,
     RenderPass* render_pass) {
+  if (render_pass_bypass_quads_.find(render_pass->id) !=
+      render_pass_bypass_quads_.end()) {
+    return;
+  }
+
   DrawRenderPass(frame, render_pass);
 
   bool first_request = true;
   for (auto& copy_request : render_pass->copy_requests) {
     // Doing a readback is destructive of our state on Mac, so make sure
     // we restore the state between readbacks. http://crbug.com/99393.
     if (!first_request)
       UseRenderPass(frame, render_pass);
     CopyCurrentRenderPassToBitmap(frame, std::move(copy_request));
     first_request = false;
@@ skipping 136 matching lines @@
   auto iter = render_pass_textures_.find(id);
   return iter != render_pass_textures_.end() && iter->second->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc