Use SwapBuffersWithBounds on Chromecast

cc/output/overlay_strategy_underlay_cast.cc

Index: cc/output/overlay_strategy_underlay_cast.cc
diff --git a/cc/output/overlay_strategy_underlay_cast.cc b/cc/output/overlay_strategy_underlay_cast.cc
new file mode 100644
index 0000000000000000000000000000000000000000..614df2ec038474d3eaa0fa4588b934766ce47a92
--- /dev/null
+++ b/cc/output/overlay_strategy_underlay_cast.cc
@@ -0,0 +1,67 @@
+// Copyright 2017 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_underlay_cast.h"
+
+#include "base/containers/adapters.h"
+#include "cc/quads/draw_quad.h"
+#include "cc/quads/solid_color_draw_quad.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+
+namespace cc {
+
+OverlayStrategyUnderlayCast::OverlayStrategyUnderlayCast(
+    OverlayCandidateValidator* capability_checker)
+    : OverlayStrategyUnderlay(capability_checker) {}
+
+OverlayStrategyUnderlayCast::~OverlayStrategyUnderlayCast() {}
+
+bool OverlayStrategyUnderlayCast::Attempt(
+    ResourceProvider* resource_provider,
+    RenderPass* render_pass,
+    OverlayCandidateList* candidate_list,
+    std::vector<gfx::Rect>* content_bounds) {
+  const QuadList& const_quad_list = render_pass->quad_list;
+  bool found_underlay = false;
+  gfx::Rect content_rect;
+  for (const auto* quad : base::Reversed(const_quad_list)) {
+    if (OverlayCandidate::IsInvisibleQuad(quad))
+      continue;
+
+    const auto& transform = quad->shared_quad_state->quad_to_target_transform;
+    gfx::RectF quad_rect = gfx::RectF(quad->rect);
+    transform.TransformRect(&quad_rect);
+
+    bool is_underlay = false;
+    if (!found_underlay) {
+      OverlayCandidate candidate;
+      is_underlay =
+          OverlayCandidate::FromDrawQuad(resource_provider, quad, &candidate);

[danakj, 2017/02/16 18:54:19]

How robust is it that you're redoing a subset of the logic from
OverlayStrategyUnderlay here to decide what will be the underlay, then calling
it to do the real thing? I'm looking at CheckOverlaySupport() and wondering
about the fact you're not using that here. Maybe I'm wrong and this is all okay?

Or, is there a way to call the parent class, have it process things, then
determine the content rects from the result once you have definite answer on
what will be the underlay?

[halliwell, 2017/02/23 18:01:46]

Strictly speaking, it is ok (we always return true for CheckOverlaySupport
here).  I acknowledge that does involve some assumptions (i.e. that this is used
together with OverlayCandidatesCast), which is less than ideal.
It's a bit awkward, because we need to treat solid-black quads here differently
depending on whether they occlude the overlay or not.  If we run the parent
logic first, the overlay quad gets replaced with a transparent one, and it's no
longer possible to tell that it was the overlay quad in order to recover this
ordering, I think.

One option to clean it up would be to give up on code reuse with parent class
and just put all the 'Attempt' logic directly here.  That wouldn't require any
assumptions.  WDYT?

[danakj, 2017/02/24 22:05:18]

If you reproduce the tests for it then that seems decent to me. Otherwise, some
tests and/or dchecks that verify assumptions and would go off if they were ever
violated would be good if possible. I don't have any specifically amazing
suggestions right now so LGTM and if you like any of those ideas or have another
then go for it! :)

[halliwell, 2017/02/27 22:57:13]

Yep, good point.  I added a basic DCHECK that the parent class Attempt call
agrees with the logic here on whether an underlay is found or not.

+      found_underlay |= is_underlay;

[danakj, 2017/02/16 18:54:19]

you can just use = here if you want. you know found_underlay is false.

[halliwell, 2017/02/23 18:01:46]

Done.

+    }
+
+    if (!found_underlay && quad->material == DrawQuad::SOLID_COLOR) {
+      const SolidColorDrawQuad* solid = SolidColorDrawQuad::MaterialCast(quad);
+      if (solid->color == SK_ColorBLACK)
+        continue;
+    }
+
+    if (is_underlay) {
+      content_rect.Subtract(ToEnclosedRect(quad_rect));

[danakj, 2017/02/16 18:54:19]

Do you have a test verifying the use of Enclosed/Enclosing here?

And can you write gfx::ToEnclos*Rect() with the namespace?

[halliwell, 2017/02/23 18:01:46]

Test added.
Done.

+    } else {
+      content_rect.Union(ToEnclosingRect(quad_rect));
+    }
+  }
+
+  const bool result = OverlayStrategyUnderlay::Attempt(
+      resource_provider, render_pass, candidate_list, content_bounds);
+  DCHECK(content_bounds);
+  content_bounds->clear();

[danakj, 2017/02/16 18:54:19]

I suggest DCHECK its empty instead, if you want. It'd be weird if we're passing
a non-empty list to other strategies which just leave it as is.

[halliwell, 2017/02/23 18:01:46]

Done.

+  if (found_underlay) {
+    content_bounds->push_back(content_rect);
+  }
+  return result;
+}
+
+}  // namespace cc