diff --git a/flow/BUILD.gn b/flow/BUILD.gn
index c21db2930c1373470fe10595f8df302275f9e09f..7bd885cff221fb897459901fdafc7dafdd097a1e 100644
--- a/flow/BUILD.gn
+++ b/flow/BUILD.gn
@@ -42,7 +42,8 @@ source_set("flow") {
 
   deps = [
     "//base",
-    "//skia",
     "//mojo/services/gfx/composition/interfaces",
+    "//mojo/skia",
+    "//skia",
   ]
 }
diff --git a/flow/layers/child_scene_layer.cc b/flow/layers/child_scene_layer.cc
index 5f808e59f30a27e52e175fcb7e61f6356cf01c6b..0a6db85ee04da0c03c54f4298e57de50cd7a070f 100644
--- a/flow/layers/child_scene_layer.cc
+++ b/flow/layers/child_scene_layer.cc
@@ -4,15 +4,42 @@
 
 #include "flow/layers/child_scene_layer.h"
 
+#include "mojo/skia/type_converters.h"
+
 namespace flow {
 
+// TODO(abarth): We need to figure out how to allocate these ids sensibly.
+static uint32_t next_id = 10;
+
 ChildSceneLayer::ChildSceneLayer() {
 }
 
 ChildSceneLayer::~ChildSceneLayer() {
 }
 
+void ChildSceneLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
+  transform_ = matrix;
+}
+
 void ChildSceneLayer::Paint(PaintContext::ScopedFrame& frame) {
 }
 
+void ChildSceneLayer::UpdateScene(mojo::gfx::composition::SceneUpdate* update,
+                                  mojo::gfx::composition::Node* container) {
+  uint32_t id = next_id++;
+
+  auto child_resource = mojo::gfx::composition::Resource::New();
+  child_resource->set_scene(mojo::gfx::composition::SceneResource::New());
+  child_resource->get_scene()->scene_token = scene_token_.Clone();
+  update->resources.insert(id, child_resource.Pass());
+
+  auto child_node = mojo::gfx::composition::Node::New();
+  child_node->op = mojo::gfx::composition::NodeOp::New();
+  child_node->op->set_scene(mojo::gfx::composition::SceneNodeOp::New());
+  child_node->op->get_scene()->scene_resource_id = id;
+  child_node->content_transform = mojo::Transform::From(transform_);
+  update->nodes.insert(id, child_node.Pass());
+  container->child_node_ids.push_back(id);
+}
+
 }  // namespace flow
diff --git a/flow/layers/child_scene_layer.h b/flow/layers/child_scene_layer.h
index 4f7c196cc3b33951268f12abe94af846f8d15633..3ebaa8ad95ba82f1e90c18bd67439b65e634f081 100644
--- a/flow/layers/child_scene_layer.h
+++ b/flow/layers/child_scene_layer.h
@@ -25,12 +25,16 @@ class ChildSceneLayer : public Layer {
     scene_token_ = scene_token.Pass();
   }
 
+  void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
   void Paint(PaintContext::ScopedFrame& frame) override;
+  void UpdateScene(mojo::gfx::composition::SceneUpdate* update,
+                   mojo::gfx::composition::Node* container) override;
 
  private:
   SkPoint offset_;
   SkISize physical_size_;
   mojo::gfx::composition::SceneTokenPtr scene_token_;
+  SkMatrix transform_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildSceneLayer);
 };
diff --git a/flow/layers/container_layer.cc b/flow/layers/container_layer.cc
index 533c8bebfbfac4bea0a5a4112c6cb59858a378f6..a6427ecabb98b9620f4d101278a25fc555fa85ec 100644
--- a/flow/layers/container_layer.cc
+++ b/flow/layers/container_layer.cc
@@ -37,4 +37,10 @@ void ContainerLayer::PaintChildren(PaintContext::ScopedFrame& frame) const {
     layer->Paint(frame);
 }
 
+void ContainerLayer::UpdateScene(mojo::gfx::composition::SceneUpdate* update,
+                                 mojo::gfx::composition::Node* container) {
+  for (auto& layer : layers_)
+    layer->UpdateScene(update, container);
+}
+
 }  // namespace flow
diff --git a/flow/layers/container_layer.h b/flow/layers/container_layer.h
index c5b6b588c3bfb29694e910efb3da6baeced895c2..12a6412cef07155575a4f28e0c603935dec66597 100644
--- a/flow/layers/container_layer.h
+++ b/flow/layers/container_layer.h
@@ -22,6 +22,9 @@ class ContainerLayer : public Layer {
 
   void PaintChildren(PaintContext::ScopedFrame& frame) const;
 
+  void UpdateScene(mojo::gfx::composition::SceneUpdate* update,
+                   mojo::gfx::composition::Node* container) override;
+
   const std::vector<std::unique_ptr<Layer>>& layers() const { return layers_; }
 
  private:
diff --git a/flow/layers/layer.cc b/flow/layers/layer.cc
index d4fc13e25be7e5356d6abb35ab9592e18c661128..49139525fa4582c59f05e8b551af4d25f5b886bd 100644
--- a/flow/layers/layer.cc
+++ b/flow/layers/layer.cc
@@ -20,4 +20,8 @@ Layer::~Layer() {
 void Layer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
 }
 
+void Layer::UpdateScene(mojo::gfx::composition::SceneUpdate* update,
+                        mojo::gfx::composition::Node* container) {
+}
+
 }  // namespace flow
