Mozart: Implement hit testing.

services/gfx/compositor/graph/node_def.cc

 // 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 "services/gfx/compositor/graph/node_def.h"
 
 #include <ostream>
 
 #include "base/logging.h"
 #include "mojo/services/gfx/composition/cpp/formatting.h"
 #include "mojo/skia/type_converters.h"
 #include "services/gfx/compositor/graph/scene_content.h"
 #include "services/gfx/compositor/graph/scene_def.h"
 #include "services/gfx/compositor/graph/snapshot.h"
 #include "services/gfx/compositor/render/render_image.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/core/SkPoint.h"
 #include "third_party/skia/include/core/SkRect.h"
 
 namespace compositor {
 namespace {
 SkColor MakeSkColor(const mojo::gfx::composition::Color& color) {
   return SkColorSetARGBInline(color.alpha, color.red, color.green, color.blue);
 }
 
 void SetPaintForBlend(SkPaint* paint, mojo::gfx::composition::Blend* blend) {
   DCHECK(paint);
   if (blend)
     paint->setAlpha(blend->alpha);
 }
+
+bool Contains(const SkRect& bounds, const SkPoint& point) {
+  return point.x() >= bounds.left() && point.x() < bounds.right() &&
+         point.y() >= bounds.top() && point.y() < bounds.bottom();
+}
 }  // namespace
 
 NodeDef::NodeDef(uint32_t node_id,
                  mojo::TransformPtr content_transform,
                  mojo::RectPtr content_clip,
+                 mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
                  Combinator combinator,
                  const std::vector<uint32_t>& child_node_ids)
     : node_id_(node_id),
       content_transform_(content_transform.Pass()),
       content_clip_(content_clip.Pass()),
+      hit_test_behavior_(hit_test_behavior.Pass()),
       combinator_(combinator),
       child_node_ids_(child_node_ids) {}
 
 NodeDef::~NodeDef() {}
 
 std::string NodeDef::FormattedLabel(const SceneContent* content) const {
   return content->FormattedLabelForNode(node_id_);
 }
 
 bool NodeDef::RecordContent(SceneContentBuilder* builder) const {
@@ skipping 163 matching lines @@
   DCHECK(canvas);
 
   TraverseSnapshottedChildren(
       content, snapshot,
       [this, content, snapshot, canvas](const NodeDef* child_node) -> bool {
         child_node->RecordPicture(content, snapshot, canvas);
         return true;
       });
 }
 
-RectNodeDef::RectNodeDef(uint32_t node_id,
-                         mojo::TransformPtr content_transform,
-                         mojo::RectPtr content_clip,
-                         Combinator combinator,
-                         const std::vector<uint32_t>& child_node_ids,
-                         const mojo::Rect& content_rect,
-                         const mojo::gfx::composition::Color& color)
+bool NodeDef::HitTest(const SceneContent* content,
+                      const Snapshot* snapshot,
+                      const SkPoint& parent_point,
+                      const SkMatrix& global_to_parent_transform,
+                      mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
+  DCHECK(content);
+  DCHECK(snapshot);
+  DCHECK(hits);
+
+  // TODO(jeffbrown): These calculations should probably be happening using
+  // a 4x4 matrix instead.
+  SkPoint local_point = parent_point;
+  SkMatrix global_to_local_transform = global_to_parent_transform;
+  if (content_transform_) {
+    // TODO(jeffbrown): Cache the inverse transform.
+    // Defer matrix multiplications using a matrix stack.
+    SkMatrix inverse_transform;
+    if (!content_transform_.To<SkMatrix>().invert(&inverse_transform)) {
+      // Matrix is singular!
+      // Return [0,0,0][0,0,0][0,0,1] (all zeroes except last component).
+      // This causes all points to be mapped to (0,0) when transformed.
+      inverse_transform.setScale(0.f, 0.f);
+    }
+    inverse_transform.mapXY(parent_point.x(), parent_point.y(), &local_point);
+    global_to_local_transform.preConcat(inverse_transform);
+  }
+
+  if (content_clip_ && !Contains(content_clip_->To<SkRect>(), local_point))
+    return false;
+
+  bool opaque_children = false;
+  if (!hit_test_behavior_ || !hit_test_behavior_->prune) {
+    opaque_children = HitTestInner(content, snapshot, local_point,
+                                   global_to_local_transform, hits);
+  }
+
+  return HitTestSelf(content, snapshot, local_point, global_to_local_transform,
+                     hits) ||
+         opaque_children;
+}
+
+bool NodeDef::HitTestInner(
+    const SceneContent* content,
+    const Snapshot* snapshot,
+    const SkPoint& local_point,
+    const SkMatrix& global_to_local_transform,
+    mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
+  DCHECK(content);
+  DCHECK(snapshot);
+  DCHECK(hits);
+
+  // TODO(jeffbrown): Implement a more efficient way to traverse children in
+  // reverse order.
+  std::vector<const NodeDef*> children;
+  TraverseSnapshottedChildren(
+      content, snapshot, [this, &children](const NodeDef* child_node) -> bool {
+        children.push_back(child_node);
+        return true;
+      });
+
+  for (auto it = children.crbegin(); it != children.crend(); ++it) {
+    if ((*it)->HitTest(content, snapshot, local_point,
+                       global_to_local_transform, hits))
+      return true;  // opaque child covering siblings
+  }
+  return false;
+}
+
+bool NodeDef::HitTestSelf(
+    const SceneContent* content,
+    const Snapshot* snapshot,
+    const SkPoint& local_point,
+    const SkMatrix& global_to_local_transform,
+    mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
+  DCHECK(content);
+  DCHECK(snapshot);
+  DCHECK(hits);
+
+  if (!hit_test_behavior_ ||
+      hit_test_behavior_->visibility ==
+          mojo::gfx::composition::HitTestBehavior::Visibility::INVISIBLE)
+    return false;
+
+  if (hit_test_behavior_->hit_rect &&
+      !Contains(hit_test_behavior_->hit_rect->To<SkRect>(), local_point))
+    return false;
+
+  auto hit = mojo::gfx::composition::Hit::New();
+  hit->set_node(mojo::gfx::composition::NodeHit::New());
+  hit->get_node()->node_id = node_id_;
+  hit->get_node()->transform =
+      mojo::ConvertTo<mojo::TransformPtr>(global_to_local_transform);
+  hits->push_back(hit.Pass());
+  return hit_test_behavior_->visibility ==
+         mojo::gfx::composition::HitTestBehavior::Visibility::OPAQUE;
+}
+
+RectNodeDef::RectNodeDef(
+    uint32_t node_id,
+    mojo::TransformPtr content_transform,
+    mojo::RectPtr content_clip,
+    mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
+    Combinator combinator,
+    const std::vector<uint32_t>& child_node_ids,
+    const mojo::Rect& content_rect,
+    const mojo::gfx::composition::Color& color)
     : NodeDef(node_id,
               content_transform.Pass(),
               content_clip.Pass(),
+              hit_test_behavior.Pass(),
               combinator,
               child_node_ids),
       content_rect_(content_rect),
       color_(color) {}
 
 RectNodeDef::~RectNodeDef() {}
 
 void RectNodeDef::RecordPictureInner(const SceneContent* content,
                                      const Snapshot* snapshot,
                                      SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   SkPaint paint;
   paint.setColor(MakeSkColor(color_));
   canvas->drawRect(content_rect_.To<SkRect>(), paint);
 
   NodeDef::RecordPictureInner(content, snapshot, canvas);
 }
 
-ImageNodeDef::ImageNodeDef(uint32_t node_id,
-                           mojo::TransformPtr content_transform,
-                           mojo::RectPtr content_clip,
-                           Combinator combinator,
-                           const std::vector<uint32_t>& child_node_ids,
-                           const mojo::Rect& content_rect,
-                           mojo::RectPtr image_rect,
-                           uint32 image_resource_id,
-                           mojo::gfx::composition::BlendPtr blend)
+ImageNodeDef::ImageNodeDef(
+    uint32_t node_id,
+    mojo::TransformPtr content_transform,
+    mojo::RectPtr content_clip,
+    mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
+    Combinator combinator,
+    const std::vector<uint32_t>& child_node_ids,
+    const mojo::Rect& content_rect,
+    mojo::RectPtr image_rect,
+    uint32 image_resource_id,
+    mojo::gfx::composition::BlendPtr blend)
     : NodeDef(node_id,
               content_transform.Pass(),
               content_clip.Pass(),
+              hit_test_behavior.Pass(),
               combinator,
               child_node_ids),
       content_rect_(content_rect),
       image_rect_(image_rect.Pass()),
       image_resource_id_(image_resource_id),
       blend_(blend.Pass()) {}
 
 ImageNodeDef::~ImageNodeDef() {}
 
 bool ImageNodeDef::RecordContent(SceneContentBuilder* builder) const {
@@ skipping 21 matching lines @@
   canvas->drawImageRect(image_resource->image()->image().get(),
                         image_rect_
                             ? image_rect_->To<SkRect>()
                             : SkRect::MakeWH(image_resource->image()->width(),
                                              image_resource->image()->height()),
                         content_rect_.To<SkRect>(), &paint);
 
   NodeDef::RecordPictureInner(content, snapshot, canvas);
 }
 
-SceneNodeDef::SceneNodeDef(uint32_t node_id,
-                           mojo::TransformPtr content_transform,
-                           mojo::RectPtr content_clip,
-                           Combinator combinator,
-                           const std::vector<uint32_t>& child_node_ids,
-                           uint32_t scene_resource_id,
-                           uint32_t scene_version)
+SceneNodeDef::SceneNodeDef(
+    uint32_t node_id,
+    mojo::TransformPtr content_transform,
+    mojo::RectPtr content_clip,
+    mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
+    Combinator combinator,
+    const std::vector<uint32_t>& child_node_ids,
+    uint32_t scene_resource_id,
+    uint32_t scene_version)
     : NodeDef(node_id,
               content_transform.Pass(),
               content_clip.Pass(),
+              hit_test_behavior.Pass(),
               combinator,
               child_node_ids),
       scene_resource_id_(scene_resource_id),
       scene_version_(scene_version) {}
 
 SceneNodeDef::~SceneNodeDef() {}
 
 bool SceneNodeDef::RecordContent(SceneContentBuilder* builder) const {
   DCHECK(builder);
 
@@ skipping 32 matching lines @@
 void SceneNodeDef::RecordPictureInner(const SceneContent* content,
                                       const Snapshot* snapshot,
                                       SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   const SceneContent* resolved_content =
       snapshot->GetResolvedSceneContent(this);
   DCHECK(resolved_content);
+  resolved_content->RecordPicture(snapshot, canvas);
+
+  NodeDef::RecordPictureInner(content, snapshot, canvas);
+}
+
+bool SceneNodeDef::HitTestInner(
+    const SceneContent* content,
+    const Snapshot* snapshot,
+    const SkPoint& local_point,
+    const SkMatrix& global_to_local_transform,
+    mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
+  DCHECK(content);
+  DCHECK(snapshot);
+  DCHECK(hits);
+
+  if (NodeDef::HitTestInner(content, snapshot, local_point,
+                            global_to_local_transform, hits))
+    return true;  // opaque child covering referenced scene
+
+  const SceneContent* resolved_content =
+      snapshot->GetResolvedSceneContent(this);
+  DCHECK(resolved_content);
 
-  const NodeDef* root_node = resolved_content->GetRootNodeIfExists();
-  DCHECK(root_node);  // must have a root otherwise would have been blocked
-  root_node->RecordPicture(resolved_content, snapshot, canvas);
-
-  NodeDef::RecordPictureInner(content, snapshot, canvas);
+  mojo::gfx::composition::SceneHitPtr scene_hit;
+  bool opaque = resolved_content->HitTest(
+      snapshot, local_point, global_to_local_transform, &scene_hit);
+  if (scene_hit) {
+    auto hit = mojo::gfx::composition::Hit::New();
+    hit->set_scene(scene_hit.Pass());
+    hits->push_back(hit.Pass());
+  }
+  return opaque;
 }
 
-LayerNodeDef::LayerNodeDef(uint32_t node_id,
-                           mojo::TransformPtr content_transform,
-                           mojo::RectPtr content_clip,
-                           Combinator combinator,
-                           const std::vector<uint32_t>& child_node_ids,
-                           const mojo::Size& size,
-                           mojo::gfx::composition::BlendPtr blend)
+LayerNodeDef::LayerNodeDef(
+    uint32_t node_id,
+    mojo::TransformPtr content_transform,
+    mojo::RectPtr content_clip,
+    mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
+    Combinator combinator,
+    const std::vector<uint32_t>& child_node_ids,
+    const mojo::Size& size,
+    mojo::gfx::composition::BlendPtr blend)
     : NodeDef(node_id,
               content_transform.Pass(),
               content_clip.Pass(),
+              hit_test_behavior.Pass(),
               combinator,
               child_node_ids),
       size_(size),
       blend_(blend.Pass()) {}
 
 LayerNodeDef::~LayerNodeDef() {}
 
 void LayerNodeDef::RecordPictureInner(const SceneContent* content,
                                       const Snapshot* snapshot,
                                       SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   SkPaint paint;
   SetPaintForBlend(&paint, blend_.get());
 
   canvas->saveLayer(SkRect::MakeWH(size_.width, size_.height), &paint);
   NodeDef::RecordPictureInner(content, snapshot, canvas);
   canvas->restore();
 }
 
 }  // namespace compositor