Allow binding multiple textures to one DC Layer overlay.

cc/output/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 3214 matching lines @@
   if (overlay_resource_pool_) {
     overlay_resource_pool_->CheckBusyResources();
   }
 
   scoped_refptr<DCLayerOverlaySharedState> shared_state;
   size_t copied_render_pass_count = 0;
   for (const DCLayerOverlay& dc_layer_overlay :
        current_frame()->dc_layer_overlay_list) {
     DCHECK(!dc_layer_overlay.rpdq);
 
-    unsigned texture_id = 0;
+    int i = 0;
+    unsigned texture_ids[DrawQuad::Resources::kMaxResourceIdCount] = {};
+    int ids_to_send = 0;
+
     for (const auto& contents_resource_id : dc_layer_overlay.resources) {
       if (contents_resource_id) {
         pending_overlay_resources_.push_back(
             base::MakeUnique<ResourceProvider::ScopedReadLockGL>(
                 resource_provider_, contents_resource_id));
-        if (!texture_id)
-          texture_id = pending_overlay_resources_.back()->texture_id();
+        texture_ids[i] = pending_overlay_resources_.back()->texture_id();
+        ids_to_send = i + 1;
       }
+      i++;
     }
     GLfloat contents_rect[4] = {
         dc_layer_overlay.contents_rect.x(), dc_layer_overlay.contents_rect.y(),
         dc_layer_overlay.contents_rect.width(),
         dc_layer_overlay.contents_rect.height(),
     };
     GLfloat bounds_rect[4] = {
         dc_layer_overlay.bounds_rect.x(), dc_layer_overlay.bounds_rect.y(),
         dc_layer_overlay.bounds_rect.width(),
         dc_layer_overlay.bounds_rect.height(),
     };
     GLboolean is_clipped = dc_layer_overlay.shared_state->is_clipped;
     GLfloat clip_rect[4] = {dc_layer_overlay.shared_state->clip_rect.x(),
                             dc_layer_overlay.shared_state->clip_rect.y(),
                             dc_layer_overlay.shared_state->clip_rect.width(),
                             dc_layer_overlay.shared_state->clip_rect.height()};
     GLint z_order = dc_layer_overlay.shared_state->z_order;
     GLfloat transform[16];
     dc_layer_overlay.shared_state->transform.asColMajorf(transform);
     unsigned filter = dc_layer_overlay.filter;
 
     if (dc_layer_overlay.shared_state != shared_state) {
       shared_state = dc_layer_overlay.shared_state;
       gl_->ScheduleDCLayerSharedStateCHROMIUM(
           dc_layer_overlay.shared_state->opacity, is_clipped, clip_rect,
           z_order, transform);
     }
-    gl_->ScheduleDCLayerCHROMIUM(
-        texture_id, contents_rect, dc_layer_overlay.background_color,
-        dc_layer_overlay.edge_aa_mask, bounds_rect, filter);
+    gl_->ScheduleDCLayerCHROMIUM(ids_to_send, texture_ids, contents_rect,
+                                 dc_layer_overlay.background_color,
+                                 dc_layer_overlay.edge_aa_mask, bounds_rect,
+                                 filter);
   }
 
   // Take the number of copied render passes in this frame, and use 3 times that
   // amount as the cache limit.
   if (overlay_resource_pool_) {
     overlay_resource_pool_->SetResourceUsageLimits(
         std::numeric_limits<std::size_t>::max(), copied_render_pass_count * 5);
   }
 }
 
@@ skipping 319 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc