Mozart: Improve internal scene graph representation.

services/gfx/compositor/compositor_engine.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/compositor_engine.h"
 
 #include <algorithm>
 #include <sstream>
 #include <utility>
 
@@ skipping 246 matching lines @@
 }
 
 void CompositorEngine::HitTest(
     RendererState* renderer_state,
     mojo::PointPtr point,
     const mojo::gfx::composition::HitTester::HitTestCallback& callback) {
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
   DCHECK(point);
   DVLOG(1) << "HitTest: renderer=" << renderer_state << ", point=" << point;
 
-  mojo::gfx::composition::HitTestResultPtr result;
-  if (renderer_state->frame()) {
-    result =
-        renderer_state->frame()->HitTest(SkPoint::Make(point->x, point->y));
-  }
-  if (!result) {
-    result = mojo::gfx::composition::HitTestResult::New();
-    result->hits.resize(0u);
-  }
-
+  // TODO(jeffbrown): hit tests on scenes
+  auto result = mojo::gfx::composition::HitTestResult::New();
   callback.Run(result.Pass());
 }
 
-SceneDef* CompositorEngine::ResolveSceneReference(
-    mojo::gfx::composition::SceneToken* scene_token) {
-  SceneState* scene_state = FindScene(scene_token->value);
-  return scene_state ? scene_state->scene_def() : nullptr;
+base::WeakPtr<SceneDef> CompositorEngine::ResolveSceneReference(
+    const mojo::gfx::composition::SceneToken& scene_token) {
+  SceneState* scene_state = FindScene(scene_token.value);
+  return scene_state ? scene_state->scene_def()->GetWeakPtr()
+                     : base::WeakPtr<SceneDef>();
 }
 
 void CompositorEngine::SendResourceUnavailable(SceneState* scene_state,
                                                uint32_t resource_id) {
   DCHECK(IsSceneStateRegisteredDebug(scene_state));
   DVLOG(2) << "SendResourceUnavailable: resource_id=" << resource_id;
 
   // TODO: Detect ANRs
   if (scene_state->scene_listener()) {
     scene_state->scene_listener()->OnResourceUnavailable(
@@ skipping 60 matching lines @@
 
 void CompositorEngine::SnapshotRenderer(
     RendererState* renderer_state,
     const mojo::gfx::composition::FrameInfo& frame_info) {
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
   DVLOG(2) << "SnapshotRenderer: renderer_state=" << renderer_state;
 
   if (VLOG_IS_ON(2)) {
     std::ostringstream block_log;
     SnapshotRendererInner(renderer_state, frame_info, &block_log);
-    if (!renderer_state->valid()) {
+    if (!renderer_state->frame()) {
       DVLOG(2) << "Rendering completely blocked: " << block_log.str();
     } else if (!block_log.str().empty()) {
       DVLOG(2) << "Rendering partially blocked: " << block_log.str();
     } else {
       DVLOG(2) << "Rendering unblocked";
     }
   } else {
     SnapshotRendererInner(renderer_state, frame_info, nullptr);
   }
 }
 
 void CompositorEngine::SnapshotRendererInner(
     RendererState* renderer_state,
     const mojo::gfx::composition::FrameInfo& frame_info,
     std::ostream* block_log) {
   if (!renderer_state->root_scene()) {
     if (block_log)
       *block_log << "No root scene" << std::endl;
     renderer_state->SetSnapshot(nullptr);
     return;
   }
 
   SnapshotBuilder builder(block_log);
   renderer_state->SetSnapshot(
       builder.Build(renderer_state->root_scene()->scene_def(),
                     renderer_state->root_scene_viewport(), frame_info));
 
-  if (renderer_state->valid())
+  if (renderer_state->frame())
     renderer_state->output()->SubmitFrame(renderer_state->frame());
 }
 
 void CompositorEngine::ScheduleFrameForRenderer(
     RendererState* renderer_state,
     Scheduler::SchedulingMode scheduling_mode) {
   DCHECK(IsRendererStateRegisteredDebug(renderer_state));
   renderer_state->output()->GetScheduler()->ScheduleFrame(scheduling_mode);
 }
 
@@ skipping 47 matching lines @@
 
   SceneDef::Disposition disposition =
       PresentScene(scene_state, presentation_time);
   if (disposition == SceneDef::Disposition::kFailed)
     DestroyScene(scene_state);
   else if (disposition == SceneDef::Disposition::kSucceeded)
     InvalidateScene(scene_state);
 }
 
 }  // namespace compositor