Start of hardware overlay support in CC with Ubercompositor.

cc/output/overlay_strategy_single_on_top.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_strategy_single_on_top.h"
+
+#include "cc/output/output_surface.h"
+#include "cc/quads/draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
+#include "ui/gfx/rect_conversions.h"
+#include "ui/gfx/transform.h"
+
+namespace cc {
+
+OverlayStrategySingleOnTop::OverlayStrategySingleOnTop(
+    OverlayCandidateValidator* capability_checker,
+    ResourceProvider* resource_provider)
+    : capability_checker_(capability_checker),
+      resource_provider_(resource_provider) {}
+
+bool OverlayStrategySingleOnTop::Attempt(
+    RenderPassList* render_passes_in_draw_order) {
+  // Only attempt to handle very simple case for now.
+  if (render_passes_in_draw_order->size() != 1 || !capability_checker_)

[piman, 2014/03/18 23:46:08]

nit: actually, do we even care about the render pass size? If we have multiple
passes, as long as we're only looking at the root pass, as long as we decided
that the texture quad for consideration isn't overlapped by anything (since it's
last), it doesn't matter if this "anything" comes from a pass or not... When we
have multiple pass, the way other passes come into play is by having references
to them from RenderPassDrawQuads in the root pass. I think we'd still be correct
if we remove the size != 1 check, and more general.

+    return false;
+
+  RenderPass* root_render_pass = render_passes_in_draw_order->back();
+  DCHECK(root_render_pass);
+
+  QuadList& quad_list = root_render_pass->quad_list;
+  const DrawQuad* candidate_quad = quad_list.front();
+  if (candidate_quad->material != DrawQuad::TEXTURE_CONTENT)
+    return false;
+
+  ResourceProvider::ResourceId resource_id =
+      TextureDrawQuad::MaterialCast(candidate_quad)->resource_id;
+  if (!resource_provider_->AllowOverlay(resource_id))
+    return false;
+
+  // Add our primary surface.
+  OverlayCandidateValidator::OverlayCandidateList candidates;
+  OverlayCandidate main_image;
+  main_image.display_rect = root_render_pass->output_rect;
+  main_image.format = RGBA_8888;
+  candidates.push_back(main_image);
+
+  // Add the overlay.
+  OverlayCandidate candidate;
+  const TextureDrawQuad& quad = *TextureDrawQuad::MaterialCast(candidate_quad);

[piman, 2014/03/18 23:46:08]

nit: we could do this only once above, before we grab the resource id.
Also, we should do all the rejecting early, before we allocate memory (by
pushing back into candidates).

+  if (!quad.quadTransform().IsIdentityOrTranslation())

[piman, 2014/03/18 23:46:08]

Should we also reject if quad.shared_quad_state->opacity != 1? Also, I think
blend_mode != kSrcOver_Mode and probably something with quad.needs_blending,
vertex_opacity, background_color... flipped? premultiplied_alpha?

We should be conservative first, and then add support as we can.

+    return false;
+  gfx::RectF float_rect(quad.rect);
+  quad.quadTransform().TransformRect(&float_rect);
+  candidate.display_rect = gfx::ToNearestRect(float_rect);
+  candidate.uv_rect = BoundingRect(quad.uv_top_left, quad.uv_bottom_right);
+  candidate.format = RGBA_8888;
+  candidates.push_back(candidate);
+
+  // Check for support.
+  capability_checker_->CheckOverlaySupport(&candidates);
+
+  // If the candidate can be handled by an overlay, create a pass for it.
+  if (candidates[1].overlay_handled) {
+    scoped_ptr<RenderPass> overlay_pass = RenderPass::Create();
+    overlay_pass->overlay_state = RenderPass::SIMPLE_OVERLAY;
+
+    scoped_ptr<DrawQuad> overlay_quad = quad_list.take(quad_list.begin());
+    quad_list.erase(quad_list.begin());
+    overlay_pass->quad_list.push_back(overlay_quad.Pass());
+    render_passes_in_draw_order->insert(render_passes_in_draw_order->begin(),
+                                        overlay_pass.Pass());
+  }
+  return candidates[1].overlay_handled;
+}
+
+}  // namespace cc