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..c2f96c5fc9732366cc39c3d034f7d342927f9318
--- /dev/null
+++ b/cc/surfaces/surface_hittest.cc
@@ -0,0 +1,151 @@
+// 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/render_pass_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 {
+namespace {
+const RenderPass* GetRootRenderPass(SurfaceManager* manager,
+                                    SurfaceId surface_id) {
+  Surface* surface = manager->GetSurfaceForId(surface_id);
+
+  const CompositorFrame* surface_frame = surface->GetEligibleFrame();
+  if (!surface_frame)
+    return nullptr;
+
+  const DelegatedFrameData* frame_data =
+      surface_frame->delegated_frame_data.get();
+  return frame_data->render_pass_list.empty()
+             ? nullptr
+             : frame_data->render_pass_list.back();
+}
+}
+
+SurfaceHittest::SurfaceHittest(SurfaceManager* manager) : manager_(manager) {}
+
+SurfaceHittest::~SurfaceHittest() {}
+
+SurfaceId SurfaceHittest::Hittest(SurfaceId surface_id,
+                                  const gfx::Point& point,
+                                  gfx::Point* transformed_point) {
+  SurfaceId hittest_surface_id = surface_id;
+
+  if (transformed_point)
+    *transformed_point = point;
+
+  HittestInternal(surface_id, GetRootRenderPass(manager_, surface_id), point,
+                  &hittest_surface_id, transformed_point);
+
+  referenced_passes_.clear();
+
+  return hittest_surface_id;
+}
+
+bool SurfaceHittest::HittestInternal(SurfaceId surface_id,
+                                     const RenderPass* render_pass,
+                                     const gfx::Point& point,
+                                     SurfaceId* out_surface_id,
+                                     gfx::Point* out_transformed_point) {
+  // To avoid an infinite recursion, we need to skip the RenderPass if it's
+  // already been referenced.
+  if (referenced_passes_.find(render_pass) != referenced_passes_.end())
+    return false;
+  referenced_passes_.insert(render_pass);
+
+  gfx::Transform transform_from_root_target;
+  if (!render_pass ||
+      !render_pass->transform_to_root_target.GetInverse(
+          &transform_from_root_target)) {
+    return false;
+  }
+
+  gfx::Point point_in_target_space(point);
+  transform_from_root_target.TransformPoint(&point_in_target_space);
+
+  for (const auto* quad : render_pass->quad_list) {
+    // First we test against the clip_rect. The clip_rect is in target space, so
+    // we can test the point directly.
+    if (!quad->shared_quad_state->is_clipped ||
+        quad->shared_quad_state->clip_rect.Contains(point_in_target_space)) {
+      // We now transform the point to content space and test if it hits the
+      // rect.
+      gfx::Transform target_to_quad_transform;
+      if (quad->shared_quad_state->quad_to_target_transform.GetInverse(
+              &target_to_quad_transform)) {
+        gfx::Point transformed_point(point_in_target_space);
+        target_to_quad_transform.TransformPoint(&transformed_point);
+
+        if (quad->rect.Contains(transformed_point)) {
+          if (quad->material == DrawQuad::SURFACE_CONTENT) {
+            // We've hit a SurfaceDrawQuad, we need to recurse into this
+            // Surface.
+            const SurfaceDrawQuad* surface_quad =
+                SurfaceDrawQuad::MaterialCast(quad);
+
+            gfx::Point point_in_current_surface;
+            if (out_transformed_point) {
+              point_in_current_surface = *out_transformed_point;
+              *out_transformed_point = transformed_point;
+            }
+
+            if (HittestInternal(
+                    surface_quad->surface_id,
+                    GetRootRenderPass(manager_, surface_quad->surface_id),
+                    transformed_point, out_surface_id, out_transformed_point)) {
+              return true;
+            } else {
+              if (out_transformed_point)
+                *out_transformed_point = point_in_current_surface;
+            }
+          } else if (quad->material == DrawQuad::RENDER_PASS) {
+            // We've hit a RenderPassDrawQuad, we need to recurse into this
+            // RenderPass.
+            const RenderPassDrawQuad* render_quad =
+                RenderPassDrawQuad::MaterialCast(quad);
+
+            Surface* surface = manager_->GetSurfaceForId(surface_id);
+            const CompositorFrame* surface_frame = surface->GetEligibleFrame();
+            DCHECK(surface_frame);
+            const DelegatedFrameData* frame_data =
+                surface_frame->delegated_frame_data.get();
+
+            const RenderPass* quad_render_pass = nullptr;
+            for (const auto* render_pass : frame_data->render_pass_list) {
+              if (render_pass->id == render_quad->render_pass_id) {
+                quad_render_pass = render_pass;
+                break;
+              }
+            }
+
+            if (quad_render_pass &&
+                HittestInternal(surface_id, quad_render_pass,
+                                point_in_target_space, out_surface_id,
+                                out_transformed_point)) {
+              return true;
+            }
+          } else {
+            // We've hit a different type of quad in the current Surface,
+            // there's no need to iterate anymore, this is the quad that
+            // receives the event;
+            *out_surface_id = surface_id;
+            return true;
+          }
+        }
+      }
+    }
+  }
+
+  return false;
+}
+}  // namespace cc