cc: Remove DrawQuad::IterateResoruces

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 434 matching lines @@
   always_clear = true;
 #endif
   if (always_clear || frame->current_render_pass->has_transparent_background) {
     GLbitfield clear_bits = GL_COLOR_BUFFER_BIT;
     if (always_clear)
       clear_bits |= GL_STENCIL_BUFFER_BIT;
     gl_->Clear(clear_bits);
   }
 }
 
-static ResourceId WaitOnResourceSyncPoints(ResourceProvider* resource_provider,
-                                           ResourceId resource_id) {
-  resource_provider->WaitSyncPointIfNeeded(resource_id);
-  return resource_id;
-}
-
 void GLRenderer::BeginDrawingFrame(DrawingFrame* frame) {
   TRACE_EVENT0("cc", "GLRenderer::BeginDrawingFrame");
 
   scoped_refptr<ResourceProvider::Fence> read_lock_fence;
   if (use_sync_query_) {
     // Block until oldest sync query has passed if the number of pending queries
     // ever reach kMaxPendingSyncQueries.
     if (pending_sync_queries_.size() >= kMaxPendingSyncQueries) {
       LOG(ERROR) << "Reached limit of pending sync queries.";
 
@@ skipping 14 matching lines @@
 
     read_lock_fence = current_sync_query_->Begin();
   } else {
     read_lock_fence =
         make_scoped_refptr(new ResourceProvider::SynchronousFence(gl_));
   }
   resource_provider_->SetReadLockFence(read_lock_fence.get());
 
   // Insert WaitSyncPointCHROMIUM on quad resources prior to drawing the frame,
   // so that drawing can proceed without GL context switching interruptions.
-  DrawQuad::ResourceIteratorCallback wait_on_resource_syncpoints_callback =
-      base::Bind(&WaitOnResourceSyncPoints, resource_provider_);
-
+  ResourceProvider* resource_provider = resource_provider_;
   for (const auto& pass : *frame->render_passes_in_draw_order) {
-    for (const auto& quad : pass->quad_list)
-      quad->IterateResources(wait_on_resource_syncpoints_callback);
+    for (const auto& quad : pass->quad_list) {
+      for (const ResourceId& resource_id : quad->resources)

[piman, 2015/05/28 19:35:46]

nit: ResourceId instead of const ResourceId&

[vmpstr, 2015/05/28 22:36:59]

Done.

+        resource_provider->WaitSyncPointIfNeeded(resource_id);
+    }
   }
 
   // TODO(enne): Do we need to reinitialize all of this state per frame?
   ReinitializeGLState();
 }
 
 void GLRenderer::DoNoOp() {
   gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
   gl_->Flush();
 }
@@ skipping 477 matching lines @@
             ApplyBackgroundFilters(frame, quad, background_texture.get());
       }
     }
 
     if (!background_texture) {
       // Something went wrong with reading the backdrop.
       DCHECK(!background_image);
       use_shaders_for_blending = false;
     } else if (background_image) {
       // Reset original background texture if there is not any mask
-      if (!quad->mask_resource_id)
+      if (!quad->mask_resource_id())
         background_texture.reset();
     } else if (CanApplyBlendModeUsingBlendFunc(blend_mode) &&
                ShouldApplyBackgroundFilters(frame, quad)) {
       // Something went wrong with applying background filters to the backdrop.
       use_shaders_for_blending = false;
       background_texture.reset();
     }
   }
   // Need original background texture for mask?
   bool mask_for_background =
