Adds support for hittesting points on surface quads

cc/surfaces/surface_hittest.cc

Index: cc/surfaces/surface_hittest.cc
diff --git a/cc/surfaces/surface_hittest.cc b/cc/surfaces/surface_hittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..04d8f987d30c590b4c99cbe71ef5f704be9108a1
--- /dev/null
+++ b/cc/surfaces/surface_hittest.cc
@@ -0,0 +1,56 @@
+// Copyright 2015 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/surfaces/surface_hittest.h"
+
+#include "cc/output/compositor_frame.h"
+#include "cc/output/delegated_frame_data.h"
+#include "cc/quads/draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
+#include "cc/surfaces/surface.h"
+#include "cc/surfaces/surface_manager.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/transform.h"
+
+namespace cc {
+SurfaceHittest::SurfaceHittest(SurfaceManager* manager) : manager_(manager) {}
+
+SurfaceHittest::~SurfaceHittest() {}
+
+SurfaceId SurfaceHittest::Hittest(SurfaceId surface_id,
+                                  const gfx::Point& point) {
+  Surface* surface = manager_->GetSurfaceForId(surface_id);
+
+  const CompositorFrame* surface_frame = surface->GetEligibleFrame();

[jbauman, 2015/07/31 22:00:28]

To avoid infinite recursion, this should check that it's not already being
called on the current surface higher in the callstack (see referenced_surfaces_
in SurfaceAggregator).

[lfg, 2015/08/04 21:21:42]

Done.

+  if (!surface_frame)
+    return surface_id;
+  const DelegatedFrameData* frame_data =
+      surface_frame->delegated_frame_data.get();
+
+  for (const auto& render_pass : frame_data->render_pass_list) {

[jbauman, 2015/07/31 22:00:28]

It would probably be best to look at the root pass (last pass), and look at
other passes only if the point hits a RenderPassDrawQuad that references them.

[lfg, 2015/08/04 21:21:42]

Done.

+    for (const auto& quad : render_pass->quad_list) {

[jbauman, 2015/07/31 22:00:28]

This should go from the end of the list to the beginning to handle overlapping
surfaces - it should also stop if any quad contains the point.

[lfg, 2015/08/04 21:21:42]

This is the only point I'm not sure about. For rendering, yes, we want to go
from end to beginning. But for hittesting, I actually want to go from front to
back in quads, so that the quads that are drawn later are the first ones tested
for input.

The code here
https://code.google.com/p/chromium/codesearch#chromium/src/cc/quads/render_pa...
shows that the reverse iterator is used for back to front for quads, so isn't
the order I'm iterating the correct one?

+      if (quad->material == DrawQuad::SURFACE_CONTENT) {
+        const SurfaceDrawQuad* surface_quad =
+            SurfaceDrawQuad::MaterialCast(quad);
+        gfx::Transform root_to_surface_transform;
+        if (gfx::Transform(
+                render_pass->transform_to_root_target,
+                surface_quad->shared_quad_state->quad_to_target_transform)
+                .GetInverse(&root_to_surface_transform)) {
+          gfx::Point transformed_point(point);
+          root_to_surface_transform.TransformPoint(&transformed_point);
+
+          if (transformed_point.x() > 0 && transformed_point.y() > 0 &&
+              transformed_point.x() < surface_quad->rect.width() &&
+              transformed_point.y() < surface_quad->rect.height()) {

[jbauman, 2015/07/31 22:00:28]

Should check clip rect as well.

[lfg, 2015/08/04 21:21:42]

I've added the check to clip rect, but I'm wondering if the check to rect is not
necessary. Is it true that all visible_rects are contained inside their rects?

+            return Hittest(surface_quad->surface_id, transformed_point);
+          }
+        }
+      }
+    }
+  }
+
+  return surface_id;
+}
+}  // namespace cc