cc: Remove redundant is_overlay arguments

cc/output/overlay_candidate.cc

 // Copyright 2014 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/overlay_candidate.h"
 
 #include <algorithm>
 #include <limits>
 #include "base/logging.h"
 #include "cc/base/math_util.h"
 #include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
+#include "cc/quads/tile_draw_quad.h"
+#include "cc/resources/resource_provider.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/vector3d_f.h"
 
 namespace cc {
 
 namespace {
 // Tolerance for considering axis vector elements to be zero.
 const SkMScalar kEpsilon = std::numeric_limits<float>::epsilon();
 
 enum Axis { NONE, AXIS_POS_X, AXIS_NEG_X, AXIS_POS_Y, AXIS_NEG_Y };
@@ skipping 146 matching lines @@
       uv_rect(0.f, 0.f, 1.f, 1.f),
       is_clipped(false),
       use_output_surface_for_resource(false),
       resource_id(0),
       plane_z_order(0),
       overlay_handled(false) {}
 
 OverlayCandidate::~OverlayCandidate() {}
 
 // static
-bool OverlayCandidate::FromDrawQuad(const DrawQuad* quad,
+bool OverlayCandidate::FromDrawQuad(ResourceProvider* resource_provider,
+                                    const DrawQuad* quad,
                                     OverlayCandidate* candidate) {
   if (quad->needs_blending || quad->shared_quad_state->opacity != 1.f ||
       quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode)
     return false;
 
   auto& transform = quad->shared_quad_state->quad_to_target_transform;
   candidate->display_rect = gfx::RectF(quad->rect);
   transform.TransformRect(&candidate->display_rect);
   candidate->quad_rect_in_target_space =
       MathUtil::MapEnclosingClippedRect(transform, quad->rect);
 
   candidate->format = RGBA_8888;
   candidate->clip_rect = quad->shared_quad_state->clip_rect;
   candidate->is_clipped = quad->shared_quad_state->is_clipped;
 
   switch (quad->material) {
     case DrawQuad::TEXTURE_CONTENT:
-      return FromTextureQuad(TextureDrawQuad::MaterialCast(quad), candidate);
+      return FromTextureQuad(resource_provider,
+                             TextureDrawQuad::MaterialCast(quad), candidate);
     case DrawQuad::STREAM_VIDEO_CONTENT:
-      return FromStreamVideoQuad(StreamVideoDrawQuad::MaterialCast(quad),
+      return FromStreamVideoQuad(resource_provider,
+                                 StreamVideoDrawQuad::MaterialCast(quad),
                                  candidate);
     case DrawQuad::IO_SURFACE_CONTENT:
-      return FromIOSurfaceQuad(IOSurfaceDrawQuad::MaterialCast(quad),
-                               candidate);
+      return FromIOSurfaceQuad(
+          resource_provider, IOSurfaceDrawQuad::MaterialCast(quad), candidate);
     default:
       break;
   }
 
   return false;
 }
 
 // static
 bool OverlayCandidate::IsInvisibleQuad(const DrawQuad* quad) {
   if (quad->material == DrawQuad::SOLID_COLOR) {
     SkColor color = SolidColorDrawQuad::MaterialCast(quad)->color;
     float opacity = quad->shared_quad_state->opacity;
     float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
     return quad->ShouldDrawWithBlending() &&
            alpha < std::numeric_limits<float>::epsilon();
   }
   return false;
 }
 
 // static
-bool OverlayCandidate::FromTextureQuad(const TextureDrawQuad* quad,
+bool OverlayCandidate::FromTextureQuad(ResourceProvider* resource_provider,
+                                       const TextureDrawQuad* quad,
                                        OverlayCandidate* candidate) {
-  if (!quad->allow_overlay())
+  if (!resource_provider->IsOverlayCandidate(quad->resource_id()))
     return false;
   gfx::OverlayTransform overlay_transform = GetOverlayTransform(
       quad->shared_quad_state->quad_to_target_transform, quad->y_flipped);
   if (quad->background_color != SK_ColorTRANSPARENT ||
       quad->premultiplied_alpha ||
       overlay_transform == gfx::OVERLAY_TRANSFORM_INVALID)
     return false;
   candidate->resource_id = quad->resource_id();
   candidate->resource_size_in_pixels = quad->resource_size_in_pixels();
   candidate->transform = overlay_transform;
   candidate->uv_rect = BoundingRect(quad->uv_top_left, quad->uv_bottom_right);
   return true;
 }
 
 // static
-bool OverlayCandidate::FromStreamVideoQuad(const StreamVideoDrawQuad* quad,
+bool OverlayCandidate::FromStreamVideoQuad(ResourceProvider* resource_provider,
+                                           const StreamVideoDrawQuad* quad,
                                            OverlayCandidate* candidate) {
-  if (!quad->allow_overlay())
+  if (!resource_provider->IsOverlayCandidate(quad->resource_id()))
     return false;
   gfx::OverlayTransform overlay_transform = GetOverlayTransform(
       quad->shared_quad_state->quad_to_target_transform, false);
   if (overlay_transform == gfx::OVERLAY_TRANSFORM_INVALID)
     return false;
   if (!quad->matrix.IsScaleOrTranslation()) {
     // We cannot handle anything other than scaling & translation for texture
     // coordinates yet.
     return false;
   }
@@ skipping 22 matching lines @@
     candidate->uv_rect = gfx::RectF(uv0.x(), uv1.y(), delta.x(), -delta.y());
   } else {
     candidate->transform = ComposeTransforms(
         gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL, candidate->transform);
     candidate->uv_rect = gfx::RectF(uv0.x(), uv0.y(), delta.x(), delta.y());
   }
   return true;
 }
 
 // static
-bool OverlayCandidate::FromIOSurfaceQuad(const IOSurfaceDrawQuad* quad,
+bool OverlayCandidate::FromIOSurfaceQuad(ResourceProvider* resource_provider,
+                                         const IOSurfaceDrawQuad* quad,
                                          OverlayCandidate* candidate) {
-  if (!quad->allow_overlay)
+  if (!resource_provider->IsOverlayCandidate(quad->io_surface_resource_id()))
     return false;
   gfx::OverlayTransform overlay_transform = GetOverlayTransform(
       quad->shared_quad_state->quad_to_target_transform, false);
   if (overlay_transform != gfx::OVERLAY_TRANSFORM_NONE)
     return false;
   candidate->resource_id = quad->io_surface_resource_id();
   candidate->resource_size_in_pixels = quad->io_surface_size;
   candidate->transform = overlay_transform;
   candidate->uv_rect = gfx::RectF(1.f, 1.f);
   return true;
 }
 
 }  // namespace cc