-      background_texture &&    // Have original background texture
-      background_image &&      // Have filtered background texture
-      quad->mask_resource_id;  // Have mask texture
+      background_texture &&      // Have original background texture
+      background_image &&        // Have filtered background texture
+      quad->mask_resource_id();  // Have mask texture
   SetBlendEnabled(
       !use_shaders_for_blending &&
       (quad->ShouldDrawWithBlending() || !IsDefaultBlendMode(blend_mode)));
 
   // TODO(senorblanco): Cache this value so that we don't have to do it for both
   // the surface and its replica.  Apply filters to the contents texture.
   skia::RefPtr<SkImage> filter_image;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
   if (!quad->filters.IsEmpty()) {
@@ skipping 16 matching lines @@
         filter_image = ApplyImageFilter(
             ScopedUseGrContext::Create(this, frame), resource_provider_,
             quad->rect, quad->filters_scale, filter.get(), contents_texture);
       }
     }
   }
 
   scoped_ptr<ResourceProvider::ScopedSamplerGL> mask_resource_lock;
   unsigned mask_texture_id = 0;
   SamplerType mask_sampler = SAMPLER_TYPE_NA;
-  if (quad->mask_resource_id) {
+  if (quad->mask_resource_id()) {
     mask_resource_lock.reset(new ResourceProvider::ScopedSamplerGL(
-        resource_provider_, quad->mask_resource_id, GL_TEXTURE1, GL_LINEAR));
+        resource_provider_, quad->mask_resource_id(), GL_TEXTURE1, GL_LINEAR));
     mask_texture_id = mask_resource_lock->texture_id();
     mask_sampler = SamplerTypeFromTextureTarget(mask_resource_lock->target());
   }
 
   scoped_ptr<ResourceProvider::ScopedSamplerGL> contents_resource_lock;
   if (filter_image) {
     GrTexture* texture = filter_image->getTexture();
     DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
     gl_->BindTexture(GL_TEXTURE_2D, texture->getTextureHandle());
   } else {
@@ skipping 567 matching lines @@
 
   uniforms->sampler_location = program->fragment_shader().sampler_location();
   uniforms->alpha_location = program->fragment_shader().alpha_location();
   uniforms->fragment_tex_transform_location =
       program->fragment_shader().fragment_tex_transform_location();
 }
 
 void GLRenderer::DrawTileQuad(const DrawingFrame* frame,
                               const TileDrawQuad* quad,
                               const gfx::QuadF* clip_region) {
-  DrawContentQuad(frame, quad, quad->resource_id, clip_region);
+  DrawContentQuad(frame, quad, quad->resource_id(), clip_region);
 }
 
 void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
                                  const ContentDrawQuadBase* quad,
                                  ResourceId resource_id,
                                  const gfx::QuadF* clip_region) {
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix * quad->quadTransform();
   device_transform.FlattenTo2d();
 
@@ skipping 248 matching lines @@
                                   const YUVVideoDrawQuad* quad,
                                   const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_,
       &highp_threshold_cache_,
       highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
-  bool use_alpha_plane = quad->a_plane_resource_id != 0;
+  bool use_alpha_plane = quad->a_plane_resource_id() != 0;
 
   ResourceProvider::ScopedSamplerGL y_plane_lock(
-      resource_provider_, quad->y_plane_resource_id, GL_TEXTURE1, GL_LINEAR);
+      resource_provider_, quad->y_plane_resource_id(), GL_TEXTURE1, GL_LINEAR);
   ResourceProvider::ScopedSamplerGL u_plane_lock(
-      resource_provider_, quad->u_plane_resource_id, GL_TEXTURE2, GL_LINEAR);
+      resource_provider_, quad->u_plane_resource_id(), GL_TEXTURE2, GL_LINEAR);
   DCHECK_EQ(y_plane_lock.target(), u_plane_lock.target());
   ResourceProvider::ScopedSamplerGL v_plane_lock(
-      resource_provider_, quad->v_plane_resource_id, GL_TEXTURE3, GL_LINEAR);
+      resource_provider_, quad->v_plane_resource_id(), GL_TEXTURE3, GL_LINEAR);
   DCHECK_EQ(y_plane_lock.target(), v_plane_lock.target());
   scoped_ptr<ResourceProvider::ScopedSamplerGL> a_plane_lock;
   if (use_alpha_plane) {
     a_plane_lock.reset(new ResourceProvider::ScopedSamplerGL(
-        resource_provider_, quad->a_plane_resource_id, GL_TEXTURE4, GL_LINEAR));
+        resource_provider_, quad->a_plane_resource_id(), GL_TEXTURE4,
+        GL_LINEAR));
     DCHECK_EQ(y_plane_lock.target(), a_plane_lock->target());
   }
 
   // All planes must have the same sampler type.
   SamplerType sampler = SamplerTypeFromTextureTarget(y_plane_lock.target());
 
   int matrix_location = -1;
   int ya_tex_scale_location = -1;
   int ya_tex_offset_location = -1;
   int uv_tex_scale_location = -1;