diff --git a/flow/layers/layer.h b/flow/layers/layer.h
index 9484047974cbfaee00f3b26996effd7740de69dd..27c20e99771c73ac43fa1d3edec88fecc066e346 100644
--- a/flow/layers/layer.h
+++ b/flow/layers/layer.h
@@ -10,8 +10,9 @@
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "skia/ext/refptr.h"
 #include "flow/paint_context.h"
+#include "mojo/services/gfx/composition/interfaces/scenes.mojom.h"
+#include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
@@ -38,6 +39,9 @@ class Layer {
   virtual void Preroll(PrerollContext* context, const SkMatrix& matrix);
   virtual void Paint(PaintContext::ScopedFrame& frame) = 0;
 
+  virtual void UpdateScene(mojo::gfx::composition::SceneUpdate* update,
+                           mojo::gfx::composition::Node* container);
+
   ContainerLayer* parent() const { return parent_; }
 
   void set_parent(ContainerLayer* parent) { parent_ = parent; }
diff --git a/flow/layers/layer_tree.cc b/flow/layers/layer_tree.cc
index 20c2ff952e03a534794f470a9d8445bc24b406dd..e1fa655d25199f152f3512196e790f2439547674 100644
--- a/flow/layers/layer_tree.cc
+++ b/flow/layers/layer_tree.cc
@@ -17,15 +17,21 @@ LayerTree::~LayerTree() {
 
 void LayerTree::Raster(PaintContext::ScopedFrame& frame) {
   {
-    TRACE_EVENT0("flutter", "LayerTree::Preroll")
+    TRACE_EVENT0("flutter", "LayerTree::Preroll");
     Layer::PrerollContext context = { frame, SkRect::MakeEmpty() };
     root_layer_->Preroll(&context, SkMatrix());
   }
 
   {
-    TRACE_EVENT0("flutter", "LayerTree::Paint")
+    TRACE_EVENT0("flutter", "LayerTree::Paint");
     root_layer_->Paint(frame);
   }
 }
 
+void LayerTree::UpdateScene(mojo::gfx::composition::SceneUpdate* update,
+                            mojo::gfx::composition::Node* container) {
+  TRACE_EVENT0("flutter", "LayerTree::UpdateScene");
+  root_layer_->UpdateScene(update, container);
+}
+
 }  // namespace flow
diff --git a/flow/layers/layer_tree.h b/flow/layers/layer_tree.h
index a74f7abd031b6155159c54af174094376d79aeed..e4ecc98e0137e1c4e319cf2362286eb7b9119548 100644
--- a/flow/layers/layer_tree.h
+++ b/flow/layers/layer_tree.h
@@ -22,6 +22,12 @@ class LayerTree {
 
   void Raster(PaintContext::ScopedFrame& frame);
 
+  // TODO(abarth): Integrate scene updates with the rasterization pass so that
+  // we can draw on top of child scenes (and so that we can apply clips and
+  // blending operations to child scene).
+  void UpdateScene(mojo::gfx::composition::SceneUpdate* update,
+                   mojo::gfx::composition::Node* container);
+
   Layer* root_layer() const { return root_layer_.get(); }
 
   void set_root_layer(std::unique_ptr<Layer> root_layer) {
diff --git a/sky/shell/gpu/mojo/rasterizer_mojo.cc b/sky/shell/gpu/mojo/rasterizer_mojo.cc
index 1cfc8ae9f5da609f0548ea81ac095c65fdc7d033..0847ecb0b920813f35224035d5ba0a068473d4e2 100644
--- a/sky/shell/gpu/mojo/rasterizer_mojo.cc
+++ b/sky/shell/gpu/mojo/rasterizer_mojo.cc
@@ -84,6 +84,8 @@ void RasterizerMojo::Draw(uint64_t layer_tree_ptr,
   DCHECK(resource);
 
   auto update = mojo::gfx::composition::SceneUpdate::New();
+  update->clear_resources = true;
+  update->clear_nodes = true;
   update->resources.insert(kContentImageResourceId, resource.Pass());
   auto root_node = mojo::gfx::composition::Node::New();
   root_node->op = mojo::gfx::composition::NodeOp::New();
@@ -94,6 +96,8 @@ void RasterizerMojo::Draw(uint64_t layer_tree_ptr,
   root_node->op->get_image()->image_resource_id = kContentImageResourceId;
   update->nodes.insert(kRootNodeId, root_node.Pass());
 
+  layer_tree->UpdateScene(update.get(), root_node.get());
+
   scene_->Update(update.Pass());
   scene_->Publish(nullptr);
   callback.Run();