ozone: Add overlay candidate implementation that queries support via IPC

ui/ozone/platform/drm/host/drm_overlay_candidates_host.cc

+#include "ui/ozone/platform/drm/host/drm_overlay_candidates_host.h"
+
+#include <algorithm>
+
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/ozone/common/gpu/ozone_gpu_messages.h"
+#include "ui/ozone/platform/drm/host/drm_gpu_platform_support_host.h"
+
+namespace ui {
+
+namespace {
+const size_t kMaxCacheSize = 10000;

[spang, 2015/06/01 23:23:51]

How likely do we expect a config to be reused >>10,000 frames later?

[achaulk, 2015/06/02 14:37:43]

Well it depends. The answers are generally considered to be constant forever,
but since we have a (screen rect, buffer size, format) tuple to key off of,
scrolling + zooming + adaptive video size could easily add a few hundred to
thousand entries pretty quickly and if we left it unbounded it could eat up
memory, and if we make it too small we will clear it too often

5-10k seems like a good compromise range where it still won't take too much
memory and won't need to be re-queried too often

[spang, 2015/06/02 17:14:34]

Yeah, the space of configurations is very large. So I'm wondering if a cache of
10000 entries actually has a enough higher hit rate than a cache of 100 entries
to justify the increased memory cost. If 100x larger cache has a negligible
effect on the hit rate, we shouldn't do it.

I think "clearing too often" being a worry is just a sign that clearing the
cache isn't a very good eviction policy. Maybe look into base::MRUCache.

Can we make it small for now and increase the size once we have justification
for it?

[achaulk, 2015/06/02 19:38:38]

Done.

+}  // namespace
+
+bool DrmOverlayCandidatesHost::OverlayCompare::operator()(
+    const OverlayCheck_Params& l,
+    const OverlayCheck_Params& r) {
+  return l.plane_z_order < r.plane_z_order ||

[spang, 2015/06/01 23:23:51]

Can you split this into multiple statements?

[achaulk, 2015/06/02 19:38:38]

Done.

+         (l.plane_z_order == r.plane_z_order &&
+          (l.display_rect < r.display_rect ||
+           (l.display_rect == r.display_rect &&
+            (l.format < r.format ||
+             (l.format == r.format &&
+              (l.transform < r.transform ||
+               (l.transform == r.transform &&
+                (l.buffer_size.width() < r.buffer_size.width() ||
+                 (l.buffer_size.width() == r.buffer_size.width() &&
+                  l.buffer_size.height() < r.buffer_size.height())))))))));
+}
+
+DrmOverlayCandidatesHost::DrmOverlayCandidatesHost(
+    gfx::AcceleratedWidget widget,
+    DrmGpuPlatformSupportHost* platform_support)
+    : widget_(widget), platform_support_(platform_support) {
+  platform_support_->RegisterHandler(this);
+}
+
+DrmOverlayCandidatesHost::~DrmOverlayCandidatesHost() {
+  platform_support_->UnregisterHandler(this);
+}
+
+void DrmOverlayCandidatesHost::CheckOverlaySupport(
+    OverlaySurfaceCandidateList* candidates) {
+  if (candidates->size() == 2)
+    CheckSingleOverlay(candidates);
+}
+
+void DrmOverlayCandidatesHost::CheckSingleOverlay(
+    OverlaySurfaceCandidateList* candidates) {
+  OverlayCandidatesOzone::OverlaySurfaceCandidate* first = &(*candidates)[0];
+  OverlayCandidatesOzone::OverlaySurfaceCandidate* second = &(*candidates)[1];
+  OverlayCandidatesOzone::OverlaySurfaceCandidate* overlay;
+  if (first->plane_z_order == 0) {
+    overlay = second;
+  } else if (second->plane_z_order == 0) {
+    overlay = first;
+  } else {
+    return;
+  }
+  // 0.01 constant chosen to match DCHECKs in gfx::ToNearestRect and avoid
+  // that code asserting on quads that we accept.
+  if (!gfx::IsNearestRectWithinDistance(overlay->display_rect, 0.01f))
+    return;
+  if (overlay->transform == gfx::OVERLAY_TRANSFORM_INVALID)
+    return;
+
+  OverlayCheck_Params lookup(*overlay);
+  auto iter = cache_.find(lookup);
+  if (iter == cache_.end()) {
+    if (cache_.size() > kMaxCacheSize)
+      cache_.clear();
+    cache_[lookup] = false;
+    SendRequest(*candidates, lookup);
+  } else {
+    overlay->overlay_handled = iter->second;
+  }
+}
+
+void DrmOverlayCandidatesHost::OnChannelEstablished(
+    int host_id,
+    scoped_refptr<base::SingleThreadTaskRunner> send_runner,
+    const base::Callback<void(IPC::Message*)>& sender) {
+}
+
+void DrmOverlayCandidatesHost::OnChannelDestroyed(int host_id) {
+}
+
+bool DrmOverlayCandidatesHost::OnMessageReceived(const IPC::Message& message) {
+  bool handled = false;
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(DrmOverlayCandidatesHost, message, &handled)
+  IPC_MESSAGE_FORWARD(OzoneHostMsg_OverlayCapabilitiesReceived, this,
+                      DrmOverlayCandidatesHost::OnOverlayResult)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void DrmOverlayCandidatesHost::SendRequest(
+    const OverlaySurfaceCandidateList& candidates,
+    const OverlayCheck_Params& check) {
+  if (!platform_support_->IsConnected())
+    return;
+  pending_checks_.push_back(check);
+  std::vector<OverlayCheck_Params> list;
+  for (const auto& candidate : candidates)
+    list.push_back(OverlayCheck_Params(candidate));
+  platform_support_->Send(
+      new OzoneGpuMsg_CheckOverlayCapabilities(widget_, list));
+}
+
+void DrmOverlayCandidatesHost::OnOverlayResult(bool* handled,
+                                               gfx::AcceleratedWidget widget,
+                                               bool result) {
+  if (widget != widget_)
+    return;
+  *handled = true;
+  DCHECK(!pending_checks_.empty());
+  ProcessResult(pending_checks_.front(), result);
+  pending_checks_.pop_front();
+}
+
+void DrmOverlayCandidatesHost::ProcessResult(const OverlayCheck_Params& check,
+                                             bool result) {
+  if (result)
+    cache_[check] = true;

[spang, 2015/06/01 23:23:51]

Should we also cache negative results?

[achaulk, 2015/06/02 14:37:43]

Everything defaults to negative when it's added, so there's no need to update
anything in that case

[spang, 2015/06/02 17:14:34]

Ah I see it now, thanks.

+}
+
+}  // namespace ui