Mac Overlays: Allow SolidColor and Tile quads to be candidates for overlays.

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"
@@ skipping 154 matching lines @@
   }
 }
 
 }  // namespace
 
 OverlayCandidate::OverlayCandidate()
     : transform(gfx::OVERLAY_TRANSFORM_NONE),
       format(RGBA_8888),
       uv_rect(0.f, 0.f, 1.f, 1.f),
       is_clipped(false),
-      use_output_surface_for_resource(false),
-      resource_id(0),
+      resource_type(HAS_RESOURCE),
       plane_z_order(0),
       overlay_handled(false) {}
 
 OverlayCandidate::~OverlayCandidate() {}
 
 // static
 bool OverlayCandidate::FromDrawQuad(ResourceProvider* resource_provider,
                                     const DrawQuad* quad,
                                     OverlayCandidate* candidate) {
   if (quad->needs_blending || quad->shared_quad_state->opacity != 1.f ||
@@ skipping 14 matching lines @@
     case DrawQuad::TEXTURE_CONTENT:
       return FromTextureQuad(resource_provider,
                              TextureDrawQuad::MaterialCast(quad), candidate);
     case DrawQuad::STREAM_VIDEO_CONTENT:
       return FromStreamVideoQuad(resource_provider,
                                  StreamVideoDrawQuad::MaterialCast(quad),
                                  candidate);
     case DrawQuad::IO_SURFACE_CONTENT:
       return FromIOSurfaceQuad(
           resource_provider, IOSurfaceDrawQuad::MaterialCast(quad), candidate);
+    case DrawQuad::TILED_CONTENT:
+      return FromTileQuad(resource_provider, TileDrawQuad::MaterialCast(quad),
+                          candidate);
+    case DrawQuad::SOLID_COLOR:
+      return FromSolidColorQuad(SolidColorDrawQuad::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(ResourceProvider* resource_provider,
                                        const TextureDrawQuad* quad,
                                        OverlayCandidate* candidate) {
   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.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(ResourceProvider* resource_provider,
                                            const StreamVideoDrawQuad* quad,
                                            OverlayCandidate* candidate) {
   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;
   }
-  candidate->resource_id = quad->resource_id();
+  candidate->resource.resource_id = quad->resource_id();
   candidate->resource_size_in_pixels = quad->resource_size_in_pixels();
   candidate->transform = overlay_transform;
 
   gfx::Point3F uv0 = gfx::Point3F(0, 0, 0);
   gfx::Point3F uv1 = gfx::Point3F(1, 1, 0);
   quad->matrix.TransformPoint(&uv0);
   quad->matrix.TransformPoint(&uv1);
   gfx::Vector3dF delta = uv1 - uv0;
   if (delta.x() < 0) {
     candidate->transform = ComposeTransforms(
@@ skipping 20 matching lines @@
 // static
 bool OverlayCandidate::FromIOSurfaceQuad(ResourceProvider* resource_provider,
                                          const IOSurfaceDrawQuad* quad,
                                          OverlayCandidate* candidate) {
   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.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;
 }
 
+// static
+bool OverlayCandidate::FromTileQuad(ResourceProvider* resource_provider,
+                                    const TileDrawQuad* quad,
+                                    OverlayCandidate* candidate) {
+  if (!resource_provider->IsOverlayCandidate(quad->resource_id()))
+    return false;
+  candidate->transform = GetOverlayTransform(
+      quad->shared_quad_state->quad_to_target_transform, false);
+  if (candidate->transform != gfx::OVERLAY_TRANSFORM_NONE)
+    return false;
+  candidate->resource.resource_id = quad->resource_id();
+  candidate->resource_size_in_pixels = quad->texture_size;
+  candidate->uv_rect = quad->tex_coord_rect;
+  candidate->uv_rect.Scale(1.f / quad->texture_size.width(),
+                           1.f / quad->texture_size.height());
+  return true;
+}
+
+// static
+bool OverlayCandidate::FromSolidColorQuad(const SolidColorDrawQuad* quad,
+                                          OverlayCandidate* candidate) {
+  candidate->transform = GetOverlayTransform(
+      quad->shared_quad_state->quad_to_target_transform, false);
+  if (candidate->transform != gfx::OVERLAY_TRANSFORM_NONE)
+    return false;
+  candidate->resource_type = SOLID_COLOR;
+  candidate->resource.solid_color = quad->color;
+  return true;
+}
+
 }  // namespace cc