@@ skipping 192 matching lines @@
 
   const VideoStreamTextureProgram* program =
       GetVideoStreamTextureProgram(tex_coord_precision);
   SetUseProgram(program->program());
 
   ToGLMatrix(&gl_matrix[0], quad->matrix);
   gl_->UniformMatrix4fv(program->vertex_shader().tex_matrix_location(), 1,
                         false, gl_matrix);
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
-                                          quad->resource_id);
+                                          quad->resource_id());
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
   gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id());
 
   gl_->Uniform1i(program->fragment_shader().sampler_location(), 0);
 
   SetShaderOpacity(quad->opacity(),
                    program->fragment_shader().alpha_location());
   if (!clip_region) {
     DrawQuadGeometry(frame, quad->quadTransform(), quad->rect,
                      program->vertex_shader().matrix_location());
@@ skipping 116 matching lines @@
     FlushTextureQuadCache(SHARED_BINDING);
   }
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_,
       &highp_threshold_cache_,
       highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
-                                          quad->resource_id);
+                                          quad->resource_id());
   const SamplerType sampler = SamplerTypeFromTextureTarget(lock.target());
   // Choose the correct texture program binding
   TexTransformTextureProgramBinding binding;
   if (quad->premultiplied_alpha) {
     if (quad->background_color == SK_ColorTRANSPARENT) {
       binding.Set(GetTextureProgram(tex_coord_precision, sampler));
     } else {
       binding.Set(GetTextureBackgroundProgram(tex_coord_precision, sampler));
     }
   } else {
     if (quad->background_color == SK_ColorTRANSPARENT) {
       binding.Set(
           GetNonPremultipliedTextureProgram(tex_coord_precision, sampler));
     } else {
       binding.Set(GetNonPremultipliedTextureBackgroundProgram(
           tex_coord_precision, sampler));
     }
   }
 
-  int resource_id = quad->resource_id;
+  int resource_id = quad->resource_id();
 
   if (draw_cache_.program_id != binding.program_id ||
       draw_cache_.resource_id != resource_id ||
       draw_cache_.needs_blending != quad->ShouldDrawWithBlending() ||
       draw_cache_.nearest_neighbor != quad->nearest_neighbor ||
       draw_cache_.background_color != quad->background_color ||
       draw_cache_.matrix_data.size() >= 8) {
     FlushTextureQuadCache(SHARED_BINDING);
     draw_cache_.program_id = binding.program_id;
     draw_cache_.resource_id = resource_id;
@@ skipping 78 matching lines @@
     gl_->Uniform4f(binding.tex_transform_location, 0, 0,
                    quad->io_surface_size.width(),
                    quad->io_surface_size.height());
   }
 
   const float vertex_opacity[] = {quad->opacity(), quad->opacity(),
                                   quad->opacity(), quad->opacity()};
   gl_->Uniform1fv(binding.vertex_opacity_location, 4, vertex_opacity);
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
-                                          quad->io_surface_resource_id);
+                                          quad->io_surface_resource_id());
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
   gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, lock.texture_id());
 
   if (!clip_region) {
     DrawQuadGeometry(frame, quad->quadTransform(), quad->rect,
                      binding.matrix_location);
   } else {
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     DrawQuadGeometryClippedByQuadF(frame, quad->quadTransform(), quad->rect,
@@ skipping 1106 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         ToNearestRect(overlay.display_rect),
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc