Mozart: Implement hit testing.

services/gfx/compositor/graph/snapshot.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/snapshot.h"
 
 #include "base/logging.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/render/render_frame.h"
+#include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkRect.h"
 
 namespace compositor {
 
 Snapshot::Snapshot() {}
 
 Snapshot::~Snapshot() {}
 
 bool Snapshot::HasDependency(const SceneDef* scene) const {
   return dependencies_.find(scene->label().token()) != dependencies_.end();
 }
 
 std::shared_ptr<RenderFrame> Snapshot::CreateFrame(
     const mojo::Rect& viewport,
     const mojo::gfx::composition::FrameInfo& frame_info) const {
   DCHECK(!is_blocked());
+  DCHECK(root_scene_content_);
 
-  SkRect sk_viewport =
-      SkRect::MakeXYWH(viewport.x, viewport.y, viewport.width, viewport.height);
+  SkRect sk_viewport = viewport.To<SkRect>();
   SkPictureRecorder recorder;
   recorder.beginRecording(sk_viewport);
-
-  const NodeDef* root_node = root_scene_content_->GetRootNodeIfExists();
-  DCHECK(root_node);  // otherwise would have failed to snapshot
-  root_node->RecordPicture(root_scene_content_.get(), this,
-                           recorder.getRecordingCanvas());
-
+  root_scene_content_->RecordPicture(this, recorder.getRecordingCanvas());
   return RenderFrame::Create(skia::AdoptRef(recorder.endRecordingAsPicture()),
                              sk_viewport, frame_info);
 }
 
+void Snapshot::HitTest(const mojo::Point& point,
+                       mojo::gfx::composition::HitTestResult* result) const {
+  DCHECK(result);
+  DCHECK(!is_blocked());
+  DCHECK(root_scene_content_);
+
+  bool opaque = false;
+  result->root = root_scene_content_->HitTest(this, point.To<SkPoint>(),
+                                              SkMatrix::I(), &opaque);
+}
+
 bool Snapshot::IsNodeBlocked(const NodeDef* node) const {
   DCHECK(!is_blocked());
 
   auto it = node_dispositions_.find(node);
   DCHECK(it != node_dispositions_.end());
   DCHECK(it->second == Disposition::kSuccess ||
          it->second == Disposition::kBlocked);
   return it->second == Disposition::kBlocked;
 }
 
@@ skipping 152 matching lines @@
 
   if (snapshot_->is_blocked()) {
     snapshot_->root_scene_content_ = nullptr;
     snapshot_->resolved_scene_contents_.clear();
     snapshot_->node_dispositions_.clear();
   }
   return std::move(snapshot_);
 }
 
 }  // namespace compositor