diff --git a/bin/ui/BUILD.gn b/bin/ui/BUILD.gn
index 9db7743..da72969 100644
--- a/bin/ui/BUILD.gn
+++ b/bin/ui/BUILD.gn
@@ -76,6 +76,10 @@
       dest = "input_unittests.cmx"
     },
     {
+      path = rebase_path("meta/scenic_unittests.cmx")
+      dest = "scenic_unittests.cmx"
+    },
+    {
       path = rebase_path("meta/view_manager_apptests.cmx")
       dest = "view_manager_apptests.cmx"
     },
diff --git a/bin/ui/meta/scenic_unittests.cmx b/bin/ui/meta/scenic_unittests.cmx
new file mode 100644
index 0000000..30a58aa
--- /dev/null
+++ b/bin/ui/meta/scenic_unittests.cmx
@@ -0,0 +1,11 @@
+{
+    "program": {
+        "binary": "test/scenic_unittests"
+    },
+    "sandbox": {
+        "features": [ "vulkan" ],
+        "services": [
+            "fuchsia.vulkan.loader.Loader"
+        ]
+    }
+}
diff --git a/lib/ui/gfx/BUILD.gn b/lib/ui/gfx/BUILD.gn
index 24cc45e..afb865d 100644
--- a/lib/ui/gfx/BUILD.gn
+++ b/lib/ui/gfx/BUILD.gn
@@ -75,6 +75,8 @@
     "engine/frame_scheduler.h",
     "engine/frame_timings.cc",
     "engine/frame_timings.h",
+    "engine/gfx_command_applier.cc",
+    "engine/gfx_command_applier.h",
     "engine/hardware_layer_assignment.cc",
     "engine/hardware_layer_assignment.h",
     "engine/hit.h",
diff --git a/lib/ui/gfx/engine/gfx_command_applier.cc b/lib/ui/gfx/engine/gfx_command_applier.cc
new file mode 100644
index 0000000..fb13818
--- /dev/null
+++ b/lib/ui/gfx/engine/gfx_command_applier.cc
@@ -0,0 +1,1530 @@
+// Copyright 2019 The Fuchsia 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 "garnet/lib/ui/gfx/engine/gfx_command_applier.h"
+
+#include <lib/async/default.h>
+#include <trace/event.h>
+
+#include "garnet/lib/ui/gfx/engine/resource_linker.h"
+#include "garnet/lib/ui/gfx/resources/buffer.h"
+#include "garnet/lib/ui/gfx/resources/camera.h"
+#include "garnet/lib/ui/gfx/resources/compositor/display_compositor.h"
+#include "garnet/lib/ui/gfx/resources/compositor/layer.h"
+#include "garnet/lib/ui/gfx/resources/compositor/layer_stack.h"
+#include "garnet/lib/ui/gfx/resources/image.h"
+#include "garnet/lib/ui/gfx/resources/image_pipe.h"
+#include "garnet/lib/ui/gfx/resources/image_pipe_handler.h"
+#include "garnet/lib/ui/gfx/resources/lights/ambient_light.h"
+#include "garnet/lib/ui/gfx/resources/lights/directional_light.h"
+#include "garnet/lib/ui/gfx/resources/memory.h"
+#include "garnet/lib/ui/gfx/resources/nodes/entity_node.h"
+#include "garnet/lib/ui/gfx/resources/nodes/node.h"
+#include "garnet/lib/ui/gfx/resources/nodes/opacity_node.h"
+#include "garnet/lib/ui/gfx/resources/nodes/scene.h"
+#include "garnet/lib/ui/gfx/resources/nodes/shape_node.h"
+#include "garnet/lib/ui/gfx/resources/renderers/renderer.h"
+#include "garnet/lib/ui/gfx/resources/shapes/circle_shape.h"
+#include "garnet/lib/ui/gfx/resources/shapes/mesh_shape.h"
+#include "garnet/lib/ui/gfx/resources/shapes/rectangle_shape.h"
+#include "garnet/lib/ui/gfx/resources/shapes/rounded_rectangle_shape.h"
+#include "garnet/lib/ui/gfx/resources/snapshot/snapshotter.h"
+#include "garnet/lib/ui/gfx/resources/stereo_camera.h"
+#include "garnet/lib/ui/gfx/resources/variable.h"
+#include "garnet/lib/ui/gfx/resources/view.h"
+#include "garnet/lib/ui/gfx/resources/view_holder.h"
+
+#include "garnet/lib/ui/gfx/engine/hit_tester.h"
+#include "garnet/lib/ui/gfx/engine/session_handler.h"
+#include "garnet/lib/ui/gfx/swapchain/swapchain_factory.h"
+#include "garnet/lib/ui/gfx/util/time.h"
+#include "garnet/lib/ui/gfx/util/unwrap.h"
+#include "garnet/lib/ui/gfx/util/wrap.h"
+#include "garnet/lib/ui/scenic/util/print_command.h"
+#include "lib/escher/hmd/pose_buffer.h"
+#include "lib/escher/renderer/batch_gpu_uploader.h"
+#include "lib/escher/shape/mesh.h"
+#include "lib/escher/shape/rounded_rect_factory.h"
+#include "lib/escher/util/type_utils.h"
+
+namespace scenic_impl {
+namespace gfx {
+
+namespace {
+
+// Makes it convenient to check that a value is constant and of a specific type,
+// or a variable.
+// TODO: There should also be a convenient way of type-checking a variable;
+// this will necessarily involve looking up the value in the ResourceMap.
+constexpr std::array<fuchsia::ui::gfx::Value::Tag, 2> kFloatValueTypes{
+    {fuchsia::ui::gfx::Value::Tag::kVector1,
+     fuchsia::ui::gfx::Value::Tag::kVariableId}};
+
+}  // anonymous namespace
+
+bool GfxCommandApplier::AssertValueIsOfType(
+    const fuchsia::ui::gfx::Value& value,
+    const fuchsia::ui::gfx::Value::Tag* tags, size_t tag_count,
+    Session* session) {
+  using ::operator<<;  // From print_commands.h
+  FXL_DCHECK(tag_count > 0);
+  for (size_t i = 0; i < tag_count; ++i) {
+    if (value.Which() == tags[i]) {
+      return true;
+    }
+  }
+  std::ostringstream str;
+  if (tag_count == 1) {
+    str << ", which is not the expected type: " << tags[0] << ".";
+  } else {
+    str << ", which is not one of the expected types (" << tags[0];
+    for (size_t i = 1; i < tag_count; ++i) {
+      str << ", " << tags[i];
+    }
+    str << ").";
+  }
+  session->error_reporter()->ERROR()
+      << "scenic_impl::gfx::Session: received value of type: " << value.Which()
+      << str.str();
+  return false;
+}
+
+bool GfxCommandApplier::ApplyCommand(Session* session,
+                                     CommandContext* command_context,
+                                     fuchsia::ui::gfx::Command command) {
+  TRACE_DURATION("gfx", "GfxCommandApplier::ApplyCommand");
+
+  switch (command.Which()) {
+    case fuchsia::ui::gfx::Command::Tag::kCreateResource:
+      return ApplyCreateResourceCmd(session, command_context,
+                                    std::move(command.create_resource()));
+    case fuchsia::ui::gfx::Command::Tag::kReleaseResource:
+      return ApplyReleaseResourceCmd(session,
+                                     std::move(command.release_resource()));
+    case fuchsia::ui::gfx::Command::Tag::kExportResource:
+      return ApplyExportResourceCmd(session,
+                                    std::move(command.export_resource()));
+    case fuchsia::ui::gfx::Command::Tag::kImportResource:
+      return ApplyImportResourceCmd(session,
+                                    std::move(command.import_resource()));
+    case fuchsia::ui::gfx::Command::Tag::kSetImportFocus: {
+      // TODO(SCN-1026): Remove this.
+      if (auto import = session->resources()->FindResource<Import>(
+              command.set_import_focus().id,
+              ResourceMap::ErrorBehavior::kDontReportErrors)) {
+        import->set_focusable(command.set_import_focus().focusable);
+        return true;
+      }
+      return false;
+    }
+    case fuchsia::ui::gfx::Command::Tag::kAddChild:
+      return ApplyAddChildCmd(session, std::move(command.add_child()));
+    case fuchsia::ui::gfx::Command::Tag::kAddPart:
+      return ApplyAddPartCmd(session, std::move(command.add_part()));
+    case fuchsia::ui::gfx::Command::Tag::kDetach:
+      return ApplyDetachCmd(session, std::move(command.detach()));
+    case fuchsia::ui::gfx::Command::Tag::kDetachChildren:
+      return ApplyDetachChildrenCmd(session,
+                                    std::move(command.detach_children()));
+    case fuchsia::ui::gfx::Command::Tag::kSetTag:
+      return ApplySetTagCmd(session, std::move(command.set_tag()));
+    case fuchsia::ui::gfx::Command::Tag::kSetTranslation:
+      return ApplySetTranslationCmd(session,
+                                    std::move(command.set_translation()));
+    case fuchsia::ui::gfx::Command::Tag::kSetScale:
+      return ApplySetScaleCmd(session, std::move(command.set_scale()));
+    case fuchsia::ui::gfx::Command::Tag::kSetRotation:
+      return ApplySetRotationCmd(session, std::move(command.set_rotation()));
+    case fuchsia::ui::gfx::Command::Tag::kSetAnchor:
+      return ApplySetAnchorCmd(session, std::move(command.set_anchor()));
+    case fuchsia::ui::gfx::Command::Tag::kSetSize:
+      return ApplySetSizeCmd(session, std::move(command.set_size()));
+    case fuchsia::ui::gfx::Command::Tag::kSetOpacity:
+      return ApplySetOpacityCmd(session, command.set_opacity());
+    case fuchsia::ui::gfx::Command::Tag::kSendSizeChangeHintHack:
+      return ApplySendSizeChangeHintCmd(session,
+                                        command.send_size_change_hint_hack());
+    case fuchsia::ui::gfx::Command::Tag::kSetShape:
+      return ApplySetShapeCmd(session, std::move(command.set_shape()));
+    case fuchsia::ui::gfx::Command::Tag::kSetMaterial:
+      return ApplySetMaterialCmd(session, std::move(command.set_material()));
+    case fuchsia::ui::gfx::Command::Tag::kSetClip:
+      return ApplySetClipCmd(session, std::move(command.set_clip()));
+    case fuchsia::ui::gfx::Command::Tag::kSetHitTestBehavior:
+      return ApplySetHitTestBehaviorCmd(
+          session, std::move(command.set_hit_test_behavior()));
+    case fuchsia::ui::gfx::Command::Tag::kSetViewProperties:
+      return ApplySetViewPropertiesCmd(
+          session, std::move(command.set_view_properties()));
+    case fuchsia::ui::gfx::Command::Tag::kSetCamera:
+      return ApplySetCameraCmd(session, std::move(command.set_camera()));
+    case fuchsia::ui::gfx::Command::Tag::kSetCameraTransform:
+      return ApplySetCameraTransformCmd(
+          session, std::move(command.set_camera_transform()));
+    case fuchsia::ui::gfx::Command::Tag::kSetCameraProjection:
+      return ApplySetCameraProjectionCmd(
+          session, std::move(command.set_camera_projection()));
+    case fuchsia::ui::gfx::Command::Tag::kSetStereoCameraProjection:
+      return ApplySetStereoCameraProjectionCmd(
+          session, std::move(command.set_stereo_camera_projection()));
+    case fuchsia::ui::gfx::Command::Tag::kSetCameraPoseBuffer:
+      return ApplySetCameraPoseBufferCmd(
+          session, std::move(command.set_camera_pose_buffer()));
+    case fuchsia::ui::gfx::Command::Tag::kSetLightColor:
+      return ApplySetLightColorCmd(session,
+                                   std::move(command.set_light_color()));
+    case fuchsia::ui::gfx::Command::Tag::kSetLightDirection:
+      return ApplySetLightDirectionCmd(
+          session, std::move(command.set_light_direction()));
+    case fuchsia::ui::gfx::Command::Tag::kAddLight:
+      return ApplyAddLightCmd(session, std::move(command.add_light()));
+    case fuchsia::ui::gfx::Command::Tag::kDetachLight:
+      return ApplyDetachLightCmd(session, std::move(command.detach_light()));
+    case fuchsia::ui::gfx::Command::Tag::kDetachLights:
+      return ApplyDetachLightsCmd(session, std::move(command.detach_lights()));
+    case fuchsia::ui::gfx::Command::Tag::kSetTexture:
+      return ApplySetTextureCmd(session, std::move(command.set_texture()));
+    case fuchsia::ui::gfx::Command::Tag::kSetColor:
+      return ApplySetColorCmd(session, std::move(command.set_color()));
+    case fuchsia::ui::gfx::Command::Tag::kBindMeshBuffers:
+      return ApplyBindMeshBuffersCmd(session,
+                                     std::move(command.bind_mesh_buffers()));
+    case fuchsia::ui::gfx::Command::Tag::kAddLayer:
+      return ApplyAddLayerCmd(session, std::move(command.add_layer()));
+    case fuchsia::ui::gfx::Command::Tag::kRemoveLayer:
+      return ApplyRemoveLayerCmd(session, std::move(command.remove_layer()));
+    case fuchsia::ui::gfx::Command::Tag::kRemoveAllLayers:
+      return ApplyRemoveAllLayersCmd(session,
+                                     std::move(command.remove_all_layers()));
+    case fuchsia::ui::gfx::Command::Tag::kSetLayerStack:
+      return ApplySetLayerStackCmd(session,
+                                   std::move(command.set_layer_stack()));
+    case fuchsia::ui::gfx::Command::Tag::kSetRenderer:
+      return ApplySetRendererCmd(session, std::move(command.set_renderer()));
+    case fuchsia::ui::gfx::Command::Tag::kSetRendererParam:
+      return ApplySetRendererParamCmd(session,
+                                      std::move(command.set_renderer_param()));
+    case fuchsia::ui::gfx::Command::Tag::kSetEventMask:
+      return ApplySetEventMaskCmd(session, std::move(command.set_event_mask()));
+    case fuchsia::ui::gfx::Command::Tag::kSetLabel:
+      return ApplySetLabelCmd(session, std::move(command.set_label()));
+    case fuchsia::ui::gfx::Command::Tag::kSetDisableClipping:
+      return ApplySetDisableClippingCmd(
+          session, std::move(command.set_disable_clipping()));
+    case fuchsia::ui::gfx::Command::Tag::kTakeSnapshotCmd:
+      return ApplyTakeSnapshotCmdHACK(session,
+                                      std::move(command.take_snapshot_cmd()));
+    case fuchsia::ui::gfx::Command::Tag::Invalid:
+      // FIDL validation should make this impossible.
+      FXL_CHECK(false);
+      return false;
+  }
+}
+
+bool GfxCommandApplier::ApplyCreateResourceCmd(
+    Session* session, CommandContext* command_context,
+    fuchsia::ui::gfx::CreateResourceCmd command) {
+  const ResourceId id = command.id;
+  if (id == 0) {
+    using ::operator<<;  // From print_commands.h
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplyCreateResourceCmd(): invalid ID: "
+        << command;
+    return false;
+  }
+
+  switch (command.resource.Which()) {
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kMemory:
+      return ApplyCreateMemory(session, id,
+                               std::move(command.resource.memory()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kImage:
+      return ApplyCreateImage(session, id, std::move(command.resource.image()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kImagePipe:
+      return ApplyCreateImagePipe(session, id,
+                                  std::move(command.resource.image_pipe()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kBuffer:
+      return ApplyCreateBuffer(session, id,
+                               std::move(command.resource.buffer()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kScene:
+      return ApplyCreateScene(session, id, std::move(command.resource.scene()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kCamera:
+      return ApplyCreateCamera(session, id,
+                               std::move(command.resource.camera()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kStereoCamera:
+      return ApplyCreateStereoCamera(
+          session, id, std::move(command.resource.stereo_camera()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kRenderer:
+      return ApplyCreateRenderer(session, id,
+                                 std::move(command.resource.renderer()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kAmbientLight:
+      return ApplyCreateAmbientLight(
+          session, id, std::move(command.resource.ambient_light()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kDirectionalLight:
+      return ApplyCreateDirectionalLight(
+          session, id, std::move(command.resource.directional_light()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kRectangle:
+      return ApplyCreateRectangle(session, id,
+                                  std::move(command.resource.rectangle()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kRoundedRectangle:
+      return ApplyCreateRoundedRectangle(
+          session, command_context, id,
+          std::move(command.resource.rounded_rectangle()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kCircle:
+      return ApplyCreateCircle(session, id,
+                               std::move(command.resource.circle()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kMesh:
+      return ApplyCreateMesh(session, id, std::move(command.resource.mesh()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kMaterial:
+      return ApplyCreateMaterial(session, id,
+                                 std::move(command.resource.material()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kView:
+      return ApplyCreateView(session, id, std::move(command.resource.view()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kViewHolder:
+      return ApplyCreateViewHolder(session, id,
+                                   std::move(command.resource.view_holder()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kClipNode:
+      return ApplyCreateClipNode(session, id,
+                                 std::move(command.resource.clip_node()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kOpacityNode:
+      return ApplyCreateOpacityNode(session, id,
+                                    command.resource.opacity_node());
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kEntityNode:
+      return ApplyCreateEntityNode(session, id,
+                                   std::move(command.resource.entity_node()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kShapeNode:
+      return ApplyCreateShapeNode(session, id,
+                                  std::move(command.resource.shape_node()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kCompositor:
+      return ApplyCreateCompositor(session, id,
+                                   std::move(command.resource.compositor()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kDisplayCompositor:
+      return ApplyCreateDisplayCompositor(
+          session, id, std::move(command.resource.display_compositor()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kImagePipeCompositor:
+      return ApplyCreateImagePipeCompositor(
+          session, id, std::move(command.resource.image_pipe_compositor()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kLayerStack:
+      return ApplyCreateLayerStack(session, id,
+                                   std::move(command.resource.layer_stack()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kLayer:
+      return ApplyCreateLayer(session, id, std::move(command.resource.layer()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::kVariable:
+      return ApplyCreateVariable(session, id,
+                                 std::move(command.resource.variable()));
+    case fuchsia::ui::gfx::ResourceArgs::Tag::Invalid:
+      // FIDL validation should make this impossible.
+      FXL_CHECK(false);
+      return false;
+  }
+}
+
+bool GfxCommandApplier::ApplyReleaseResourceCmd(
+    Session* session, fuchsia::ui::gfx::ReleaseResourceCmd command) {
+  return session->resources()->RemoveResource(command.id);
+}
+
+bool GfxCommandApplier::ApplyExportResourceCmd(
+    Session* session, fuchsia::ui::gfx::ExportResourceCmd command) {
+  if (!command.token) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::ApplyExportResourceCmd(): "
+           "no token provided.";
+    return false;
+  }
+  if (auto resource =
+          session->resources()->FindResource<Resource>(command.id)) {
+    return session->session_context().resource_linker->ExportResource(
+        resource.get(), std::move(command.token));
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyImportResourceCmd(
+    Session* session, fuchsia::ui::gfx::ImportResourceCmd command) {
+  if (!command.token) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::ApplyImportResourceCmd(): "
+           "no token provided.";
+    return false;
+  }
+  auto import = fxl::MakeRefCounted<Import>(
+      session, command.id, command.spec,
+      session->session_context().resource_linker->GetWeakPtr());
+  return session->session_context().resource_linker->ImportResource(
+             import.get(), command.spec, std::move(command.token)) &&
+         session->resources()->AddResource(command.id, std::move(import));
+}
+
+bool GfxCommandApplier::ApplyAddChildCmd(
+    Session* session, fuchsia::ui::gfx::AddChildCmd command) {
+  // Find the parent and child nodes. We can add:
+  // - Nodes to Nodes
+  // - ViewHolders to Nodes
+  // - Nodes to Views
+  // TODO(SCN-795): Split these out into separate commands?
+  if (auto parent = session->resources()->FindResource<Node>(
+          command.node_id, ResourceMap::ErrorBehavior::kDontReportErrors)) {
+    if (auto child = session->resources()->FindResource<Node>(
+            command.child_id, ResourceMap::ErrorBehavior::kDontReportErrors)) {
+      return parent->AddChild(std::move(child));
+    } else if (auto child = session->resources()->FindResource<ViewHolder>(
+                   command.child_id)) {
+      return parent->AddViewHolder(std::move(child));
+    }
+  } else if (auto parent =
+                 session->resources()->FindResource<View>(command.node_id)) {
+    if (auto child =
+            session->resources()->FindResource<Node>(command.child_id)) {
+      return parent->AddChild(std::move(child));
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyAddPartCmd(Session* session,
+                                        fuchsia::ui::gfx::AddPartCmd command) {
+  // Find the parent and part nodes.
+  if (auto parent_node =
+          session->resources()->FindResource<Node>(command.node_id)) {
+    if (auto part_node =
+            session->resources()->FindResource<Node>(command.part_id)) {
+      return parent_node->AddPart(std::move(part_node));
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyTakeSnapshotCmdHACK(
+    Session* session, fuchsia::ui::gfx::TakeSnapshotCmdHACK command) {
+  async::PostTask(
+      async_get_default_dispatcher(),
+      [weak = session->GetWeakPtr(), command = std::move(command)]() mutable {
+        if (!weak) {
+          if (auto callback = command.callback.Bind()) {
+            // TODO(SCN-978): Return an error to the caller for invalid data.
+            callback->OnData(fuchsia::mem::Buffer{});
+          }
+          return;
+        }
+
+        const auto& context = weak->session_context();
+        Resource* resource = nullptr;
+        if (auto node =
+                weak->resources()->FindResource<Node>(command.node_id)) {
+          resource = node.get();
+        } else if (command.node_id == 0) {
+          // TODO(SCN-1170): get rid of SceneGraph::first_compositor().
+          const auto& first_compositor_weak =
+              context.scene_graph->first_compositor();
+          if (first_compositor_weak) {
+            resource = first_compositor_weak.get();
+          }
+        }
+
+        if (resource == nullptr) {
+          if (auto callback = command.callback.Bind()) {
+            callback->OnData(fuchsia::mem::Buffer{});
+          }
+          return;
+        }
+
+        auto gpu_uploader =
+            escher::BatchGpuUploader::New(context.escher->GetWeakPtr());
+        Snapshotter snapshotter(gpu_uploader);
+        // Take a snapshot and return the data in callback. The closure does
+        // not need the snapshotter instance and is invoked after the instance
+        // is destroyed.
+        snapshotter.TakeSnapshot(resource, [callback = command.callback.Bind()](
+                                               fuchsia::mem::Buffer snapshot) {
+          callback->OnData(std::move(snapshot));
+        });
+      });
+  return true;
+}
+
+bool GfxCommandApplier::ApplyDetachCmd(Session* session,
+                                       fuchsia::ui::gfx::DetachCmd command) {
+  if (auto resource =
+          session->resources()->FindResource<Resource>(command.id)) {
+    return resource->Detach();
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyDetachChildrenCmd(
+    Session* session, fuchsia::ui::gfx::DetachChildrenCmd command) {
+  if (auto node = session->resources()->FindResource<Node>(command.node_id)) {
+    return node->DetachChildren();
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetTagCmd(Session* session,
+                                       fuchsia::ui::gfx::SetTagCmd command) {
+  if (auto node = session->resources()->FindResource<Node>(command.node_id)) {
+    return node->SetTagValue(command.tag_value);
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetTranslationCmd(
+    Session* session, fuchsia::ui::gfx::SetTranslationCmd command) {
+  if (auto node = session->resources()->FindResource<Node>(command.id)) {
+    if (IsVariable(command.value)) {
+      if (auto variable =
+              session->resources()->FindVariableResource<Vector3Variable>(
+                  command.value.variable_id)) {
+        return node->SetTranslation(variable);
+      }
+    } else {
+      return node->SetTranslation(UnwrapVector3(command.value));
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetScaleCmd(
+    Session* session, fuchsia::ui::gfx::SetScaleCmd command) {
+  if (auto node = session->resources()->FindResource<Node>(command.id)) {
+    if (IsVariable(command.value)) {
+      if (auto variable =
+              session->resources()->FindVariableResource<Vector3Variable>(
+                  command.value.variable_id)) {
+        return node->SetScale(variable);
+      }
+    } else {
+      return node->SetScale(UnwrapVector3(command.value));
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetRotationCmd(
+    Session* session, fuchsia::ui::gfx::SetRotationCmd command) {
+  if (auto node = session->resources()->FindResource<Node>(command.id)) {
+    if (IsVariable(command.value)) {
+      if (auto variable =
+              session->resources()->FindVariableResource<QuaternionVariable>(
+                  command.value.variable_id)) {
+        return node->SetRotation(variable);
+      }
+    } else {
+      return node->SetRotation(UnwrapQuaternion(command.value));
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetAnchorCmd(
+    Session* session, fuchsia::ui::gfx::SetAnchorCmd command) {
+  if (auto node = session->resources()->FindResource<Node>(command.id)) {
+    if (IsVariable(command.value)) {
+      if (auto variable =
+              session->resources()->FindVariableResource<Vector3Variable>(
+                  command.value.variable_id)) {
+        return node->SetAnchor(variable);
+      }
+    }
+    return node->SetAnchor(UnwrapVector3(command.value));
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetSizeCmd(Session* session,
+                                        fuchsia::ui::gfx::SetSizeCmd command) {
+  if (auto layer = session->resources()->FindResource<Layer>(command.id)) {
+    if (IsVariable(command.value)) {
+      session->error_reporter()->ERROR()
+          << "scenic_impl::gfx::GfxCommandApplier::ApplySetSizeCmd(): "
+             "unimplemented for variable value.";
+      return false;
+    }
+    return layer->SetSize(UnwrapVector2(command.value));
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetOpacityCmd(
+    Session* session, fuchsia::ui::gfx::SetOpacityCmd command) {
+  if (auto node =
+          session->resources()->FindResource<OpacityNode>(command.node_id)) {
+    node->SetOpacity(command.opacity);
+    return true;
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySendSizeChangeHintCmd(
+    Session* session, fuchsia::ui::gfx::SendSizeChangeHintCmdHACK command) {
+  if (auto node = session->resources()->FindResource<Node>(command.node_id)) {
+    return node->SendSizeChangeHint(command.width_change_factor,
+                                    command.height_change_factor);
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetShapeCmd(
+    Session* session, fuchsia::ui::gfx::SetShapeCmd command) {
+  if (auto node =
+          session->resources()->FindResource<ShapeNode>(command.node_id)) {
+    if (auto shape =
+            session->resources()->FindResource<Shape>(command.shape_id)) {
+      node->SetShape(std::move(shape));
+      return true;
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetMaterialCmd(
+    Session* session, fuchsia::ui::gfx::SetMaterialCmd command) {
+  if (auto node =
+          session->resources()->FindResource<ShapeNode>(command.node_id)) {
+    if (auto material =
+            session->resources()->FindResource<Material>(command.material_id)) {
+      node->SetMaterial(std::move(material));
+      return true;
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetClipCmd(Session* session,
+                                        fuchsia::ui::gfx::SetClipCmd command) {
+  if (command.clip_id != 0) {
+    // TODO(SCN-167): Support non-zero clip_id.
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::ApplySetClipCmd(): only "
+           "clip_to_self is implemented.";
+    return false;
+  }
+
+  if (auto node = session->resources()->FindResource<Node>(command.node_id)) {
+    return node->SetClipToSelf(command.clip_to_self);
+  }
+
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetHitTestBehaviorCmd(
+    Session* session, fuchsia::ui::gfx::SetHitTestBehaviorCmd command) {
+  if (auto node = session->resources()->FindResource<Node>(command.node_id)) {
+    return node->SetHitTestBehavior(command.hit_test_behavior);
+  }
+
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetViewPropertiesCmd(
+    Session* session, fuchsia::ui::gfx::SetViewPropertiesCmd command) {
+  if (auto view_holder = session->resources()->FindResource<ViewHolder>(
+          command.view_holder_id)) {
+    view_holder->SetViewProperties(std::move(command.properties));
+    return true;
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetCameraCmd(
+    Session* session, fuchsia::ui::gfx::SetCameraCmd command) {
+  if (auto renderer =
+          session->resources()->FindResource<Renderer>(command.renderer_id)) {
+    if (command.camera_id == 0) {
+      renderer->SetCamera(nullptr);
+      return true;
+    } else if (auto camera = session->resources()->FindResource<Camera>(
+                   command.camera_id)) {
+      renderer->SetCamera(std::move(camera));
+      return true;
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetTextureCmd(
+    Session* session, fuchsia::ui::gfx::SetTextureCmd command) {
+  if (auto material =
+          session->resources()->FindResource<Material>(command.material_id)) {
+    if (command.texture_id == 0) {
+      material->SetTexture(nullptr);
+      return true;
+    } else if (auto image = session->resources()->FindResource<ImageBase>(
+                   command.texture_id)) {
+      material->SetTexture(std::move(image));
+      return true;
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetColorCmd(
+    Session* session, fuchsia::ui::gfx::SetColorCmd command) {
+  if (auto material =
+          session->resources()->FindResource<Material>(command.material_id)) {
+    if (IsVariable(command.color)) {
+      session->error_reporter()->ERROR()
+          << "scenic_impl::gfx::GfxCommandApplier::ApplySetColorCmd(): "
+             "unimplemented for variable color.";
+      return false;
+    }
+
+    auto& color = command.color.value;
+    float red = static_cast<float>(color.red) / 255.f;
+    float green = static_cast<float>(color.green) / 255.f;
+    float blue = static_cast<float>(color.blue) / 255.f;
+    float alpha = static_cast<float>(color.alpha) / 255.f;
+    material->SetColor(red, green, blue, alpha);
+    return true;
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyBindMeshBuffersCmd(
+    Session* session, fuchsia::ui::gfx::BindMeshBuffersCmd command) {
+  auto mesh = session->resources()->FindResource<MeshShape>(command.mesh_id);
+  auto index_buffer =
+      session->resources()->FindResource<Buffer>(command.index_buffer_id);
+  auto vertex_buffer =
+      session->resources()->FindResource<Buffer>(command.vertex_buffer_id);
+  if (mesh && index_buffer && vertex_buffer) {
+    return mesh->BindBuffers(std::move(index_buffer), command.index_format,
+                             command.index_offset, command.index_count,
+                             std::move(vertex_buffer), command.vertex_format,
+                             command.vertex_offset, command.vertex_count,
+                             Unwrap(command.bounding_box));
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyAddLayerCmd(
+    Session* session, fuchsia::ui::gfx::AddLayerCmd command) {
+  auto layer_stack =
+      session->resources()->FindResource<LayerStack>(command.layer_stack_id);
+  auto layer = session->resources()->FindResource<Layer>(command.layer_id);
+  if (layer_stack && layer) {
+    return layer_stack->AddLayer(std::move(layer));
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyRemoveLayerCmd(
+    Session* session, fuchsia::ui::gfx::RemoveLayerCmd command) {
+  auto layer_stack =
+      session->resources()->FindResource<LayerStack>(command.layer_stack_id);
+  auto layer = session->resources()->FindResource<Layer>(command.layer_id);
+  if (layer_stack && layer) {
+    return layer_stack->RemoveLayer(std::move(layer));
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyRemoveAllLayersCmd(
+    Session* session, fuchsia::ui::gfx::RemoveAllLayersCmd command) {
+  auto layer_stack =
+      session->resources()->FindResource<LayerStack>(command.layer_stack_id);
+  if (layer_stack) {
+    return layer_stack->RemoveAllLayers();
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetLayerStackCmd(
+    Session* session, fuchsia::ui::gfx::SetLayerStackCmd command) {
+  auto compositor =
+      session->resources()->FindResource<Compositor>(command.compositor_id);
+  auto layer_stack =
+      session->resources()->FindResource<LayerStack>(command.layer_stack_id);
+  if (compositor && layer_stack) {
+    return compositor->SetLayerStack(std::move(layer_stack));
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetRendererCmd(
+    Session* session, fuchsia::ui::gfx::SetRendererCmd command) {
+  auto layer = session->resources()->FindResource<Layer>(command.layer_id);
+  auto renderer =
+      session->resources()->FindResource<Renderer>(command.renderer_id);
+
+  if (layer && renderer) {
+    return layer->SetRenderer(std::move(renderer));
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetRendererParamCmd(
+    Session* session, fuchsia::ui::gfx::SetRendererParamCmd command) {
+  auto renderer =
+      session->resources()->FindResource<Renderer>(command.renderer_id);
+  if (renderer) {
+    switch (command.param.Which()) {
+      case fuchsia::ui::gfx::RendererParam::Tag::kShadowTechnique:
+        return renderer->SetShadowTechnique(command.param.shadow_technique());
+      case fuchsia::ui::gfx::RendererParam::Tag::kRenderFrequency:
+        // TODO(SCN-1169): SetRenderContinuously should only affect the
+        // compositor that has the renderer attached to it.
+        session->session_context().frame_scheduler->SetRenderContinuously(
+            command.param.render_frequency() ==
+            fuchsia::ui::gfx::RenderFrequency::CONTINUOUSLY);
+        return true;
+      case fuchsia::ui::gfx::RendererParam::Tag::Invalid:
+        session->error_reporter()->ERROR()
+            << "scenic_impl::gfx::GfxCommandApplier::"
+               "ApplySetRendererParamCmd(): "
+               "invalid param.";
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetEventMaskCmd(
+    Session* session, fuchsia::ui::gfx::SetEventMaskCmd command) {
+  if (auto r = session->resources()->FindResource<Resource>(command.id)) {
+    return r->SetEventMask(command.event_mask);
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetCameraTransformCmd(
+    Session* session, fuchsia::ui::gfx::SetCameraTransformCmd command) {
+  // TODO(SCN-123): support variables.
+  if (IsVariable(command.eye_position) || IsVariable(command.eye_look_at) ||
+      IsVariable(command.eye_up)) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplySetCameraTransformCmd(): "
+           "unimplemented: variable properties.";
+    return false;
+  } else if (auto camera = session->resources()->FindResource<Camera>(
+                 command.camera_id)) {
+    camera->SetTransform(UnwrapVector3(command.eye_position),
+                         UnwrapVector3(command.eye_look_at),
+                         UnwrapVector3(command.eye_up));
+    return true;
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetCameraProjectionCmd(
+    Session* session, fuchsia::ui::gfx::SetCameraProjectionCmd command) {
+  // TODO(SCN-123): support variables.
+  if (IsVariable(command.fovy)) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplySetCameraProjectionCmd(): "
+           "unimplemented: variable properties.";
+    return false;
+  } else if (auto camera = session->resources()->FindResource<Camera>(
+                 command.camera_id)) {
+    camera->SetProjection(UnwrapFloat(command.fovy));
+    return true;
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetStereoCameraProjectionCmd(
+    Session* session, fuchsia::ui::gfx::SetStereoCameraProjectionCmd command) {
+  if (IsVariable(command.left_projection) ||
+      IsVariable(command.right_projection)) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplySetStereoCameraProjectionOp(): "
+           "unimplemented: variable properties.";
+    return false;
+  } else if (auto stereo_camera =
+                 session->resources()->FindResource<StereoCamera>(
+                     command.camera_id)) {
+    stereo_camera->SetStereoProjection(Unwrap(command.left_projection.value),
+                                       Unwrap(command.right_projection.value));
+    return true;
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetCameraPoseBufferCmd(
+    Session* session, fuchsia::ui::gfx::SetCameraPoseBufferCmd command) {
+  if (command.base_time > dispatcher_clock_now()) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplySetCameraPoseBufferCmd(): "
+           "base time not in the past";
+    return false;
+  }
+
+  auto buffer = session->resources()->FindResource<Buffer>(command.buffer_id);
+  if (!buffer) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplySetCameraPoseBufferCmd(S): "
+           "invalid buffer ID";
+    return false;
+  }
+
+  if (command.num_entries < 1) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplySetCameraPoseBufferCmd(): "
+           "must have at least one entry in the pose buffer";
+    return false;
+  }
+
+  if (buffer->size() < command.num_entries * sizeof(escher::hmd::Pose)) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplySetCameraPoseBufferCmd(): "
+           "buffer is not large enough";
+    return false;
+  }
+
+  auto camera = session->resources()->FindResource<Camera>(command.camera_id);
+  if (!camera) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplySetCameraPoseBufferCmd(): "
+           "invalid camera ID";
+    return false;
+  }
+
+  camera->SetPoseBuffer(buffer, command.num_entries, command.base_time,
+                        command.time_interval);
+
+  return true;
+}
+
+bool GfxCommandApplier::ApplySetLightColorCmd(
+    Session* session, fuchsia::ui::gfx::SetLightColorCmd command) {
+  // TODO(SCN-123): support variables.
+  if (command.color.variable_id) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::ApplySetLightColorCmd(): "
+           "unimplemented: variable color.";
+    return false;
+  } else if (auto light =
+                 session->resources()->FindResource<Light>(command.light_id)) {
+    return light->SetColor(Unwrap(command.color.value));
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetLightDirectionCmd(
+    Session* session, fuchsia::ui::gfx::SetLightDirectionCmd command) {
+  // TODO(SCN-123): support variables.
+  if (command.direction.variable_id) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplySetLightDirectionCmd(): "
+           "unimplemented: variable direction.";
+    return false;
+  } else if (auto light = session->resources()->FindResource<DirectionalLight>(
+                 command.light_id)) {
+    return light->SetDirection(Unwrap(command.direction.value));
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyAddLightCmd(
+    Session* session, fuchsia::ui::gfx::AddLightCmd command) {
+  if (auto scene =
+          session->resources()->FindResource<Scene>(command.scene_id)) {
+    if (auto light =
+            session->resources()->FindResource<Light>(command.light_id)) {
+      return scene->AddLight(std::move(light));
+    }
+  }
+
+  session->error_reporter()->ERROR() << "scenic_impl::gfx::GfxCommandApplier::"
+                                        "ApplyAddLightCmd(): unimplemented.";
+  return false;
+}
+
+bool GfxCommandApplier::ApplyDetachLightCmd(
+    Session* session, fuchsia::ui::gfx::DetachLightCmd command) {
+  session->error_reporter()->ERROR() << "scenic_impl::gfx::GfxCommandApplier::"
+                                        "ApplyDetachLightCmd(): unimplemented.";
+  return false;
+}
+
+bool GfxCommandApplier::ApplyDetachLightsCmd(
+    Session* session, fuchsia::ui::gfx::DetachLightsCmd command) {
+  session->error_reporter()->ERROR()
+      << "scenic_impl::gfx::GfxCommandApplier::"
+         "ApplyDetachLightsCmd(): unimplemented.";
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetLabelCmd(
+    Session* session, fuchsia::ui::gfx::SetLabelCmd command) {
+  if (auto r = session->resources()->FindResource<Resource>(command.id)) {
+    return r->SetLabel(command.label);
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplySetDisableClippingCmd(
+    Session* session, fuchsia::ui::gfx::SetDisableClippingCmd command) {
+  if (auto r =
+          session->resources()->FindResource<Renderer>(command.renderer_id)) {
+    r->DisableClipping(command.disable_clipping);
+    return true;
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyCreateMemory(Session* session, ResourceId id,
+                                          fuchsia::ui::gfx::MemoryArgs args) {
+  auto memory = CreateMemory(session, id, std::move(args));
+  return memory ? session->resources()->AddResource(id, std::move(memory))
+                : false;
+}
+
+bool GfxCommandApplier::ApplyCreateImage(Session* session, ResourceId id,
+                                         fuchsia::ui::gfx::ImageArgs args) {
+  if (auto memory =
+          session->resources()->FindResource<Memory>(args.memory_id)) {
+    if (auto image = CreateImage(session, id, std::move(memory), args)) {
+      return session->resources()->AddResource(id, std::move(image));
+    }
+  }
+
+  return false;
+}
+
+bool GfxCommandApplier::ApplyCreateImagePipe(
+    Session* session, ResourceId id, fuchsia::ui::gfx::ImagePipeArgs args) {
+  auto image_pipe = fxl::MakeRefCounted<ImagePipe>(
+      session, id, std::move(args.image_pipe_request),
+      session->session_context().update_scheduler);
+  return session->resources()->AddResource(id, image_pipe);
+}
+
+bool GfxCommandApplier::ApplyCreateBuffer(Session* session, ResourceId id,
+                                          fuchsia::ui::gfx::BufferArgs args) {
+  if (auto memory =
+          session->resources()->FindResource<Memory>(args.memory_id)) {
+    if (auto buffer = CreateBuffer(session, id, std::move(memory),
+                                   args.memory_offset, args.num_bytes)) {
+      return session->resources()->AddResource(id, std::move(buffer));
+    }
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyCreateScene(Session* session, ResourceId id,
+                                         fuchsia::ui::gfx::SceneArgs args) {
+  auto scene = CreateScene(session, id, std::move(args));
+  return scene ? session->resources()->AddResource(id, std::move(scene))
+               : false;
+}
+
+bool GfxCommandApplier::ApplyCreateCamera(Session* session, ResourceId id,
+                                          fuchsia::ui::gfx::CameraArgs args) {
+  auto camera = CreateCamera(session, id, std::move(args));
+  return camera ? session->resources()->AddResource(id, std::move(camera))
+                : false;
+}
+
+bool GfxCommandApplier::ApplyCreateStereoCamera(
+    Session* session, ResourceId id, fuchsia::ui::gfx::StereoCameraArgs args) {
+  auto camera = CreateStereoCamera(session, id, args);
+  return camera ? session->resources()->AddResource(id, std::move(camera))
+                : false;
+}
+
+bool GfxCommandApplier::ApplyCreateRenderer(
+    Session* session, ResourceId id, fuchsia::ui::gfx::RendererArgs args) {
+  auto renderer = CreateRenderer(session, id, std::move(args));
+  return renderer ? session->resources()->AddResource(id, std::move(renderer))
+                  : false;
+}
+
+bool GfxCommandApplier::ApplyCreateAmbientLight(
+    Session* session, ResourceId id, fuchsia::ui::gfx::AmbientLightArgs args) {
+  auto light = CreateAmbientLight(session, id);
+  return light ? session->resources()->AddResource(id, std::move(light))
+               : false;
+}
+
+bool GfxCommandApplier::ApplyCreateDirectionalLight(
+    Session* session, ResourceId id,
+    fuchsia::ui::gfx::DirectionalLightArgs args) {
+  auto light = CreateDirectionalLight(session, id);
+  return light ? session->resources()->AddResource(id, std::move(light))
+               : false;
+}
+
+bool GfxCommandApplier::ApplyCreateRectangle(
+    Session* session, ResourceId id, fuchsia::ui::gfx::RectangleArgs args) {
+  if (!AssertValueIsOfType(args.width, kFloatValueTypes, session) ||
+      !AssertValueIsOfType(args.height, kFloatValueTypes, session)) {
+    return false;
+  }
+
+  // TODO(SCN-123): support variables.
+  if (IsVariable(args.width) || IsVariable(args.height)) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::ApplyCreateRectangle(): "
+           "unimplemented: variable width/height.";
+    return false;
+  }
+
+  auto rectangle =
+      CreateRectangle(session, id, args.width.vector1(), args.height.vector1());
+  return rectangle ? session->resources()->AddResource(id, std::move(rectangle))
+                   : false;
+}
+
+bool GfxCommandApplier::ApplyCreateRoundedRectangle(
+    Session* session, CommandContext* command_context, ResourceId id,
+    fuchsia::ui::gfx::RoundedRectangleArgs args) {
+  if (!AssertValueIsOfType(args.width, kFloatValueTypes, session) ||
+      !AssertValueIsOfType(args.height, kFloatValueTypes, session) ||
+      !AssertValueIsOfType(args.top_left_radius, kFloatValueTypes, session) ||
+      !AssertValueIsOfType(args.top_right_radius, kFloatValueTypes, session) ||
+      !AssertValueIsOfType(args.bottom_left_radius, kFloatValueTypes,
+                           session) ||
+      !AssertValueIsOfType(args.bottom_right_radius, kFloatValueTypes,
+                           session)) {
+    return false;
+  }
+
+  // TODO(SCN-123): support variables.
+  if (IsVariable(args.width) || IsVariable(args.height) ||
+      IsVariable(args.top_left_radius) || IsVariable(args.top_right_radius) ||
+      IsVariable(args.bottom_left_radius) ||
+      IsVariable(args.bottom_right_radius)) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::"
+           "ApplyCreateRoundedRectangle(): "
+           "unimplemented: variable width/height/radii.";
+    return false;
+  }
+
+  const float width = args.width.vector1();
+  const float height = args.height.vector1();
+  const float top_left_radius = args.top_left_radius.vector1();
+  const float top_right_radius = args.top_right_radius.vector1();
+  const float bottom_right_radius = args.bottom_right_radius.vector1();
+  const float bottom_left_radius = args.bottom_left_radius.vector1();
+
+  auto rectangle = CreateRoundedRectangle(
+      session, command_context, id, width, height, top_left_radius,
+      top_right_radius, bottom_right_radius, bottom_left_radius);
+  return rectangle ? session->resources()->AddResource(id, std::move(rectangle))
+                   : false;
+}
+
+bool GfxCommandApplier::ApplyCreateCircle(Session* session, ResourceId id,
+                                          fuchsia::ui::gfx::CircleArgs args) {
+  if (!AssertValueIsOfType(args.radius, kFloatValueTypes, session)) {
+    return false;
+  }
+
+  // TODO(SCN-123): support variables.
+  if (IsVariable(args.radius)) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::ApplyCreateCircle(): "
+           "unimplemented: variable radius.";
+    return false;
+  }
+
+  auto circle = CreateCircle(session, id, args.radius.vector1());
+  return circle ? session->resources()->AddResource(id, std::move(circle))
+                : false;
+}
+
+bool GfxCommandApplier::ApplyCreateMesh(Session* session, ResourceId id,
+                                        fuchsia::ui::gfx::MeshArgs args) {
+  auto mesh = CreateMesh(session, id);
+  return mesh ? session->resources()->AddResource(id, std::move(mesh)) : false;
+}
+
+bool GfxCommandApplier::ApplyCreateMaterial(
+    Session* session, ResourceId id, fuchsia::ui::gfx::MaterialArgs args) {
+  auto material = CreateMaterial(session, id);
+  return material ? session->resources()->AddResource(id, std::move(material))
+                  : false;
+}
+
+bool GfxCommandApplier::ApplyCreateView(Session* session, ResourceId id,
+                                        fuchsia::ui::gfx::ViewArgs args) {
+  // Sanity check.  We also rely on FIDL to enforce this for us, although it
+  // does not at the moment.
+  FXL_DCHECK(args.token) << "scenic_impl::gfx::GfxCommandApplier::"
+                            "ApplyCreateView(): no token provided.";
+
+  if (auto view = CreateView(session, id, std::move(args))) {
+    view->As<View>()->Connect();  // Initiate the link.
+    session->resources()->AddResource(id, std::move(view));
+    return true;
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyCreateViewHolder(
+    Session* session, ResourceId id, fuchsia::ui::gfx::ViewHolderArgs args) {
+  // Sanity check.  We also rely on FIDL to enforce this for us, although it
+  // does not at the moment
+  FXL_DCHECK(args.token)
+      << "scenic_impl::gfx::GfxCommandApplier::ApplyCreateViewHolder()"
+         ": no token provided.";
+
+  if (auto view_holder = CreateViewHolder(session, id, std::move(args))) {
+    view_holder->As<ViewHolder>()->Connect();  // Initiate the link.
+    session->resources()->AddResource(id, std::move(view_holder));
+    return true;
+  }
+  return false;
+}
+
+bool GfxCommandApplier::ApplyCreateClipNode(
+    Session* session, ResourceId id, fuchsia::ui::gfx::ClipNodeArgs args) {
+  auto node = CreateClipNode(session, id, std::move(args));
+  return node ? session->resources()->AddResource(id, std::move(node)) : false;
+}
+
+bool GfxCommandApplier::ApplyCreateEntityNode(
+    Session* session, ResourceId id, fuchsia::ui::gfx::EntityNodeArgs args) {
+  auto node = CreateEntityNode(session, id, std::move(args));
+  return node ? session->resources()->AddResource(id, std::move(node)) : false;
+}
+
+bool GfxCommandApplier::ApplyCreateOpacityNode(
+    Session* session, ResourceId id, fuchsia::ui::gfx::OpacityNodeArgs args) {
+  auto node = CreateOpacityNode(session, id, args);
+  return node ? session->resources()->AddResource(id, std::move(node)) : false;
+}
+
+bool GfxCommandApplier::ApplyCreateShapeNode(
+    Session* session, ResourceId id, fuchsia::ui::gfx::ShapeNodeArgs args) {
+  auto node = CreateShapeNode(session, id, std::move(args));
+  return node ? session->resources()->AddResource(id, std::move(node)) : false;
+}
+
+bool GfxCommandApplier::ApplyCreateCompositor(
+    Session* session, ResourceId id, fuchsia::ui::gfx::CompositorArgs args) {
+  auto compositor = CreateCompositor(session, id, std::move(args));
+  return compositor
+             ? session->resources()->AddResource(id, std::move(compositor))
+             : false;
+}
+
+bool GfxCommandApplier::ApplyCreateDisplayCompositor(
+    Session* session, ResourceId id,
+    fuchsia::ui::gfx::DisplayCompositorArgs args) {
+  auto compositor = CreateDisplayCompositor(session, id, std::move(args));
+  return compositor
+             ? session->resources()->AddResource(id, std::move(compositor))
+             : false;
+}
+
+bool GfxCommandApplier::ApplyCreateImagePipeCompositor(
+    Session* session, ResourceId id,
+    fuchsia::ui::gfx::ImagePipeCompositorArgs args) {
+  auto compositor = CreateImagePipeCompositor(session, id, std::move(args));
+  return compositor
+             ? session->resources()->AddResource(id, std::move(compositor))
+             : false;
+}
+
+bool GfxCommandApplier::ApplyCreateLayerStack(
+    Session* session, ResourceId id, fuchsia::ui::gfx::LayerStackArgs args) {
+  auto layer_stack = CreateLayerStack(session, id, std::move(args));
+  return layer_stack
+             ? session->resources()->AddResource(id, std::move(layer_stack))
+             : false;
+}
+
+bool GfxCommandApplier::ApplyCreateLayer(Session* session, ResourceId id,
+                                         fuchsia::ui::gfx::LayerArgs args) {
+  auto layer = CreateLayer(session, id, std::move(args));
+  return layer ? session->resources()->AddResource(id, std::move(layer))
+               : false;
+}
+
+bool GfxCommandApplier::ApplyCreateVariable(
+    Session* session, ResourceId id, fuchsia::ui::gfx::VariableArgs args) {
+  auto variable = CreateVariable(session, id, std::move(args));
+  return variable ? session->resources()->AddResource(id, std::move(variable))
+                  : false;
+}
+
+ResourcePtr GfxCommandApplier::CreateMemory(Session* session, ResourceId id,
+                                            fuchsia::ui::gfx::MemoryArgs args) {
+  return Memory::New(session, id, std::move(args), session->error_reporter());
+}
+
+ResourcePtr GfxCommandApplier::CreateImage(Session* session, ResourceId id,
+                                           MemoryPtr memory,
+                                           fuchsia::ui::gfx::ImageArgs args) {
+  return Image::New(session, id, memory, args.info, args.memory_offset,
+                    session->error_reporter());
+}
+
+ResourcePtr GfxCommandApplier::CreateBuffer(Session* session, ResourceId id,
+                                            MemoryPtr memory,
+                                            uint32_t memory_offset,
+                                            uint32_t num_bytes) {
+  if (memory_offset + num_bytes > memory->size()) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::CreateBuffer(): "
+           "buffer does not fit within memory (buffer "
+           "offset: "
+        << memory_offset << ", buffer size: " << num_bytes
+        << ", memory size: " << memory->size() << ")";
+    return ResourcePtr();
+  }
+
+  // Make a pointer to a subregion of the memory, if necessary.
+  escher::GpuMemPtr gpu_mem =
+      (memory_offset > 0 || num_bytes < memory->size())
+          ? memory->GetGpuMem()->Suballocate(num_bytes, memory_offset)
+          : memory->GetGpuMem();
+
+  return fxl::MakeRefCounted<Buffer>(session, id, std::move(gpu_mem),
+                                     std::move(memory));
+}
+
+ResourcePtr GfxCommandApplier::CreateScene(Session* session, ResourceId id,
+                                           fuchsia::ui::gfx::SceneArgs args) {
+  return fxl::MakeRefCounted<Scene>(session, id);
+}
+
+ResourcePtr GfxCommandApplier::CreateCamera(Session* session, ResourceId id,
+                                            fuchsia::ui::gfx::CameraArgs args) {
+  if (auto scene = session->resources()->FindResource<Scene>(args.scene_id)) {
+    return fxl::MakeRefCounted<Camera>(session, id, std::move(scene));
+  }
+  return ResourcePtr();
+}
+
+ResourcePtr GfxCommandApplier::CreateStereoCamera(
+    Session* session, ResourceId id,
+    const fuchsia::ui::gfx::StereoCameraArgs args) {
+  if (auto scene = session->resources()->FindResource<Scene>(args.scene_id)) {
+    return fxl::MakeRefCounted<StereoCamera>(session, id, std::move(scene));
+  }
+  return ResourcePtr();
+}
+
+ResourcePtr GfxCommandApplier::CreateRenderer(
+    Session* session, ResourceId id, fuchsia::ui::gfx::RendererArgs args) {
+  return fxl::MakeRefCounted<Renderer>(session, id);
+}
+
+ResourcePtr GfxCommandApplier::CreateAmbientLight(Session* session,
+                                                  ResourceId id) {
+  return fxl::MakeRefCounted<AmbientLight>(session, id);
+}
+
+ResourcePtr GfxCommandApplier::CreateDirectionalLight(Session* session,
+                                                      ResourceId id) {
+  return fxl::MakeRefCounted<DirectionalLight>(session, id);
+}
+
+ResourcePtr GfxCommandApplier::CreateView(Session* session, ResourceId id,
+                                          fuchsia::ui::gfx::ViewArgs args) {
+  ViewLinker* view_linker = session->session_context().view_linker;
+  ViewLinker::ImportLink link = view_linker->CreateImport(
+      std::move(args.token), session->error_reporter());
+
+  // Create a View if the Link was successfully registered.
+  if (link.valid()) {
+    return fxl::MakeRefCounted<View>(session, id, std::move(link));
+  }
+  return nullptr;
+}
+
+ResourcePtr GfxCommandApplier::CreateViewHolder(
+    Session* session, ResourceId id, fuchsia::ui::gfx::ViewHolderArgs args) {
+  ViewLinker* view_linker = session->session_context().view_linker;
+  ViewLinker::ExportLink link = view_linker->CreateExport(
+      std::move(args.token), session->error_reporter());
+
+  // Create a ViewHolder if the Link was successfully registered.
+  if (link.valid()) {
+    return fxl::MakeRefCounted<ViewHolder>(session, id, std::move(link));
+  }
+  return nullptr;
+}
+
+ResourcePtr GfxCommandApplier::CreateClipNode(
+    Session* session, ResourceId id, fuchsia::ui::gfx::ClipNodeArgs args) {
+  session->error_reporter()->ERROR()
+      << "scenic_impl::gfx::GfxCommandApplier::CreateClipNode(): "
+         "unimplemented.";
+  return ResourcePtr();
+}
+
+ResourcePtr GfxCommandApplier::CreateEntityNode(
+    Session* session, ResourceId id, fuchsia::ui::gfx::EntityNodeArgs args) {
+  return fxl::MakeRefCounted<EntityNode>(session, id);
+}
+
+ResourcePtr GfxCommandApplier::CreateOpacityNode(
+    Session* session, ResourceId id, fuchsia::ui::gfx::OpacityNodeArgs args) {
+  return fxl::MakeRefCounted<OpacityNode>(session, id);
+}
+
+ResourcePtr GfxCommandApplier::CreateShapeNode(
+    Session* session, ResourceId id, fuchsia::ui::gfx::ShapeNodeArgs args) {
+  return fxl::MakeRefCounted<ShapeNode>(session, id);
+}
+
+ResourcePtr GfxCommandApplier::CreateCompositor(
+    Session* session, ResourceId id, fuchsia::ui::gfx::CompositorArgs args) {
+  return Compositor::New(session, id, session->session_context().scene_graph);
+}
+
+ResourcePtr GfxCommandApplier::CreateDisplayCompositor(
+    Session* session, ResourceId id,
+    fuchsia::ui::gfx::DisplayCompositorArgs args) {
+  Display* display =
+      session->session_context().display_manager->default_display();
+  if (!display) {
+    session->error_reporter()->ERROR()
+        << "There is no default display available.";
+    return nullptr;
+  }
+
+  if (display->is_claimed()) {
+    session->error_reporter()->ERROR()
+        << "The default display has already been claimed "
+           "by another compositor.";
+    return nullptr;
+  }
+
+  return fxl::AdoptRef(new DisplayCompositor(
+      session, id, session->session_context().scene_graph, display,
+      SwapchainFactory::CreateDisplaySwapchain(
+          display, session->session_context().display_manager,
+          session->session_context().event_timestamper,
+          session->session_context().escher)));
+}
+
+ResourcePtr GfxCommandApplier::CreateImagePipeCompositor(
+    Session* session, ResourceId id,
+    fuchsia::ui::gfx::ImagePipeCompositorArgs args) {
+  // TODO(SCN-179)
+  session->error_reporter()->ERROR() << "scenic_impl::gfx::GfxCommandApplier::"
+                                        "ApplyCreateImagePipeCompositor() "
+                                        "is unimplemented (SCN-179)";
+  return ResourcePtr();
+}
+
+ResourcePtr GfxCommandApplier::CreateLayerStack(
+    Session* session, ResourceId id, fuchsia::ui::gfx::LayerStackArgs args) {
+  return fxl::MakeRefCounted<LayerStack>(session, id);
+}
+
+ResourcePtr GfxCommandApplier::CreateVariable(
+    Session* session, ResourceId id, fuchsia::ui::gfx::VariableArgs args) {
+  fxl::RefPtr<Variable> variable;
+  switch (args.type) {
+    case fuchsia::ui::gfx::ValueType::kVector1:
+      variable = fxl::MakeRefCounted<FloatVariable>(session, id);
+      break;
+    case fuchsia::ui::gfx::ValueType::kVector2:
+      variable = fxl::MakeRefCounted<Vector2Variable>(session, id);
+      break;
+    case fuchsia::ui::gfx::ValueType::kVector3:
+      variable = fxl::MakeRefCounted<Vector3Variable>(session, id);
+      break;
+    case fuchsia::ui::gfx::ValueType::kVector4:
+      variable = fxl::MakeRefCounted<Vector4Variable>(session, id);
+      break;
+    case fuchsia::ui::gfx::ValueType::kMatrix4:
+      variable = fxl::MakeRefCounted<Matrix4x4Variable>(session, id);
+      break;
+    case fuchsia::ui::gfx::ValueType::kColorRgb:
+      // not yet supported
+      variable = nullptr;
+      break;
+    case fuchsia::ui::gfx::ValueType::kColorRgba:
+      // not yet supported
+      variable = nullptr;
+      break;
+    case fuchsia::ui::gfx::ValueType::kQuaternion:
+      variable = fxl::MakeRefCounted<QuaternionVariable>(session, id);
+      break;
+    case fuchsia::ui::gfx::ValueType::kFactoredTransform:
+      /* variable = fxl::MakeRefCounted<TransformVariable>(session, id); */
+      variable = nullptr;
+      break;
+    case fuchsia::ui::gfx::ValueType::kNone:
+      break;
+  }
+  if (variable && variable->SetValue(args.initial_value)) {
+    return variable;
+  }
+  return nullptr;
+}
+
+ResourcePtr GfxCommandApplier::CreateLayer(Session* session, ResourceId id,
+                                           fuchsia::ui::gfx::LayerArgs args) {
+  return fxl::MakeRefCounted<Layer>(session, id);
+}
+
+ResourcePtr GfxCommandApplier::CreateCircle(Session* session, ResourceId id,
+                                            float initial_radius) {
+  return fxl::MakeRefCounted<CircleShape>(session, id, initial_radius);
+}
+
+ResourcePtr GfxCommandApplier::CreateRectangle(Session* session, ResourceId id,
+                                               float width, float height) {
+  return fxl::MakeRefCounted<RectangleShape>(session, id, width, height);
+}
+
+ResourcePtr GfxCommandApplier::CreateRoundedRectangle(
+    Session* session, CommandContext* command_context, ResourceId id,
+    float width, float height, float top_left_radius, float top_right_radius,
+    float bottom_right_radius, float bottom_left_radius) {
+  auto factory = session->session_context().escher_rounded_rect_factory;
+  if (!factory) {
+    session->error_reporter()->ERROR()
+        << "scenic_impl::gfx::GfxCommandApplier::CreateRoundedRectangle(): "
+           "no RoundedRectFactory available.";
+    return ResourcePtr();
+  }
+
+  // If radii sum exceeds width or height, scale them down.
+  float top_radii_sum = top_left_radius + top_right_radius;
+  float top_scale = std::min(width / top_radii_sum, 1.f);
+
+  float bottom_radii_sum = bottom_left_radius + bottom_right_radius;
+  float bottom_scale = std::min(width / bottom_radii_sum, 1.f);
+
+  float left_radii_sum = top_left_radius + bottom_left_radius;
+  float left_scale = std::min(height / left_radii_sum, 1.f);
+
+  float right_radii_sum = top_right_radius + bottom_right_radius;
+  float right_scale = std::min(height / right_radii_sum, 1.f);
+
+  top_left_radius *= std::min(top_scale, left_scale);
+  top_right_radius *= std::min(top_scale, right_scale);
+  bottom_left_radius *= std::min(bottom_scale, left_scale);
+  bottom_right_radius *= std::min(bottom_scale, right_scale);
+
+  escher::RoundedRectSpec rect_spec(width, height, top_left_radius,
+                                    top_right_radius, bottom_right_radius,
+                                    bottom_left_radius);
+  escher::MeshSpec mesh_spec{escher::MeshAttribute::kPosition2D |
+                             escher::MeshAttribute::kUV};
+
+  return fxl::MakeRefCounted<RoundedRectangleShape>(
+      session, id, rect_spec,
+      factory->NewRoundedRect(rect_spec, mesh_spec,
+                              command_context->batch_gpu_uploader()));
+}
+
+ResourcePtr GfxCommandApplier::CreateMesh(Session* session, ResourceId id) {
+  return fxl::MakeRefCounted<MeshShape>(session, id);
+}
+
+ResourcePtr GfxCommandApplier::CreateMaterial(Session* session, ResourceId id) {
+  return fxl::MakeRefCounted<Material>(session, id);
+}
+
+}  // namespace gfx
+}  // namespace scenic_impl
diff --git a/lib/ui/gfx/engine/gfx_command_applier.h b/lib/ui/gfx/engine/gfx_command_applier.h
new file mode 100644
index 0000000..a3cdfed
--- /dev/null
+++ b/lib/ui/gfx/engine/gfx_command_applier.h
@@ -0,0 +1,281 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GARNET_LIB_UI_GFX_ENGINE_GFX_COMMAND_APPLIER_H_
+#define GARNET_LIB_UI_GFX_ENGINE_GFX_COMMAND_APPLIER_H_
+
+#include "garnet/lib/ui/gfx/engine/resource_map.h"
+#include "garnet/lib/ui/gfx/engine/session_context.h"
+#include "garnet/lib/ui/gfx/id.h"
+#include "garnet/lib/ui/gfx/resources/import.h"
+#include "garnet/lib/ui/gfx/resources/memory.h"
+#include "garnet/lib/ui/gfx/resources/resource.h"
+#include "garnet/lib/ui/gfx/resources/resource_context.h"
+#include "garnet/lib/ui/scenic/event_reporter.h"
+#include "garnet/lib/ui/scenic/util/error_reporter.h"
+#include "garnet/lib/ui/scenic/util/print_command.h"
+#include "lib/escher/flib/fence_set_listener.h"
+#include "lib/fxl/memory/weak_ptr.h"
+#include "lib/fxl/tasks/task_runner.h"
+
+namespace scenic_impl {
+namespace gfx {
+
+class Image;
+using ImagePtr = fxl::RefPtr<Image>;
+
+class ImageBase;
+using ImageBasePtr = fxl::RefPtr<ImageBase>;
+
+class ImagePipe;
+using ImagePipePtr = fxl::RefPtr<ImagePipe>;
+
+class CommandContext;
+class Session;
+
+// Responsible for applying gfx commands to sessions.
+// Does not own any state. The session to be modified is instead
+// passed in as an argument to ApplyCommand.
+class GfxCommandApplier {
+ public:
+  // Apply the operation to the current session state.  Return true if
+  // successful, and false if the op is somehow invalid.  In the latter case,
+  // the Session is left unchanged.
+  static bool ApplyCommand(Session* session, CommandContext* command_context,
+                           fuchsia::ui::gfx::Command command);
+
+ private:
+  // Return false and logs an error to the session's ErrorReporter if the value
+  // is not of the expected type.
+  // NOTE: although failure does not halt execution of the program,
+  // it does indicate client error, and will be used by the caller
+  // to tear down the Session.
+  static bool AssertValueIsOfType(const fuchsia::ui::gfx::Value& value,
+                                  const fuchsia::ui::gfx::Value::Tag* tags,
+                                  size_t tag_count, Session* session);
+  template <size_t N>
+  static bool AssertValueIsOfType(
+      const fuchsia::ui::gfx::Value& value,
+      const std::array<fuchsia::ui::gfx::Value::Tag, N>& tags,
+      Session* session) {
+    return AssertValueIsOfType(value, tags.data(), N, session);
+  }
+
+  // Functions for applying specific Commands. Called by ApplyCommand().
+  static bool ApplyCreateResourceCmd(
+      Session* session, CommandContext* command_context,
+      fuchsia::ui::gfx::CreateResourceCmd command);
+  static bool ApplyReleaseResourceCmd(
+      Session* session, fuchsia::ui::gfx::ReleaseResourceCmd command);
+  static bool ApplyExportResourceCmd(
+      Session* session, fuchsia::ui::gfx::ExportResourceCmd command);
+  static bool ApplyImportResourceCmd(
+      Session* session, fuchsia::ui::gfx::ImportResourceCmd command);
+  static bool ApplyAddChildCmd(Session* session,
+                               fuchsia::ui::gfx::AddChildCmd command);
+  static bool ApplyAddPartCmd(Session* session,
+                              fuchsia::ui::gfx::AddPartCmd command);
+  static bool ApplyDetachCmd(Session* session,
+                             fuchsia::ui::gfx::DetachCmd command);
+  static bool ApplyDetachChildrenCmd(
+      Session* session, fuchsia::ui::gfx::DetachChildrenCmd command);
+  static bool ApplySetTagCmd(Session* session,
+                             fuchsia::ui::gfx::SetTagCmd command);
+  static bool ApplySetTranslationCmd(
+      Session* session, fuchsia::ui::gfx::SetTranslationCmd command);
+  static bool ApplySetScaleCmd(Session* session,
+                               fuchsia::ui::gfx::SetScaleCmd command);
+  static bool ApplySetRotationCmd(Session* session,
+                                  fuchsia::ui::gfx::SetRotationCmd command);
+  static bool ApplySetAnchorCmd(Session* session,
+                                fuchsia::ui::gfx::SetAnchorCmd command);
+  static bool ApplySetSizeCmd(Session* session,
+                              fuchsia::ui::gfx::SetSizeCmd command);
+  static bool ApplySetOpacityCmd(Session* session,
+                                 fuchsia::ui::gfx::SetOpacityCmd command);
+  static bool ApplySendSizeChangeHintCmd(
+      Session* session, fuchsia::ui::gfx::SendSizeChangeHintCmdHACK command);
+  static bool ApplySetShapeCmd(Session* session,
+                               fuchsia::ui::gfx::SetShapeCmd command);
+  static bool ApplySetMaterialCmd(Session* session,
+                                  fuchsia::ui::gfx::SetMaterialCmd command);
+  static bool ApplySetClipCmd(Session* session,
+                              fuchsia::ui::gfx::SetClipCmd command);
+  static bool ApplySetViewPropertiesCmd(
+      Session* session, fuchsia::ui::gfx::SetViewPropertiesCmd command);
+  static bool ApplySetHitTestBehaviorCmd(
+      Session* session, fuchsia::ui::gfx::SetHitTestBehaviorCmd command);
+  static bool ApplySetCameraCmd(Session* session,
+                                fuchsia::ui::gfx::SetCameraCmd command);
+  static bool ApplySetCameraTransformCmd(
+      Session* session, fuchsia::ui::gfx::SetCameraTransformCmd command);
+  static bool ApplySetCameraProjectionCmd(
+      Session* session, fuchsia::ui::gfx::SetCameraProjectionCmd command);
+  static bool ApplySetStereoCameraProjectionCmd(
+      Session* session, fuchsia::ui::gfx::SetStereoCameraProjectionCmd command);
+  static bool ApplySetCameraPoseBufferCmd(
+      Session* session, fuchsia::ui::gfx::SetCameraPoseBufferCmd command);
+  static bool ApplySetLightColorCmd(Session* session,
+                                    fuchsia::ui::gfx::SetLightColorCmd command);
+  static bool ApplySetLightDirectionCmd(
+      Session* session, fuchsia::ui::gfx::SetLightDirectionCmd command);
+  static bool ApplyAddLightCmd(Session* session,
+                               fuchsia::ui::gfx::AddLightCmd command);
+  static bool ApplyDetachLightCmd(Session* session,
+                                  fuchsia::ui::gfx::DetachLightCmd command);
+  static bool ApplyDetachLightsCmd(Session* session,
+                                   fuchsia::ui::gfx::DetachLightsCmd command);
+  static bool ApplySetTextureCmd(Session* session,
+                                 fuchsia::ui::gfx::SetTextureCmd command);
+  static bool ApplySetColorCmd(Session* session,
+                               fuchsia::ui::gfx::SetColorCmd command);
+  static bool ApplyBindMeshBuffersCmd(
+      Session* session, fuchsia::ui::gfx::BindMeshBuffersCmd command);
+  static bool ApplyAddLayerCmd(Session* session,
+                               fuchsia::ui::gfx::AddLayerCmd command);
+  static bool ApplyRemoveLayerCmd(Session* session,
+                                  fuchsia::ui::gfx::RemoveLayerCmd command);
+  static bool ApplyRemoveAllLayersCmd(
+      Session* session, fuchsia::ui::gfx::RemoveAllLayersCmd command);
+  static bool ApplySetLayerStackCmd(Session* session,
+                                    fuchsia::ui::gfx::SetLayerStackCmd command);
+  static bool ApplySetRendererCmd(Session* session,
+                                  fuchsia::ui::gfx::SetRendererCmd command);
+  static bool ApplySetRendererParamCmd(
+      Session* session, fuchsia::ui::gfx::SetRendererParamCmd command);
+  static bool ApplySetEventMaskCmd(Session* session,
+                                   fuchsia::ui::gfx::SetEventMaskCmd command);
+  static bool ApplySetLabelCmd(Session* session,
+                               fuchsia::ui::gfx::SetLabelCmd command);
+  static bool ApplySetDisableClippingCmd(
+      Session* session, fuchsia::ui::gfx::SetDisableClippingCmd command);
+
+  // Resource creation functions, called by ApplyCreateResourceCmd(Session*
+  // session, ).
+  static bool ApplyCreateMemory(Session* session, ResourceId id,
+                                fuchsia::ui::gfx::MemoryArgs args);
+  static bool ApplyCreateImage(Session* session, ResourceId id,
+                               fuchsia::ui::gfx::ImageArgs args);
+  static bool ApplyCreateImagePipe(Session* session, ResourceId id,
+                                   fuchsia::ui::gfx::ImagePipeArgs args);
+  static bool ApplyCreateBuffer(Session* session, ResourceId id,
+                                fuchsia::ui::gfx::BufferArgs args);
+  static bool ApplyCreateScene(Session* session, ResourceId id,
+                               fuchsia::ui::gfx::SceneArgs args);
+  static bool ApplyCreateCamera(Session* session, ResourceId id,
+                                fuchsia::ui::gfx::CameraArgs args);
+  static bool ApplyCreateStereoCamera(Session* session, ResourceId id,
+                                      fuchsia::ui::gfx::StereoCameraArgs args);
+  static bool ApplyCreateRenderer(Session* session, ResourceId id,
+                                  fuchsia::ui::gfx::RendererArgs args);
+  static bool ApplyCreateAmbientLight(Session* session, ResourceId id,
+                                      fuchsia::ui::gfx::AmbientLightArgs args);
+  static bool ApplyCreateDirectionalLight(
+      Session* session, ResourceId id,
+      fuchsia::ui::gfx::DirectionalLightArgs args);
+  static bool ApplyCreateRectangle(Session* session, ResourceId id,
+                                   fuchsia::ui::gfx::RectangleArgs args);
+  static bool ApplyCreateRoundedRectangle(
+      Session* session, CommandContext* command_context, ResourceId id,
+      fuchsia::ui::gfx::RoundedRectangleArgs args);
+  static bool ApplyCreateCircle(Session* session, ResourceId id,
+                                fuchsia::ui::gfx::CircleArgs args);
+  static bool ApplyCreateMesh(Session* session, ResourceId id,
+                              fuchsia::ui::gfx::MeshArgs args);
+  static bool ApplyCreateMaterial(Session* session, ResourceId id,
+                                  fuchsia::ui::gfx::MaterialArgs args);
+  static bool ApplyCreateView(Session* session, ResourceId id,
+                              fuchsia::ui::gfx::ViewArgs args);
+  static bool ApplyCreateViewHolder(Session* session, ResourceId id,
+                                    fuchsia::ui::gfx::ViewHolderArgs args);
+  static bool ApplyCreateClipNode(Session* session, ResourceId id,
+                                  fuchsia::ui::gfx::ClipNodeArgs args);
+  static bool ApplyCreateEntityNode(Session* session, ResourceId id,
+                                    fuchsia::ui::gfx::EntityNodeArgs args);
+  static bool ApplyCreateOpacityNode(Session* session, ResourceId id,
+                                     fuchsia::ui::gfx::OpacityNodeArgs args);
+  static bool ApplyCreateShapeNode(Session* session, ResourceId id,
+                                   fuchsia::ui::gfx::ShapeNodeArgs args);
+  static bool ApplyCreateCompositor(Session* session, ResourceId id,
+                                    fuchsia::ui::gfx::CompositorArgs args);
+  static bool ApplyCreateDisplayCompositor(
+      Session* session, ResourceId id,
+      fuchsia::ui::gfx::DisplayCompositorArgs args);
+  static bool ApplyCreateImagePipeCompositor(
+      Session* session, ResourceId id,
+      fuchsia::ui::gfx::ImagePipeCompositorArgs args);
+  static bool ApplyCreateLayerStack(Session* session, ResourceId id,
+                                    fuchsia::ui::gfx::LayerStackArgs args);
+  static bool ApplyCreateLayer(Session* session, ResourceId id,
+                               fuchsia::ui::gfx::LayerArgs args);
+  static bool ApplyCreateVariable(Session* session, ResourceId id,
+                                  fuchsia::ui::gfx::VariableArgs args);
+  static bool ApplyTakeSnapshotCmdHACK(
+      Session* session, fuchsia::ui::gfx::TakeSnapshotCmdHACK command);
+
+  // Actually create resources.
+  static ResourcePtr CreateMemory(Session* session, ResourceId id,
+                                  fuchsia::ui::gfx::MemoryArgs args);
+  static ResourcePtr CreateImage(Session* session, ResourceId id,
+                                 MemoryPtr memory,
+                                 fuchsia::ui::gfx::ImageArgs args);
+  static ResourcePtr CreateBuffer(Session* session, ResourceId id,
+                                  MemoryPtr memory, uint32_t memory_offset,
+                                  uint32_t num_bytes);
+
+  static ResourcePtr CreateScene(Session* session, ResourceId id,
+                                 fuchsia::ui::gfx::SceneArgs args);
+  static ResourcePtr CreateCamera(Session* session, ResourceId id,
+                                  fuchsia::ui::gfx::CameraArgs args);
+  static ResourcePtr CreateStereoCamera(
+      Session* session, ResourceId id, fuchsia::ui::gfx::StereoCameraArgs args);
+  static ResourcePtr CreateRenderer(Session* session, ResourceId id,
+                                    fuchsia::ui::gfx::RendererArgs args);
+
+  static ResourcePtr CreateAmbientLight(Session* session, ResourceId id);
+  static ResourcePtr CreateDirectionalLight(Session* session, ResourceId id);
+
+  static ResourcePtr CreateView(Session* session, ResourceId id,
+                                fuchsia::ui::gfx::ViewArgs args);
+  static ResourcePtr CreateViewHolder(Session* session, ResourceId id,
+                                      fuchsia::ui::gfx::ViewHolderArgs args);
+  static ResourcePtr CreateClipNode(Session* session, ResourceId id,
+                                    fuchsia::ui::gfx::ClipNodeArgs args);
+  static ResourcePtr CreateEntityNode(Session* session, ResourceId id,
+                                      fuchsia::ui::gfx::EntityNodeArgs args);
+  static ResourcePtr CreateOpacityNode(Session* session, ResourceId id,
+                                       fuchsia::ui::gfx::OpacityNodeArgs args);
+  static ResourcePtr CreateShapeNode(Session* session, ResourceId id,
+                                     fuchsia::ui::gfx::ShapeNodeArgs args);
+
+  static ResourcePtr CreateCompositor(Session* session, ResourceId id,
+                                      fuchsia::ui::gfx::CompositorArgs args);
+  static ResourcePtr CreateDisplayCompositor(
+      Session* session, ResourceId id,
+      fuchsia::ui::gfx::DisplayCompositorArgs args);
+  static ResourcePtr CreateImagePipeCompositor(
+      Session* session, ResourceId id,
+      fuchsia::ui::gfx::ImagePipeCompositorArgs args);
+  static ResourcePtr CreateLayerStack(Session* session, ResourceId id,
+                                      fuchsia::ui::gfx::LayerStackArgs args);
+  static ResourcePtr CreateLayer(Session* session, ResourceId id,
+                                 fuchsia::ui::gfx::LayerArgs args);
+  static ResourcePtr CreateCircle(Session* session, ResourceId id,
+                                  float initial_radius);
+  static ResourcePtr CreateRectangle(Session* session, ResourceId id,
+                                     float width, float height);
+  static ResourcePtr CreateRoundedRectangle(
+      Session* session, CommandContext* command_context, ResourceId id,
+      float width, float height, float top_left_radius, float top_right_radius,
+      float bottom_right_radius, float bottom_left_radius);
+  static ResourcePtr CreateMesh(Session* session, ResourceId id);
+  static ResourcePtr CreateMaterial(Session* session, ResourceId id);
+  static ResourcePtr CreateVariable(Session* session, ResourceId id,
+                                    fuchsia::ui::gfx::VariableArgs args);
+};
+
+}  // namespace gfx
+}  // namespace scenic_impl
+
+#endif  // GARNET_LIB_UI_GFX_ENGINE_GFX_COMMAND_APPLIER_H_
diff --git a/lib/ui/gfx/engine/session.cc b/lib/ui/gfx/engine/session.cc
index 6db1eef..02db4d8 100644
--- a/lib/ui/gfx/engine/session.cc
+++ b/lib/ui/gfx/engine/session.cc
@@ -11,34 +11,11 @@
 #include <lib/async/default.h>
 #include <trace/event.h>
 
+#include "garnet/lib/ui/gfx/engine/gfx_command_applier.h"
 #include "garnet/lib/ui/gfx/engine/hit_tester.h"
 #include "garnet/lib/ui/gfx/engine/session_handler.h"
-#include "garnet/lib/ui/gfx/resources/buffer.h"
-#include "garnet/lib/ui/gfx/resources/camera.h"
-#include "garnet/lib/ui/gfx/resources/compositor/display_compositor.h"
-#include "garnet/lib/ui/gfx/resources/compositor/layer.h"
 #include "garnet/lib/ui/gfx/resources/compositor/layer_stack.h"
-#include "garnet/lib/ui/gfx/resources/image.h"
 #include "garnet/lib/ui/gfx/resources/image_pipe.h"
-#include "garnet/lib/ui/gfx/resources/image_pipe_handler.h"
-#include "garnet/lib/ui/gfx/resources/lights/ambient_light.h"
-#include "garnet/lib/ui/gfx/resources/lights/directional_light.h"
-#include "garnet/lib/ui/gfx/resources/memory.h"
-#include "garnet/lib/ui/gfx/resources/nodes/entity_node.h"
-#include "garnet/lib/ui/gfx/resources/nodes/node.h"
-#include "garnet/lib/ui/gfx/resources/nodes/opacity_node.h"
-#include "garnet/lib/ui/gfx/resources/nodes/scene.h"
-#include "garnet/lib/ui/gfx/resources/nodes/shape_node.h"
-#include "garnet/lib/ui/gfx/resources/renderers/renderer.h"
-#include "garnet/lib/ui/gfx/resources/shapes/circle_shape.h"
-#include "garnet/lib/ui/gfx/resources/shapes/mesh_shape.h"
-#include "garnet/lib/ui/gfx/resources/shapes/rectangle_shape.h"
-#include "garnet/lib/ui/gfx/resources/shapes/rounded_rectangle_shape.h"
-#include "garnet/lib/ui/gfx/resources/snapshot/snapshotter.h"
-#include "garnet/lib/ui/gfx/resources/stereo_camera.h"
-#include "garnet/lib/ui/gfx/resources/variable.h"
-#include "garnet/lib/ui/gfx/resources/view.h"
-#include "garnet/lib/ui/gfx/resources/view_holder.h"
 #include "garnet/lib/ui/gfx/swapchain/swapchain_factory.h"
 #include "garnet/lib/ui/gfx/util/time.h"
 #include "garnet/lib/ui/gfx/util/unwrap.h"
@@ -55,14 +32,6 @@
 
 namespace {
 
-// Makes it convenient to check that a value is constant and of a specific type,
-// or a variable.
-// TODO: There should also be a convenient way of type-checking a variable;
-// this will necessarily involve looking up the value in the ResourceMap.
-constexpr std::array<::fuchsia::ui::gfx::Value::Tag, 2> kFloatValueTypes{
-    {::fuchsia::ui::gfx::Value::Tag::kVector1,
-     ::fuchsia::ui::gfx::Value::Tag::kVariableId}};
-
 // Converts the provided vector of Hits into a fidl array of HitPtrs.
 fidl::VectorPtr<::fuchsia::ui::gfx::Hit> WrapHits(
     const std::vector<Hit>& hits) {
@@ -96,1332 +65,19 @@
                          session_context_.escher_resource_recycler,
                          session_context_.escher_image_factory,
                          session_context_.escher_gpu_uploader}),
-      resources_(error_reporter),
+      resources_(error_reporter_),
       weak_factory_(this) {
   FXL_DCHECK(error_reporter);
 }
 
-Session::~Session() { FXL_DCHECK(!is_valid_); }
-
-bool Session::ApplyCommand(CommandContext* command_context,
-                           ::fuchsia::ui::gfx::Command command) {
-  TRACE_DURATION("gfx", "Session::ApplyCommand");
-  switch (command.Which()) {
-    case ::fuchsia::ui::gfx::Command::Tag::kCreateResource:
-      return ApplyCreateResourceCmd(command_context,
-                                    std::move(command.create_resource()));
-    case ::fuchsia::ui::gfx::Command::Tag::kReleaseResource:
-      return ApplyReleaseResourceCmd(std::move(command.release_resource()));
-    case ::fuchsia::ui::gfx::Command::Tag::kExportResource:
-      return ApplyExportResourceCmd(std::move(command.export_resource()));
-    case ::fuchsia::ui::gfx::Command::Tag::kImportResource:
-      return ApplyImportResourceCmd(std::move(command.import_resource()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetImportFocus: {
-      // TODO(SCN-1026): Remove this.
-      if (auto import = resources_.FindResource<Import>(
-              command.set_import_focus().id,
-              ResourceMap::ErrorBehavior::kDontReportErrors)) {
-        import->set_focusable(command.set_import_focus().focusable);
-        return true;
-      }
-      return false;
-    }
-    case ::fuchsia::ui::gfx::Command::Tag::kAddChild:
-      return ApplyAddChildCmd(std::move(command.add_child()));
-    case ::fuchsia::ui::gfx::Command::Tag::kAddPart:
-      return ApplyAddPartCmd(std::move(command.add_part()));
-    case ::fuchsia::ui::gfx::Command::Tag::kDetach:
-      return ApplyDetachCmd(std::move(command.detach()));
-    case ::fuchsia::ui::gfx::Command::Tag::kDetachChildren:
-      return ApplyDetachChildrenCmd(std::move(command.detach_children()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetTag:
-      return ApplySetTagCmd(std::move(command.set_tag()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetTranslation:
-      return ApplySetTranslationCmd(std::move(command.set_translation()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetScale:
-      return ApplySetScaleCmd(std::move(command.set_scale()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetRotation:
-      return ApplySetRotationCmd(std::move(command.set_rotation()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetAnchor:
-      return ApplySetAnchorCmd(std::move(command.set_anchor()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetSize:
-      return ApplySetSizeCmd(std::move(command.set_size()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetOpacity:
-      return ApplySetOpacityCmd(command.set_opacity());
-    case ::fuchsia::ui::gfx::Command::Tag::kSendSizeChangeHintHack:
-      return ApplySendSizeChangeHintCmd(command.send_size_change_hint_hack());
-    case ::fuchsia::ui::gfx::Command::Tag::kSetShape:
-      return ApplySetShapeCmd(std::move(command.set_shape()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetMaterial:
-      return ApplySetMaterialCmd(std::move(command.set_material()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetClip:
-      return ApplySetClipCmd(std::move(command.set_clip()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetHitTestBehavior:
-      return ApplySetHitTestBehaviorCmd(
-          std::move(command.set_hit_test_behavior()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetViewProperties:
-      return ApplySetViewPropertiesCmd(
-          std::move(command.set_view_properties()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetCamera:
-      return ApplySetCameraCmd(std::move(command.set_camera()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetCameraTransform:
-      return ApplySetCameraTransformCmd(
-          std::move(command.set_camera_transform()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetCameraProjection:
-      return ApplySetCameraProjectionCmd(
-          std::move(command.set_camera_projection()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetStereoCameraProjection:
-      return ApplySetStereoCameraProjectionCmd(
-          std::move(command.set_stereo_camera_projection()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetCameraPoseBuffer:
-      return ApplySetCameraPoseBufferCmd(
-          std::move(command.set_camera_pose_buffer()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetLightColor:
-      return ApplySetLightColorCmd(std::move(command.set_light_color()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetLightDirection:
-      return ApplySetLightDirectionCmd(
-          std::move(command.set_light_direction()));
-    case ::fuchsia::ui::gfx::Command::Tag::kAddLight:
-      return ApplyAddLightCmd(std::move(command.add_light()));
-    case ::fuchsia::ui::gfx::Command::Tag::kDetachLight:
-      return ApplyDetachLightCmd(std::move(command.detach_light()));
-    case ::fuchsia::ui::gfx::Command::Tag::kDetachLights:
-      return ApplyDetachLightsCmd(std::move(command.detach_lights()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetTexture:
-      return ApplySetTextureCmd(std::move(command.set_texture()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetColor:
-      return ApplySetColorCmd(std::move(command.set_color()));
-    case ::fuchsia::ui::gfx::Command::Tag::kBindMeshBuffers:
-      return ApplyBindMeshBuffersCmd(std::move(command.bind_mesh_buffers()));
-    case ::fuchsia::ui::gfx::Command::Tag::kAddLayer:
-      return ApplyAddLayerCmd(std::move(command.add_layer()));
-    case ::fuchsia::ui::gfx::Command::Tag::kRemoveLayer:
-      return ApplyRemoveLayerCmd(std::move(command.remove_layer()));
-    case ::fuchsia::ui::gfx::Command::Tag::kRemoveAllLayers:
-      return ApplyRemoveAllLayersCmd(std::move(command.remove_all_layers()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetLayerStack:
-      return ApplySetLayerStackCmd(std::move(command.set_layer_stack()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetRenderer:
-      return ApplySetRendererCmd(std::move(command.set_renderer()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetRendererParam:
-      return ApplySetRendererParamCmd(std::move(command.set_renderer_param()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetEventMask:
-      return ApplySetEventMaskCmd(std::move(command.set_event_mask()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetLabel:
-      return ApplySetLabelCmd(std::move(command.set_label()));
-    case ::fuchsia::ui::gfx::Command::Tag::kSetDisableClipping:
-      return ApplySetDisableClippingCmd(
-          std::move(command.set_disable_clipping()));
-    case ::fuchsia::ui::gfx::Command::Tag::kTakeSnapshotCmd:
-      return ApplyTakeSnapshotCmdHACK(std::move(command.take_snapshot_cmd()));
-    case ::fuchsia::ui::gfx::Command::Tag::Invalid:
-      // FIDL validation should make this impossible.
-      FXL_CHECK(false);
-      return false;
-  }
-}
-
-bool Session::ApplyCreateResourceCmd(
-    CommandContext* command_context,
-    ::fuchsia::ui::gfx::CreateResourceCmd command) {
-  const ResourceId id = command.id;
-  if (id == 0) {
-    using ::operator<<;  // From print_commands.h
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplyCreateResourceCmd(): invalid ID: "
-        << command;
-    return false;
-  }
-
-  switch (command.resource.Which()) {
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kMemory:
-      return ApplyCreateMemory(id, std::move(command.resource.memory()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kImage:
-      return ApplyCreateImage(id, std::move(command.resource.image()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kImagePipe:
-      return ApplyCreateImagePipe(id, std::move(command.resource.image_pipe()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kBuffer:
-      return ApplyCreateBuffer(id, std::move(command.resource.buffer()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kScene:
-      return ApplyCreateScene(id, std::move(command.resource.scene()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kCamera:
-      return ApplyCreateCamera(id, std::move(command.resource.camera()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kStereoCamera:
-      return ApplyCreateStereoCamera(
-          id, std::move(command.resource.stereo_camera()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kRenderer:
-      return ApplyCreateRenderer(id, std::move(command.resource.renderer()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kAmbientLight:
-      return ApplyCreateAmbientLight(
-          id, std::move(command.resource.ambient_light()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kDirectionalLight:
-      return ApplyCreateDirectionalLight(
-          id, std::move(command.resource.directional_light()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kRectangle:
-      return ApplyCreateRectangle(id, std::move(command.resource.rectangle()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kRoundedRectangle:
-      return ApplyCreateRoundedRectangle(
-          command_context, id, std::move(command.resource.rounded_rectangle()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kCircle:
-      return ApplyCreateCircle(id, std::move(command.resource.circle()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kMesh:
-      return ApplyCreateMesh(id, std::move(command.resource.mesh()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kMaterial:
-      return ApplyCreateMaterial(id, std::move(command.resource.material()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kView:
-      return ApplyCreateView(id, std::move(command.resource.view()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kViewHolder:
-      return ApplyCreateViewHolder(id,
-                                   std::move(command.resource.view_holder()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kClipNode:
-      return ApplyCreateClipNode(id, std::move(command.resource.clip_node()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kOpacityNode:
-      return ApplyCreateOpacityNode(id, command.resource.opacity_node());
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kEntityNode:
-      return ApplyCreateEntityNode(id,
-                                   std::move(command.resource.entity_node()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kShapeNode:
-      return ApplyCreateShapeNode(id, std::move(command.resource.shape_node()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kCompositor:
-      return ApplyCreateCompositor(id,
-                                   std::move(command.resource.compositor()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kDisplayCompositor:
-      return ApplyCreateDisplayCompositor(
-          id, std::move(command.resource.display_compositor()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kImagePipeCompositor:
-      return ApplyCreateImagePipeCompositor(
-          id, std::move(command.resource.image_pipe_compositor()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kLayerStack:
-      return ApplyCreateLayerStack(id,
-                                   std::move(command.resource.layer_stack()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kLayer:
-      return ApplyCreateLayer(id, std::move(command.resource.layer()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::kVariable:
-      return ApplyCreateVariable(id, std::move(command.resource.variable()));
-    case ::fuchsia::ui::gfx::ResourceArgs::Tag::Invalid:
-      // FIDL validation should make this impossible.
-      FXL_CHECK(false);
-      return false;
-  }
-}
-
-bool Session::ApplyReleaseResourceCmd(
-    ::fuchsia::ui::gfx::ReleaseResourceCmd command) {
-  return resources_.RemoveResource(command.id);
-}
-
-bool Session::ApplyExportResourceCmd(
-    ::fuchsia::ui::gfx::ExportResourceCmd command) {
-  if (!command.token) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplyExportResourceCmd(): "
-           "no token provided.";
-    return false;
-  }
-  if (auto resource = resources_.FindResource<Resource>(command.id)) {
-    return session_context_.resource_linker->ExportResource(
-        resource.get(), std::move(command.token));
-  }
-  return false;
-}
-
-bool Session::ApplyImportResourceCmd(
-    ::fuchsia::ui::gfx::ImportResourceCmd command) {
-  if (!command.token) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplyImportResourceCmd(): "
-           "no token provided.";
-    return false;
-  }
-  ImportPtr import = fxl::MakeRefCounted<Import>(
-      this, command.id, command.spec,
-      session_context_.resource_linker->GetWeakPtr());
-  return session_context_.resource_linker->ImportResource(
-             import.get(), command.spec, std::move(command.token)) &&
-         resources_.AddResource(command.id, std::move(import));
-}
-
-bool Session::ApplyAddChildCmd(::fuchsia::ui::gfx::AddChildCmd command) {
-  // Find the parent and child nodes. We can add:
-  // - Nodes to Nodes
-  // - ViewHolders to Nodes
-  // - Nodes to Views
-  // TODO(SCN-795): Split these out into separate commands?
-  if (auto parent = resources_.FindResource<Node>(
-          command.node_id, ResourceMap::ErrorBehavior::kDontReportErrors)) {
-    if (auto child = resources_.FindResource<Node>(
-            command.child_id, ResourceMap::ErrorBehavior::kDontReportErrors)) {
-      return parent->AddChild(std::move(child));
-    } else if (auto child =
-                   resources_.FindResource<ViewHolder>(command.child_id)) {
-      return parent->AddViewHolder(std::move(child));
-    }
-  } else if (auto parent = resources_.FindResource<View>(command.node_id)) {
-    if (auto child = resources_.FindResource<Node>(command.child_id)) {
-      return parent->AddChild(std::move(child));
-    }
-  }
-  return false;
-}
-
-bool Session::ApplyAddPartCmd(::fuchsia::ui::gfx::AddPartCmd command) {
-  // Find the parent and part nodes.
-  if (auto parent_node = resources_.FindResource<Node>(command.node_id)) {
-    if (auto part_node = resources_.FindResource<Node>(command.part_id)) {
-      return parent_node->AddPart(std::move(part_node));
-    }
-  }
-  return false;
-}
-
-bool Session::ApplyTakeSnapshotCmdHACK(
-    ::fuchsia::ui::gfx::TakeSnapshotCmdHACK command) {
-  async::PostTask(
-      async_get_default_dispatcher(), [weak = weak_factory_.GetWeakPtr(),
-                                       command = std::move(command)]() mutable {
-        if (!weak) {
-          if (auto callback = command.callback.Bind()) {
-            // TODO(SCN-978): Return an error to the caller for invalid data.
-            callback->OnData(fuchsia::mem::Buffer{});
-          }
-          return;
-        }
-
-        const auto& context = weak->session_context_;
-        Resource* resource = nullptr;
-        if (auto node = weak->resources_.FindResource<Node>(command.node_id)) {
-          resource = node.get();
-        } else if (command.node_id == 0) {
-          // TODO(SCN-1170): get rid of SceneGraph::first_compositor().
-          const auto& first_compositor_weak =
-              context.scene_graph->first_compositor();
-          if (first_compositor_weak) {
-            resource = first_compositor_weak.get();
-          }
-        }
-
-        if (resource == nullptr) {
-          if (auto callback = command.callback.Bind()) {
-            callback->OnData(fuchsia::mem::Buffer{});
-          }
-          return;
-        }
-
-        auto gpu_uploader =
-            escher::BatchGpuUploader::New(context.escher->GetWeakPtr());
-        Snapshotter snapshotter(gpu_uploader);
-        // Take a snapshot and return the data in callback. The closure does
-        // not need the snapshotter instance and is invoked after the instance
-        // is destroyed.
-        snapshotter.TakeSnapshot(resource, [callback = command.callback.Bind()](
-                                               fuchsia::mem::Buffer snapshot) {
-          callback->OnData(std::move(snapshot));
-        });
-      });
-  return true;
-}
-
-bool Session::ApplyDetachCmd(::fuchsia::ui::gfx::DetachCmd command) {
-  if (auto resource = resources_.FindResource<Resource>(command.id)) {
-    return resource->Detach();
-  }
-  return false;
-}
-
-bool Session::ApplyDetachChildrenCmd(
-    ::fuchsia::ui::gfx::DetachChildrenCmd command) {
-  if (auto node = resources_.FindResource<Node>(command.node_id)) {
-    return node->DetachChildren();
-  }
-  return false;
-}
-
-bool Session::ApplySetTagCmd(::fuchsia::ui::gfx::SetTagCmd command) {
-  if (auto node = resources_.FindResource<Node>(command.node_id)) {
-    return node->SetTagValue(command.tag_value);
-  }
-  return false;
-}
-
-bool Session::ApplySetTranslationCmd(
-    ::fuchsia::ui::gfx::SetTranslationCmd command) {
-  if (auto node = resources_.FindResource<Node>(command.id)) {
-    if (IsVariable(command.value)) {
-      if (auto variable = resources_.FindVariableResource<Vector3Variable>(
-              command.value.variable_id)) {
-        return node->SetTranslation(variable);
-      }
-    } else {
-      return node->SetTranslation(UnwrapVector3(command.value));
-    }
-  }
-  return false;
-}
-
-bool Session::ApplySetScaleCmd(::fuchsia::ui::gfx::SetScaleCmd command) {
-  if (auto node = resources_.FindResource<Node>(command.id)) {
-    if (IsVariable(command.value)) {
-      if (auto variable = resources_.FindVariableResource<Vector3Variable>(
-              command.value.variable_id)) {
-        return node->SetScale(variable);
-      }
-    } else {
-      return node->SetScale(UnwrapVector3(command.value));
-    }
-  }
-  return false;
-}
-
-bool Session::ApplySetRotationCmd(::fuchsia::ui::gfx::SetRotationCmd command) {
-  if (auto node = resources_.FindResource<Node>(command.id)) {
-    if (IsVariable(command.value)) {
-      if (auto variable = resources_.FindVariableResource<QuaternionVariable>(
-              command.value.variable_id)) {
-        return node->SetRotation(variable);
-      }
-    } else {
-      return node->SetRotation(UnwrapQuaternion(command.value));
-    }
-  }
-  return false;
-}
-
-bool Session::ApplySetAnchorCmd(::fuchsia::ui::gfx::SetAnchorCmd command) {
-  if (auto node = resources_.FindResource<Node>(command.id)) {
-    if (IsVariable(command.value)) {
-      if (auto variable = resources_.FindVariableResource<Vector3Variable>(
-              command.value.variable_id)) {
-        return node->SetAnchor(variable);
-      }
-    }
-    return node->SetAnchor(UnwrapVector3(command.value));
-  }
-  return false;
-}
-
-bool Session::ApplySetSizeCmd(::fuchsia::ui::gfx::SetSizeCmd command) {
-  if (auto layer = resources_.FindResource<Layer>(command.id)) {
-    if (IsVariable(command.value)) {
-      error_reporter_->ERROR()
-          << "scenic_impl::gfx::Session::ApplySetSizeCmd(): "
-             "unimplemented for variable value.";
-      return false;
-    }
-    return layer->SetSize(UnwrapVector2(command.value));
-  }
-  return false;
-}
-
-bool Session::ApplySetOpacityCmd(::fuchsia::ui::gfx::SetOpacityCmd command) {
-  if (auto node = resources_.FindResource<OpacityNode>(command.node_id)) {
-    node->SetOpacity(command.opacity);
-    return true;
-  }
-  return false;
-}
-
-bool Session::ApplySendSizeChangeHintCmd(
-    ::fuchsia::ui::gfx::SendSizeChangeHintCmdHACK command) {
-  if (auto node = resources_.FindResource<Node>(command.node_id)) {
-    return node->SendSizeChangeHint(command.width_change_factor,
-                                    command.height_change_factor);
-  }
-  return false;
-}
-
-bool Session::ApplySetShapeCmd(::fuchsia::ui::gfx::SetShapeCmd command) {
-  if (auto node = resources_.FindResource<ShapeNode>(command.node_id)) {
-    if (auto shape = resources_.FindResource<Shape>(command.shape_id)) {
-      node->SetShape(std::move(shape));
-      return true;
-    }
-  }
-  return false;
-}
-
-bool Session::ApplySetMaterialCmd(::fuchsia::ui::gfx::SetMaterialCmd command) {
-  if (auto node = resources_.FindResource<ShapeNode>(command.node_id)) {
-    if (auto material =
-            resources_.FindResource<Material>(command.material_id)) {
-      node->SetMaterial(std::move(material));
-      return true;
-    }
-  }
-  return false;
-}
-
-bool Session::ApplySetClipCmd(::fuchsia::ui::gfx::SetClipCmd command) {
-  if (command.clip_id != 0) {
-    // TODO(SCN-167): Support non-zero clip_id.
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetClipCmd(): only "
-           "clip_to_self is implemented.";
-    return false;
-  }
-
-  if (auto node = resources_.FindResource<Node>(command.node_id)) {
-    return node->SetClipToSelf(command.clip_to_self);
-  }
-
-  return false;
-}
-
-bool Session::ApplySetHitTestBehaviorCmd(
-    ::fuchsia::ui::gfx::SetHitTestBehaviorCmd command) {
-  if (auto node = resources_.FindResource<Node>(command.node_id)) {
-    return node->SetHitTestBehavior(command.hit_test_behavior);
-  }
-
-  return false;
-}
-
-bool Session::ApplySetViewPropertiesCmd(
-    ::fuchsia::ui::gfx::SetViewPropertiesCmd command) {
-  if (auto view_holder =
-          resources_.FindResource<ViewHolder>(command.view_holder_id)) {
-    view_holder->SetViewProperties(std::move(command.properties));
-    return true;
-  }
-  return false;
-}
-
-bool Session::ApplySetCameraCmd(::fuchsia::ui::gfx::SetCameraCmd command) {
-  if (auto renderer = resources_.FindResource<Renderer>(command.renderer_id)) {
-    if (command.camera_id == 0) {
-      renderer->SetCamera(nullptr);
-      return true;
-    } else if (auto camera =
-                   resources_.FindResource<Camera>(command.camera_id)) {
-      renderer->SetCamera(std::move(camera));
-      return true;
-    }
-  }
-  return false;
-}
-
-bool Session::ApplySetTextureCmd(::fuchsia::ui::gfx::SetTextureCmd command) {
-  if (auto material = resources_.FindResource<Material>(command.material_id)) {
-    if (command.texture_id == 0) {
-      material->SetTexture(nullptr);
-      return true;
-    } else if (auto image =
-                   resources_.FindResource<ImageBase>(command.texture_id)) {
-      material->SetTexture(std::move(image));
-      return true;
-    }
-  }
-  return false;
-}
-
-bool Session::ApplySetColorCmd(::fuchsia::ui::gfx::SetColorCmd command) {
-  if (auto material = resources_.FindResource<Material>(command.material_id)) {
-    if (IsVariable(command.color)) {
-      error_reporter_->ERROR()
-          << "scenic_impl::gfx::Session::ApplySetColorCmd(): "
-             "unimplemented for variable color.";
-      return false;
-    }
-
-    auto& color = command.color.value;
-    float red = static_cast<float>(color.red) / 255.f;
-    float green = static_cast<float>(color.green) / 255.f;
-    float blue = static_cast<float>(color.blue) / 255.f;
-    float alpha = static_cast<float>(color.alpha) / 255.f;
-    material->SetColor(red, green, blue, alpha);
-    return true;
-  }
-  return false;
-}
-
-bool Session::ApplyBindMeshBuffersCmd(
-    ::fuchsia::ui::gfx::BindMeshBuffersCmd command) {
-  auto mesh = resources_.FindResource<MeshShape>(command.mesh_id);
-  auto index_buffer = resources_.FindResource<Buffer>(command.index_buffer_id);
-  auto vertex_buffer =
-      resources_.FindResource<Buffer>(command.vertex_buffer_id);
-  if (mesh && index_buffer && vertex_buffer) {
-    return mesh->BindBuffers(std::move(index_buffer), command.index_format,
-                             command.index_offset, command.index_count,
-                             std::move(vertex_buffer), command.vertex_format,
-                             command.vertex_offset, command.vertex_count,
-                             Unwrap(command.bounding_box));
-  }
-  return false;
-}
-
-bool Session::ApplyAddLayerCmd(::fuchsia::ui::gfx::AddLayerCmd command) {
-  auto layer_stack =
-      resources_.FindResource<LayerStack>(command.layer_stack_id);
-  auto layer = resources_.FindResource<Layer>(command.layer_id);
-  if (layer_stack && layer) {
-    return layer_stack->AddLayer(std::move(layer));
-  }
-  return false;
-}
-
-bool Session::ApplyRemoveLayerCmd(::fuchsia::ui::gfx::RemoveLayerCmd command) {
-  auto layer_stack =
-      resources_.FindResource<LayerStack>(command.layer_stack_id);
-  auto layer = resources_.FindResource<Layer>(command.layer_id);
-  if (layer_stack && layer) {
-    return layer_stack->RemoveLayer(std::move(layer));
-  }
-  return false;
-}
-
-bool Session::ApplyRemoveAllLayersCmd(
-    ::fuchsia::ui::gfx::RemoveAllLayersCmd command) {
-  auto layer_stack =
-      resources_.FindResource<LayerStack>(command.layer_stack_id);
-  if (layer_stack) {
-    return layer_stack->RemoveAllLayers();
-  }
-  return false;
-}
-
-bool Session::ApplySetLayerStackCmd(
-    ::fuchsia::ui::gfx::SetLayerStackCmd command) {
-  auto compositor = resources_.FindResource<Compositor>(command.compositor_id);
-  auto layer_stack =
-      resources_.FindResource<LayerStack>(command.layer_stack_id);
-  if (compositor && layer_stack) {
-    return compositor->SetLayerStack(std::move(layer_stack));
-  }
-  return false;
-}
-
-bool Session::ApplySetRendererCmd(::fuchsia::ui::gfx::SetRendererCmd command) {
-  auto layer = resources_.FindResource<Layer>(command.layer_id);
-  auto renderer = resources_.FindResource<Renderer>(command.renderer_id);
-
-  if (layer && renderer) {
-    return layer->SetRenderer(std::move(renderer));
-  }
-  return false;
-}
-
-bool Session::ApplySetRendererParamCmd(
-    ::fuchsia::ui::gfx::SetRendererParamCmd command) {
-  auto renderer = resources_.FindResource<Renderer>(command.renderer_id);
-  if (renderer) {
-    switch (command.param.Which()) {
-      case ::fuchsia::ui::gfx::RendererParam::Tag::kShadowTechnique:
-        return renderer->SetShadowTechnique(command.param.shadow_technique());
-      case ::fuchsia::ui::gfx::RendererParam::Tag::kRenderFrequency:
-        // TODO(SCN-1169): SetRenderContinuously should only affect the
-        // compositor that has the renderer attached to it.
-        session_context_.frame_scheduler->SetRenderContinuously(
-            command.param.render_frequency() ==
-            ::fuchsia::ui::gfx::RenderFrequency::CONTINUOUSLY);
-        return true;
-      case ::fuchsia::ui::gfx::RendererParam::Tag::Invalid:
-        error_reporter_->ERROR()
-            << "scenic_impl::gfx::Session::ApplySetRendererParamCmd(): "
-               "invalid param.";
-    }
-  }
-  return false;
-}
-
-bool Session::ApplySetEventMaskCmd(
-    ::fuchsia::ui::gfx::SetEventMaskCmd command) {
-  if (auto r = resources_.FindResource<Resource>(command.id)) {
-    return r->SetEventMask(command.event_mask);
-  }
-  return false;
-}
-
-bool Session::ApplySetCameraTransformCmd(
-    ::fuchsia::ui::gfx::SetCameraTransformCmd command) {
-  // TODO(SCN-123): support variables.
-  if (IsVariable(command.eye_position) || IsVariable(command.eye_look_at) ||
-      IsVariable(command.eye_up)) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetCameraTransformCmd(): "
-           "unimplemented: variable properties.";
-    return false;
-  } else if (auto camera = resources_.FindResource<Camera>(command.camera_id)) {
-    camera->SetTransform(UnwrapVector3(command.eye_position),
-                         UnwrapVector3(command.eye_look_at),
-                         UnwrapVector3(command.eye_up));
-    return true;
-  }
-  return false;
-}
-
-bool Session::ApplySetCameraProjectionCmd(
-    ::fuchsia::ui::gfx::SetCameraProjectionCmd command) {
-  // TODO(SCN-123): support variables.
-  if (IsVariable(command.fovy)) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetCameraProjectionCmd(): "
-           "unimplemented: variable properties.";
-    return false;
-  } else if (auto camera = resources_.FindResource<Camera>(command.camera_id)) {
-    camera->SetProjection(UnwrapFloat(command.fovy));
-    return true;
-  }
-  return false;
-}
-
-bool Session::ApplySetStereoCameraProjectionCmd(
-    ::fuchsia::ui::gfx::SetStereoCameraProjectionCmd command) {
-  if (IsVariable(command.left_projection) ||
-      IsVariable(command.right_projection)) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetStereoCameraProjectionOp(): "
-           "unimplemented: variable properties.";
-    return false;
-  } else if (auto stereo_camera =
-                 resources_.FindResource<StereoCamera>(command.camera_id)) {
-    stereo_camera->SetStereoProjection(Unwrap(command.left_projection.value),
-                                       Unwrap(command.right_projection.value));
-    return true;
-  }
-  return false;
-}
-
-bool Session::ApplySetCameraPoseBufferCmd(
-    ::fuchsia::ui::gfx::SetCameraPoseBufferCmd command) {
-  if (command.base_time > dispatcher_clock_now()) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetCameraPoseBufferCmd(): "
-           "base time not in the past";
-    return false;
-  }
-
-  auto buffer = resources_.FindResource<Buffer>(command.buffer_id);
-  if (!buffer) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetCameraPoseBufferCmd(): "
-           "invalid buffer ID";
-    return false;
-  }
-
-  if (command.num_entries < 1) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetCameraPoseBufferCmd(): "
-           "must have at least one entry in the pose buffer";
-    return false;
-  }
-
-  if (buffer->size() < command.num_entries * sizeof(escher::hmd::Pose)) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetCameraPoseBufferCmd(): "
-           "buffer is not large enough";
-    return false;
-  }
-
-  auto camera = resources_.FindResource<Camera>(command.camera_id);
-  if (!camera) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetCameraPoseBufferCmd(): "
-           "invalid camera ID";
-    return false;
-  }
-
-  camera->SetPoseBuffer(buffer, command.num_entries, command.base_time,
-                        command.time_interval);
-
-  return true;
-}
-
-bool Session::ApplySetLightColorCmd(
-    ::fuchsia::ui::gfx::SetLightColorCmd command) {
-  // TODO(SCN-123): support variables.
-  if (command.color.variable_id) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetLightColorCmd(): "
-           "unimplemented: variable color.";
-    return false;
-  } else if (auto light = resources_.FindResource<Light>(command.light_id)) {
-    return light->SetColor(Unwrap(command.color.value));
-  }
-  return false;
-}
-
-bool Session::ApplySetLightDirectionCmd(
-    ::fuchsia::ui::gfx::SetLightDirectionCmd command) {
-  // TODO(SCN-123): support variables.
-  if (command.direction.variable_id) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplySetLightDirectionCmd(): "
-           "unimplemented: variable direction.";
-    return false;
-  } else if (auto light =
-                 resources_.FindResource<DirectionalLight>(command.light_id)) {
-    return light->SetDirection(Unwrap(command.direction.value));
-  }
-  return false;
-}
-
-bool Session::ApplyAddLightCmd(::fuchsia::ui::gfx::AddLightCmd command) {
-  if (auto scene = resources_.FindResource<Scene>(command.scene_id)) {
-    if (auto light = resources_.FindResource<Light>(command.light_id)) {
-      return scene->AddLight(std::move(light));
-    }
-  }
-
-  error_reporter_->ERROR()
-      << "scenic_impl::gfx::Session::ApplyAddLightCmd(): unimplemented.";
-  return false;
-}
-
-bool Session::ApplyDetachLightCmd(::fuchsia::ui::gfx::DetachLightCmd command) {
-  error_reporter_->ERROR()
-      << "scenic_impl::gfx::Session::ApplyDetachLightCmd(): unimplemented.";
-  return false;
-}
-
-bool Session::ApplyDetachLightsCmd(
-    ::fuchsia::ui::gfx::DetachLightsCmd command) {
-  error_reporter_->ERROR()
-      << "scenic_impl::gfx::Session::ApplyDetachLightsCmd(): unimplemented.";
-  return false;
-}
-
-bool Session::ApplySetLabelCmd(::fuchsia::ui::gfx::SetLabelCmd command) {
-  if (auto r = resources_.FindResource<Resource>(command.id)) {
-    return r->SetLabel(command.label);
-  }
-  return false;
-}
-
-bool Session::ApplySetDisableClippingCmd(
-    ::fuchsia::ui::gfx::SetDisableClippingCmd command) {
-  if (auto r = resources_.FindResource<Renderer>(command.renderer_id)) {
-    r->DisableClipping(command.disable_clipping);
-    return true;
-  }
-  return false;
-}
-
-bool Session::ApplyCreateMemory(ResourceId id,
-                                ::fuchsia::ui::gfx::MemoryArgs args) {
-  auto memory = CreateMemory(id, std::move(args));
-  return memory ? resources_.AddResource(id, std::move(memory)) : false;
-}
-
-bool Session::ApplyCreateImage(ResourceId id,
-                               ::fuchsia::ui::gfx::ImageArgs args) {
-  if (auto memory = resources_.FindResource<Memory>(args.memory_id)) {
-    if (auto image = CreateImage(id, std::move(memory), args)) {
-      return resources_.AddResource(id, std::move(image));
-    }
-  }
-
-  return false;
-}
-
-bool Session::ApplyCreateImagePipe(ResourceId id,
-                                   ::fuchsia::ui::gfx::ImagePipeArgs args) {
-  auto image_pipe = fxl::MakeRefCounted<ImagePipe>(
-      this, id, std::move(args.image_pipe_request),
-      session_context_.update_scheduler);
-  return resources_.AddResource(id, image_pipe);
-}
-
-bool Session::ApplyCreateBuffer(ResourceId id,
-                                ::fuchsia::ui::gfx::BufferArgs args) {
-  if (auto memory = resources_.FindResource<Memory>(args.memory_id)) {
-    if (auto buffer = CreateBuffer(id, std::move(memory), args.memory_offset,
-                                   args.num_bytes)) {
-      return resources_.AddResource(id, std::move(buffer));
-    }
-  }
-  return false;
-}
-
-bool Session::ApplyCreateScene(ResourceId id,
-                               ::fuchsia::ui::gfx::SceneArgs args) {
-  auto scene = CreateScene(id, std::move(args));
-  return scene ? resources_.AddResource(id, std::move(scene)) : false;
-}
-
-bool Session::ApplyCreateCamera(ResourceId id,
-                                ::fuchsia::ui::gfx::CameraArgs args) {
-  auto camera = CreateCamera(id, std::move(args));
-  return camera ? resources_.AddResource(id, std::move(camera)) : false;
-}
-
-bool Session::ApplyCreateStereoCamera(
-    ResourceId id, ::fuchsia::ui::gfx::StereoCameraArgs args) {
-  auto camera = CreateStereoCamera(id, args);
-  return camera ? resources_.AddResource(id, std::move(camera)) : false;
-}
-
-bool Session::ApplyCreateRenderer(ResourceId id,
-                                  ::fuchsia::ui::gfx::RendererArgs args) {
-  auto renderer = CreateRenderer(id, std::move(args));
-  return renderer ? resources_.AddResource(id, std::move(renderer)) : false;
-}
-
-bool Session::ApplyCreateAmbientLight(
-    ResourceId id, ::fuchsia::ui::gfx::AmbientLightArgs args) {
-  auto light = CreateAmbientLight(id);
-  return light ? resources_.AddResource(id, std::move(light)) : false;
-}
-
-bool Session::ApplyCreateDirectionalLight(
-    ResourceId id, ::fuchsia::ui::gfx::DirectionalLightArgs args) {
-  auto light = CreateDirectionalLight(id);
-  return light ? resources_.AddResource(id, std::move(light)) : false;
-}
-
-bool Session::ApplyCreateRectangle(ResourceId id,
-                                   ::fuchsia::ui::gfx::RectangleArgs args) {
-  if (!AssertValueIsOfType(args.width, kFloatValueTypes) ||
-      !AssertValueIsOfType(args.height, kFloatValueTypes)) {
-    return false;
-  }
-
-  // TODO(SCN-123): support variables.
-  if (IsVariable(args.width) || IsVariable(args.height)) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplyCreateRectangle(): "
-           "unimplemented: variable width/height.";
-    return false;
-  }
-
-  auto rectangle =
-      CreateRectangle(id, args.width.vector1(), args.height.vector1());
-  return rectangle ? resources_.AddResource(id, std::move(rectangle)) : false;
-}
-
-bool Session::ApplyCreateRoundedRectangle(
-    CommandContext* command_context, ResourceId id,
-    ::fuchsia::ui::gfx::RoundedRectangleArgs args) {
-  if (!AssertValueIsOfType(args.width, kFloatValueTypes) ||
-      !AssertValueIsOfType(args.height, kFloatValueTypes) ||
-      !AssertValueIsOfType(args.top_left_radius, kFloatValueTypes) ||
-      !AssertValueIsOfType(args.top_right_radius, kFloatValueTypes) ||
-      !AssertValueIsOfType(args.bottom_left_radius, kFloatValueTypes) ||
-      !AssertValueIsOfType(args.bottom_right_radius, kFloatValueTypes)) {
-    return false;
-  }
-
-  // TODO(SCN-123): support variables.
-  if (IsVariable(args.width) || IsVariable(args.height) ||
-      IsVariable(args.top_left_radius) || IsVariable(args.top_right_radius) ||
-      IsVariable(args.bottom_left_radius) ||
-      IsVariable(args.bottom_right_radius)) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplyCreateRoundedRectangle(): "
-           "unimplemented: variable width/height/radii.";
-    return false;
-  }
-
-  const float width = args.width.vector1();
-  const float height = args.height.vector1();
-  const float top_left_radius = args.top_left_radius.vector1();
-  const float top_right_radius = args.top_right_radius.vector1();
-  const float bottom_right_radius = args.bottom_right_radius.vector1();
-  const float bottom_left_radius = args.bottom_left_radius.vector1();
-
-  auto rectangle = CreateRoundedRectangle(
-      command_context, id, width, height, top_left_radius, top_right_radius,
-      bottom_right_radius, bottom_left_radius);
-  return rectangle ? resources_.AddResource(id, std::move(rectangle)) : false;
-}
-
-bool Session::ApplyCreateCircle(ResourceId id,
-                                ::fuchsia::ui::gfx::CircleArgs args) {
-  if (!AssertValueIsOfType(args.radius, kFloatValueTypes)) {
-    return false;
-  }
-
-  // TODO(SCN-123): support variables.
-  if (IsVariable(args.radius)) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::ApplyCreateCircle(): "
-           "unimplemented: variable radius.";
-    return false;
-  }
-
-  auto circle = CreateCircle(id, args.radius.vector1());
-  return circle ? resources_.AddResource(id, std::move(circle)) : false;
-}
-
-bool Session::ApplyCreateMesh(ResourceId id,
-                              ::fuchsia::ui::gfx::MeshArgs args) {
-  auto mesh = CreateMesh(id);
-  return mesh ? resources_.AddResource(id, std::move(mesh)) : false;
-}
-
-bool Session::ApplyCreateMaterial(ResourceId id,
-                                  ::fuchsia::ui::gfx::MaterialArgs args) {
-  auto material = CreateMaterial(id);
-  return material ? resources_.AddResource(id, std::move(material)) : false;
-}
-
-bool Session::ApplyCreateView(ResourceId id,
-                              ::fuchsia::ui::gfx::ViewArgs args) {
-  // Sanity check.  We also rely on FIDL to enforce this for us, although it
-  // does not at the moment.
-  FXL_DCHECK(args.token)
-      << "scenic_impl::gfx::Session::ApplyCreateView(): no token provided.";
-
-  if (auto view = CreateView(id, std::move(args))) {
-    view->As<View>()->Connect();  // Initiate the link.
-    resources_.AddResource(id, std::move(view));
-    return true;
-  }
-  return false;
-}
-
-bool Session::ApplyCreateViewHolder(ResourceId id,
-                                    ::fuchsia::ui::gfx::ViewHolderArgs args) {
-  // Sanity check.  We also rely on FIDL to enforce this for us, although it
-  // does not at the moment
-  FXL_DCHECK(args.token) << "scenic_impl::gfx::Session::ApplyCreateViewHolder()"
-                            ": no token provided.";
-
-  if (auto view_holder = CreateViewHolder(id, std::move(args))) {
-    view_holder->As<ViewHolder>()->Connect();  // Initiate the link.
-    resources_.AddResource(id, std::move(view_holder));
-    return true;
-  }
-  return false;
-}
-
-bool Session::ApplyCreateClipNode(ResourceId id,
-                                  ::fuchsia::ui::gfx::ClipNodeArgs args) {
-  auto node = CreateClipNode(id, std::move(args));
-  return node ? resources_.AddResource(id, std::move(node)) : false;
-}
-
-bool Session::ApplyCreateEntityNode(ResourceId id,
-                                    ::fuchsia::ui::gfx::EntityNodeArgs args) {
-  auto node = CreateEntityNode(id, std::move(args));
-  return node ? resources_.AddResource(id, std::move(node)) : false;
-}
-
-bool Session::ApplyCreateOpacityNode(ResourceId id,
-                                     ::fuchsia::ui::gfx::OpacityNodeArgs args) {
-  auto node = CreateOpacityNode(id, args);
-  return node ? resources_.AddResource(id, std::move(node)) : false;
-}
-
-bool Session::ApplyCreateShapeNode(ResourceId id,
-                                   ::fuchsia::ui::gfx::ShapeNodeArgs args) {
-  auto node = CreateShapeNode(id, std::move(args));
-  return node ? resources_.AddResource(id, std::move(node)) : false;
-}
-
-bool Session::ApplyCreateCompositor(ResourceId id,
-                                    ::fuchsia::ui::gfx::CompositorArgs args) {
-  auto compositor = CreateCompositor(id, std::move(args));
-  return compositor ? resources_.AddResource(id, std::move(compositor)) : false;
-}
-
-bool Session::ApplyCreateDisplayCompositor(
-    ResourceId id, ::fuchsia::ui::gfx::DisplayCompositorArgs args) {
-  auto compositor = CreateDisplayCompositor(id, std::move(args));
-  return compositor ? resources_.AddResource(id, std::move(compositor)) : false;
-}
-
-bool Session::ApplyCreateImagePipeCompositor(
-    ResourceId id, ::fuchsia::ui::gfx::ImagePipeCompositorArgs args) {
-  auto compositor = CreateImagePipeCompositor(id, std::move(args));
-  return compositor ? resources_.AddResource(id, std::move(compositor)) : false;
-}
-
-bool Session::ApplyCreateLayerStack(ResourceId id,
-                                    ::fuchsia::ui::gfx::LayerStackArgs args) {
-  auto layer_stack = CreateLayerStack(id, std::move(args));
-  return layer_stack ? resources_.AddResource(id, std::move(layer_stack))
-                     : false;
-}
-
-bool Session::ApplyCreateLayer(ResourceId id,
-                               ::fuchsia::ui::gfx::LayerArgs args) {
-  auto layer = CreateLayer(id, std::move(args));
-  return layer ? resources_.AddResource(id, std::move(layer)) : false;
-}
-
-bool Session::ApplyCreateVariable(ResourceId id,
-                                  ::fuchsia::ui::gfx::VariableArgs args) {
-  auto variable = CreateVariable(id, std::move(args));
-  return variable ? resources_.AddResource(id, std::move(variable)) : false;
-}
-
-ResourcePtr Session::CreateMemory(ResourceId id,
-                                  ::fuchsia::ui::gfx::MemoryArgs args) {
-  return Memory::New(this, id, std::move(args), error_reporter_);
-}
-
-ResourcePtr Session::CreateImage(ResourceId id, MemoryPtr memory,
-                                 ::fuchsia::ui::gfx::ImageArgs args) {
-  return Image::New(this, id, memory, args.info, args.memory_offset,
-                    error_reporter_);
-}
-
-ResourcePtr Session::CreateBuffer(ResourceId id, MemoryPtr memory,
-                                  uint32_t memory_offset, uint32_t num_bytes) {
-  if (memory_offset + num_bytes > memory->size()) {
-    error_reporter_->ERROR() << "scenic_impl::gfx::Session::CreateBuffer(): "
-                                "buffer does not fit within memory (buffer "
-                                "offset: "
-                             << memory_offset << ", buffer size: " << num_bytes
-                             << ", memory size: " << memory->size() << ")";
-    return ResourcePtr();
-  }
-
-  // Make a pointer to a subregion of the memory, if necessary.
-  escher::GpuMemPtr gpu_mem =
-      (memory_offset > 0 || num_bytes < memory->size())
-          ? memory->GetGpuMem()->Suballocate(num_bytes, memory_offset)
-          : memory->GetGpuMem();
-
-  return fxl::MakeRefCounted<Buffer>(this, id, std::move(gpu_mem),
-                                     std::move(memory));
-}
-
-ResourcePtr Session::CreateScene(ResourceId id,
-                                 ::fuchsia::ui::gfx::SceneArgs args) {
-  return fxl::MakeRefCounted<Scene>(this, id);
-}
-
-ResourcePtr Session::CreateCamera(ResourceId id,
-                                  ::fuchsia::ui::gfx::CameraArgs args) {
-  if (auto scene = resources_.FindResource<Scene>(args.scene_id)) {
-    return fxl::MakeRefCounted<Camera>(this, id, std::move(scene));
-  }
-  return ResourcePtr();
-}
-
-ResourcePtr Session::CreateStereoCamera(
-    ResourceId id, const ::fuchsia::ui::gfx::StereoCameraArgs args) {
-  if (auto scene = resources_.FindResource<Scene>(args.scene_id)) {
-    return fxl::MakeRefCounted<StereoCamera>(this, id, std::move(scene));
-  }
-  return ResourcePtr();
-}
-
-ResourcePtr Session::CreateRenderer(ResourceId id,
-                                    ::fuchsia::ui::gfx::RendererArgs args) {
-  return fxl::MakeRefCounted<Renderer>(this, id);
-}
-
-ResourcePtr Session::CreateAmbientLight(ResourceId id) {
-  return fxl::MakeRefCounted<AmbientLight>(this, id);
-}
-
-ResourcePtr Session::CreateDirectionalLight(ResourceId id) {
-  return fxl::MakeRefCounted<DirectionalLight>(this, id);
-}
-
-ResourcePtr Session::CreateView(ResourceId id,
-                                ::fuchsia::ui::gfx::ViewArgs args) {
-  ViewLinker* view_linker = session_context_.view_linker;
-  ViewLinker::ImportLink link =
-      view_linker->CreateImport(std::move(args.token), error_reporter());
-
-  // Create a View if the Link was successfully registered.
-  if (link.valid()) {
-    return fxl::MakeRefCounted<View>(this, id, std::move(link));
-  }
-  return nullptr;
-}
-
-ResourcePtr Session::CreateViewHolder(ResourceId id,
-                                      ::fuchsia::ui::gfx::ViewHolderArgs args) {
-  ViewLinker* view_linker = session_context_.view_linker;
-  ViewLinker::ExportLink link =
-      view_linker->CreateExport(std::move(args.token), error_reporter());
-
-  // Create a ViewHolder if the Link was successfully registered.
-  if (link.valid()) {
-    return fxl::MakeRefCounted<ViewHolder>(this, id, std::move(link));
-  }
-  return nullptr;
-}
-
-ResourcePtr Session::CreateClipNode(ResourceId id,
-                                    ::fuchsia::ui::gfx::ClipNodeArgs args) {
-  error_reporter_->ERROR() << "scenic_impl::gfx::Session::CreateClipNode(): "
-                              "unimplemented.";
-  return ResourcePtr();
-}
-
-ResourcePtr Session::CreateEntityNode(ResourceId id,
-                                      ::fuchsia::ui::gfx::EntityNodeArgs args) {
-  return fxl::MakeRefCounted<EntityNode>(this, id);
-}
-
-ResourcePtr Session::CreateOpacityNode(
-    ResourceId id, ::fuchsia::ui::gfx::OpacityNodeArgs args) {
-  return fxl::MakeRefCounted<OpacityNode>(this, id);
-}
-
-ResourcePtr Session::CreateShapeNode(ResourceId id,
-                                     ::fuchsia::ui::gfx::ShapeNodeArgs args) {
-  return fxl::MakeRefCounted<ShapeNode>(this, id);
-}
-
-ResourcePtr Session::CreateCompositor(ResourceId id,
-                                      ::fuchsia::ui::gfx::CompositorArgs args) {
-  return Compositor::New(this, id, session_context_.scene_graph);
-}
-
-ResourcePtr Session::CreateDisplayCompositor(
-    ResourceId id, ::fuchsia::ui::gfx::DisplayCompositorArgs args) {
-  Display* display = session_context_.display_manager->default_display();
-  if (!display) {
-    error_reporter_->ERROR() << "There is no default display available.";
-    return nullptr;
-  }
-
-  if (display->is_claimed()) {
-    error_reporter_->ERROR() << "The default display has already been claimed "
-                                "by another compositor.";
-    return nullptr;
-  }
-
-  return fxl::AdoptRef(new DisplayCompositor(
-      this, id, session_context_.scene_graph, display,
-      SwapchainFactory::CreateDisplaySwapchain(
-          display, session_context_.display_manager,
-          session_context_.event_timestamper, session_context_.escher)));
-}
-
-ResourcePtr Session::CreateImagePipeCompositor(
-    ResourceId id, ::fuchsia::ui::gfx::ImagePipeCompositorArgs args) {
-  // TODO(SCN-179)
-  error_reporter_->ERROR()
-      << "scenic_impl::gfx::Session::ApplyCreateImagePipeCompositor() "
-         "is unimplemented (SCN-179)";
-  return ResourcePtr();
-}
-
-ResourcePtr Session::CreateLayerStack(ResourceId id,
-                                      ::fuchsia::ui::gfx::LayerStackArgs args) {
-  return fxl::MakeRefCounted<LayerStack>(this, id);
-}
-
-ResourcePtr Session::CreateVariable(ResourceId id,
-                                    ::fuchsia::ui::gfx::VariableArgs args) {
-  fxl::RefPtr<Variable> variable;
-  switch (args.type) {
-    case ::fuchsia::ui::gfx::ValueType::kVector1:
-      variable = fxl::MakeRefCounted<FloatVariable>(this, id);
-      break;
-    case ::fuchsia::ui::gfx::ValueType::kVector2:
-      variable = fxl::MakeRefCounted<Vector2Variable>(this, id);
-      break;
-    case ::fuchsia::ui::gfx::ValueType::kVector3:
-      variable = fxl::MakeRefCounted<Vector3Variable>(this, id);
-      break;
-    case ::fuchsia::ui::gfx::ValueType::kVector4:
-      variable = fxl::MakeRefCounted<Vector4Variable>(this, id);
-      break;
-    case ::fuchsia::ui::gfx::ValueType::kMatrix4:
-      variable = fxl::MakeRefCounted<Matrix4x4Variable>(this, id);
-      break;
-    case ::fuchsia::ui::gfx::ValueType::kColorRgb:
-      // not yet supported
-      variable = nullptr;
-      break;
-    case ::fuchsia::ui::gfx::ValueType::kColorRgba:
-      // not yet supported
-      variable = nullptr;
-      break;
-    case ::fuchsia::ui::gfx::ValueType::kQuaternion:
-      variable = fxl::MakeRefCounted<QuaternionVariable>(this, id);
-      break;
-    case ::fuchsia::ui::gfx::ValueType::kFactoredTransform:
-      /* variable = fxl::MakeRefCounted<TransformVariable>(this, id); */
-      variable = nullptr;
-      break;
-    case ::fuchsia::ui::gfx::ValueType::kNone:
-      break;
-  }
-  if (variable && variable->SetValue(args.initial_value)) {
-    return variable;
-  }
-  return nullptr;
-}
-
-ResourcePtr Session::CreateLayer(ResourceId id,
-                                 ::fuchsia::ui::gfx::LayerArgs args) {
-  return fxl::MakeRefCounted<Layer>(this, id);
-}
-
-ResourcePtr Session::CreateCircle(ResourceId id, float initial_radius) {
-  return fxl::MakeRefCounted<CircleShape>(this, id, initial_radius);
-}
-
-ResourcePtr Session::CreateRectangle(ResourceId id, float width, float height) {
-  return fxl::MakeRefCounted<RectangleShape>(this, id, width, height);
-}
-
-ResourcePtr Session::CreateRoundedRectangle(CommandContext* command_context,
-                                            ResourceId id, float width,
-                                            float height, float top_left_radius,
-                                            float top_right_radius,
-                                            float bottom_right_radius,
-                                            float bottom_left_radius) {
-  auto factory = session_context_.escher_rounded_rect_factory;
-  if (!factory) {
-    error_reporter_->ERROR()
-        << "scenic_impl::gfx::Session::CreateRoundedRectangle(): "
-           "no RoundedRectFactory available.";
-    return ResourcePtr();
-  }
-
-  // If radii sum exceeds width or height, scale them down.
-  float top_radii_sum = top_left_radius + top_right_radius;
-  float top_scale = std::min(width / top_radii_sum, 1.f);
-
-  float bottom_radii_sum = bottom_left_radius + bottom_right_radius;
-  float bottom_scale = std::min(width / bottom_radii_sum, 1.f);
-
-  float left_radii_sum = top_left_radius + bottom_left_radius;
-  float left_scale = std::min(height / left_radii_sum, 1.f);
-
-  float right_radii_sum = top_right_radius + bottom_right_radius;
-  float right_scale = std::min(height / right_radii_sum, 1.f);
-
-  top_left_radius *= std::min(top_scale, left_scale);
-  top_right_radius *= std::min(top_scale, right_scale);
-  bottom_left_radius *= std::min(bottom_scale, left_scale);
-  bottom_right_radius *= std::min(bottom_scale, right_scale);
-
-  escher::RoundedRectSpec rect_spec(width, height, top_left_radius,
-                                    top_right_radius, bottom_right_radius,
-                                    bottom_left_radius);
-  escher::MeshSpec mesh_spec{escher::MeshAttribute::kPosition2D |
-                             escher::MeshAttribute::kUV};
-
-  return fxl::MakeRefCounted<RoundedRectangleShape>(
-      this, id, rect_spec,
-      factory->NewRoundedRect(rect_spec, mesh_spec,
-                              command_context->batch_gpu_uploader()));
-}
-
-ResourcePtr Session::CreateMesh(ResourceId id) {
-  return fxl::MakeRefCounted<MeshShape>(this, id);
-}
-
-ResourcePtr Session::CreateMaterial(ResourceId id) {
-  return fxl::MakeRefCounted<Material>(this, id);
-}
-
-void Session::TearDown() {
-  if (!is_valid_) {
-    // TearDown already called.
-    return;
-  }
-  is_valid_ = false;
+Session::~Session() {
   resources_.Clear();
   scheduled_image_pipe_updates_ = {};
 
-  // We assume the channel for the associated ::fuchsia::ui::gfx::Session is
-  // closed because SessionHandler closes it before calling this method. The
-  // channel *must* be closed before we clear |scheduled_updates_|, since it
-  // contains pending callbacks to ::fuchsia::ui::gfx::Session::Present(); if it
-  // were not closed, we would have to invoke those callbacks before destroying
-  // them.
+  // We assume the channel for the associated gfx::Session is closed by
+  // SessionHandler before this point, since |scheduled_updates_| contains
+  // pending callbacks to gfx::Session::Present(). If the channel was not closed
+  // we would have to invoke those callbacks before destroying them.
   scheduled_updates_ = {};
   fences_to_release_on_next_update_.clear();
 
@@ -1429,12 +85,14 @@
     auto exported_count =
         session_context_.resource_linker->NumExportsForSession(this);
     FXL_CHECK(resource_count_ == 0)
-        << "Session::TearDown(): Not all resources have been collected. "
+        << "Session::~Session(): Not all resources have been collected. "
            "Exported resources: "
         << exported_count
         << ", total outstanding resources: " << resource_count_;
   }
   error_reporter_ = nullptr;
+
+  weak_factory_.InvalidateWeakPtrs();
 }
 
 ErrorReporter* Session::error_reporter() const {
@@ -1443,134 +101,106 @@
 
 EventReporter* Session::event_reporter() const { return event_reporter_; }
 
-bool Session::AssertValueIsOfType(const ::fuchsia::ui::gfx::Value& value,
-                                  const ::fuchsia::ui::gfx::Value::Tag* tags,
-                                  size_t tag_count) {
-  using ::operator<<;  // From print_commands.h
-  FXL_DCHECK(tag_count > 0);
-  for (size_t i = 0; i < tag_count; ++i) {
-    if (value.Which() == tags[i]) {
-      return true;
-    }
-  }
-  std::ostringstream str;
-  if (tag_count == 1) {
-    str << ", which is not the expected type: " << tags[0] << ".";
-  } else {
-    str << ", which is not one of the expected types (" << tags[0];
-    for (size_t i = 1; i < tag_count; ++i) {
-      str << ", " << tags[i];
-    }
-    str << ").";
-  }
-  error_reporter_->ERROR()
-      << "scenic_impl::gfx::Session: received value of type: " << value.Which()
-      << str.str();
-  return false;
-}
-
 bool Session::ScheduleUpdate(
     uint64_t requested_presentation_time,
     std::vector<::fuchsia::ui::gfx::Command> commands,
     ::std::vector<zx::event> acquire_fences,
     ::std::vector<zx::event> release_events,
     fuchsia::ui::scenic::Session::PresentCallback callback) {
-  if (is_valid()) {
-    uint64_t last_scheduled_presentation_time =
-        last_applied_update_presentation_time_;
-    if (!scheduled_updates_.empty()) {
-      last_scheduled_presentation_time =
-          std::max(last_scheduled_presentation_time,
-                   scheduled_updates_.back().presentation_time);
-    }
-
-    if (requested_presentation_time < last_scheduled_presentation_time) {
-      error_reporter_->ERROR()
-          << "scenic_impl::gfx::Session: Present called with out-of-order "
-             "presentation time. "
-          << "requested presentation time=" << requested_presentation_time
-          << ", last scheduled presentation time="
-          << last_scheduled_presentation_time << ".";
-      return false;
-    }
-
-    // If we're not running headless, warn if the requested presesentation time
-    // is not reasonable.
-    if (session_context_.frame_scheduler &&
-        session_context_.display_manager->default_display()) {
-      std::pair<zx_time_t, zx_time_t> target_times =
-          session_context_.frame_scheduler
-              ->ComputeTargetPresentationAndWakeupTimes(
-                  requested_presentation_time);
-      uint64_t target_presentation_time = target_times.first;
-
-      zx_time_t vsync_interval =
-          session_context_.display_manager->default_display()
-              ->GetVsyncInterval();
-      // TODO(SCN-723): Re-enable warning when requested_presentation_time == 0
-      // after Flutter engine is fixed.
-      if (requested_presentation_time != 0 &&
-          target_presentation_time - vsync_interval >
-              requested_presentation_time) {
-        // Present called with too early of a presentation time.
-        TRACE_INSTANT("gfx", "Session requested too early presentation time",
-                      TRACE_SCOPE_PROCESS, "session_id", id(),
-                      "requested presentation time",
-                      requested_presentation_time, "target presentation time",
-                      target_presentation_time);
-      }
-    }
-    auto acquire_fence_set =
-        std::make_unique<escher::FenceSetListener>(std::move(acquire_fences));
-    // TODO: Consider calling ScheduleUpdateForSession immediately if
-    // acquire_fence_set is already ready (which is the case if there are
-    // zero acquire fences).
-
-    acquire_fence_set->WaitReadyAsync(
-        [weak = weak_factory_.GetWeakPtr(), requested_presentation_time] {
-          if (weak)
-            weak->session_context_.session_manager->ScheduleUpdateForSession(
-                weak->session_context_.update_scheduler,
-                requested_presentation_time, SessionPtr(weak.get()));
-        });
-
-    scheduled_updates_.push(
-        Update{requested_presentation_time, std::move(commands),
-               std::move(acquire_fence_set), std::move(release_events),
-               std::move(callback)});
+  uint64_t last_scheduled_presentation_time =
+      last_applied_update_presentation_time_;
+  if (!scheduled_updates_.empty()) {
+    last_scheduled_presentation_time =
+        std::max(last_scheduled_presentation_time,
+                 scheduled_updates_.back().presentation_time);
   }
+
+  if (requested_presentation_time < last_scheduled_presentation_time) {
+    error_reporter_->ERROR()
+        << "scenic_impl::gfx::Session: Present called with out-of-order "
+           "presentation time. "
+        << "requested presentation time=" << requested_presentation_time
+        << ", last scheduled presentation time="
+        << last_scheduled_presentation_time << ".";
+    return false;
+  }
+
+  // If we're not running headless, warn if the requested presesentation time
+  // is not reasonable.
+  if (session_context_.frame_scheduler &&
+      session_context_.display_manager->default_display()) {
+    std::pair<zx_time_t, zx_time_t> target_times =
+        session_context_.frame_scheduler
+            ->ComputeTargetPresentationAndWakeupTimes(
+                requested_presentation_time);
+    uint64_t target_presentation_time = target_times.first;
+    zx_time_t vsync_interval =
+        session_context_.display_manager->default_display()->GetVsyncInterval();
+    // TODO(SCN-723): Re-enable warning when requested_presentation_time == 0
+    // after Flutter engine is fixed.
+    if (requested_presentation_time != 0 &&
+        target_presentation_time - vsync_interval >
+            requested_presentation_time) {
+      // Present called with too early of a presentation time.
+      TRACE_INSTANT("gfx", "Session requested too early presentation time",
+                    TRACE_SCOPE_PROCESS, "session_id", id(),
+                    "requested presentation time", requested_presentation_time,
+                    "target presentation time", target_presentation_time);
+    }
+  }
+
+  auto acquire_fence_set =
+      std::make_unique<escher::FenceSetListener>(std::move(acquire_fences));
+  // TODO: Consider calling ScheduleUpdateForSession immediately if
+  // acquire_fence_set is already ready (which is the case if there are
+  // zero acquire fences).
+
+  acquire_fence_set->WaitReadyAsync(
+      [weak = GetWeakPtr(), requested_presentation_time] {
+        if (weak) {
+          weak->session_context_.session_manager->ScheduleUpdateForSession(
+              weak->session_context_.update_scheduler,
+              requested_presentation_time, std::move(weak));
+        }
+      });
+
+  scheduled_updates_.push(
+      Update{requested_presentation_time, std::move(commands),
+             std::move(acquire_fence_set), std::move(release_events),
+             std::move(callback)});
+
   return true;
 }
 
 void Session::ScheduleImagePipeUpdate(uint64_t presentation_time,
                                       ImagePipePtr image_pipe) {
   FXL_DCHECK(image_pipe);
-  if (is_valid()) {
-    scheduled_image_pipe_updates_.push(
-        {presentation_time, std::move(image_pipe)});
+  scheduled_image_pipe_updates_.push(
+      {presentation_time, std::move(image_pipe)});
 
-    session_context_.session_manager->ScheduleUpdateForSession(
-        session_context_.update_scheduler, presentation_time, SessionPtr(this));
-  }
+  session_context_.session_manager->ScheduleUpdateForSession(
+      session_context_.update_scheduler, presentation_time, GetWeakPtr());
 }
 
-bool Session::ApplyScheduledUpdates(CommandContext* command_context,
-                                    uint64_t presentation_time,
-                                    uint64_t presentation_interval) {
+Session::ApplyUpdateResult Session::ApplyScheduledUpdates(
+    CommandContext* command_context, uint64_t presentation_time,
+    uint64_t presentation_interval) {
   TRACE_DURATION("gfx", "Session::ApplyScheduledUpdates", "session_id", id_,
                  "session_debug_name", debug_name_, "time", presentation_time,
                  "interval", presentation_interval);
 
+  ApplyUpdateResult update_results{false, false};
+
   if (presentation_time < last_presentation_time_) {
     error_reporter_->ERROR()
         << "scenic_impl::gfx::Session: ApplyScheduledUpdates called with "
            "presentation_time="
         << presentation_time << ", which is less than last_presentation_time_="
         << last_presentation_time_ << ".";
-    return false;
+    update_results.success = false;
+    return update_results;
   }
 
-  bool needs_render = false;
   while (!scheduled_updates_.empty() &&
          scheduled_updates_.front().presentation_time <= presentation_time) {
     if (!scheduled_updates_.front().acquire_fences->ready()) {
@@ -1584,7 +214,7 @@
     }
     if (ApplyUpdate(command_context,
                     std::move(scheduled_updates_.front().commands))) {
-      needs_render = true;
+      update_results.needs_render = true;
       auto info = fuchsia::images::PresentationInfo();
       info.presentation_time = presentation_time;
       info.presentation_interval = presentation_interval;
@@ -1611,14 +241,13 @@
       FXL_LOG(WARNING) << "scenic_impl::gfx::Session::ApplyScheduledUpdates(): "
                           "An error was encountered while applying the update. "
                           "Initiating teardown.";
-
+      update_results.success = false;
       scheduled_updates_ = {};
 
-      BeginTearDown();
-
       // Tearing down a session will very probably result in changes to
       // the global scene-graph.
-      return true;
+      update_results.needs_render = true;
+      return update_results;
     }
   }
 
@@ -1629,42 +258,36 @@
     // The bool returned from Update() is 0 or 1, and needs_render is 0 or 1, so
     // bitwise |= is used which doesn't short-circuit.
     if (scheduled_image_pipe_updates_.top().image_pipe) {
-      needs_render |= scheduled_image_pipe_updates_.top().image_pipe->Update(
-          session_context_.release_fence_signaller, presentation_time,
-          presentation_interval);
+      update_results.needs_render |=
+          scheduled_image_pipe_updates_.top().image_pipe->Update(
+              session_context_.release_fence_signaller, presentation_time,
+              presentation_interval);
     }
     scheduled_image_pipe_updates_.pop();
   }
 
-  return needs_render;
+  update_results.success = true;
+  return update_results;
 }
 
 void Session::EnqueueEvent(::fuchsia::ui::gfx::Event event) {
-  if (!is_valid()) {
-    return;
-  }
   event_reporter_->EnqueueEvent(std::move(event));
 }
 
 void Session::EnqueueEvent(::fuchsia::ui::input::InputEvent event) {
-  if (!is_valid()) {
-    return;
-  }
   event_reporter_->EnqueueEvent(std::move(event));
 }
 
 bool Session::ApplyUpdate(CommandContext* command_context,
                           std::vector<::fuchsia::ui::gfx::Command> commands) {
   TRACE_DURATION("gfx", "Session::ApplyUpdate");
-  if (is_valid()) {
-    for (auto& command : commands) {
-      if (!ApplyCommand(command_context, std::move(command))) {
-        using ::operator<<;  // From print_commands.h
-        error_reporter_->ERROR() << "scenic_impl::gfx::Session::ApplyCommand() "
-                                    "failed to apply Command: "
-                                 << command;
-        return false;
-      }
+  for (auto& command : commands) {
+    if (!ApplyCommand(command_context, std::move(command))) {
+      using ::operator<<;  // From print_commands.h
+      error_reporter_->ERROR() << "scenic_impl::gfx::Session::ApplyCommand() "
+                                  "failed to apply Command: "
+                               << command;
+      return false;
     }
   }
   return true;
@@ -1709,9 +332,5 @@
   callback(WrapHits(layer_stack_hits));
 }
 
-void Session::BeginTearDown() {
-  session_context_.session_manager->TearDownSession(id());
-}
-
 }  // namespace gfx
 }  // namespace scenic_impl
diff --git a/lib/ui/gfx/engine/session.h b/lib/ui/gfx/engine/session.h
index 6107cd5..bd2baaa 100644
--- a/lib/ui/gfx/engine/session.h
+++ b/lib/ui/gfx/engine/session.h
@@ -10,11 +10,12 @@
 #include <fuchsia/ui/gfx/cpp/fidl.h>
 #include <fuchsia/ui/scenic/cpp/fidl.h>
 
+#include "garnet/lib/ui/gfx/engine/gfx_command_applier.h"
 #include "garnet/lib/ui/gfx/engine/resource_map.h"
 #include "garnet/lib/ui/gfx/engine/session_context.h"
+#include "garnet/lib/ui/gfx/engine/session_manager.h"
 #include "garnet/lib/ui/gfx/id.h"
 #include "garnet/lib/ui/gfx/resources/memory.h"
-#include "garnet/lib/ui/gfx/resources/resource.h"
 #include "garnet/lib/ui/gfx/resources/resource_context.h"
 #include "garnet/lib/ui/scenic/event_reporter.h"
 #include "garnet/lib/ui/scenic/util/error_reporter.h"
@@ -26,27 +27,23 @@
 namespace scenic_impl {
 namespace gfx {
 
-class Image;
-using ImagePtr = ::fxl::RefPtr<Image>;
-
-class ImageBase;
-using ImageBasePtr = ::fxl::RefPtr<ImageBase>;
-
 class ImagePipe;
-using ImagePipePtr = ::fxl::RefPtr<ImagePipe>;
-
-class Session;
-using SessionPtr = ::fxl::RefPtr<Session>;
+using ImagePipePtr = fxl::RefPtr<ImagePipe>;
 
 class CommandContext;
 class Engine;
 class Resource;
-class SessionHandler;
 
-// TODO: use unsafe ref-counting for better performance (our architecture
-// guarantees that this is safe).
-class Session : public fxl::RefCountedThreadSafe<Session> {
+// gfx::Session is the internal endpoint of the scenic::Session channel.
+// It owns, and is responsible for, all graphics state on the channel
+class Session {
  public:
+  // Return type for ApplyScheduledUpdate
+  struct ApplyUpdateResult {
+    bool success;
+    bool needs_render;
+  };
+
   Session(SessionId id, SessionContext context,
           EventReporter* event_reporter = EventReporter::Default(),
           ErrorReporter* error_reporter = ErrorReporter::Default());
@@ -56,10 +53,17 @@
   // successful, and false if the op is somehow invalid.  In the latter case,
   // the Session is left unchanged.
   bool ApplyCommand(CommandContext* command_context,
-                    ::fuchsia::ui::gfx::Command command);
+                    fuchsia::ui::gfx::Command command) {
+    return GfxCommandApplier::ApplyCommand(this, command_context,
+                                           std::move(command));
+  }
 
   SessionId id() const { return id_; }
 
+  const fxl::WeakPtr<Session> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+  const SessionContext& session_context() const { return session_context_; }
   const ResourceContext& resource_context() const { return resource_context_; }
 
   // Return the total number of existing resources associated with this Session.
@@ -71,9 +75,6 @@
   // exist if it is referenced by other resources.
   size_t GetMappedResourceCount() const { return resources_.size(); }
 
-  // Session becomes invalid once TearDown is called.
-  bool is_valid() const { return is_valid_; }
-
   ErrorReporter* error_reporter() const;  // Never nullptr.
   EventReporter* event_reporter() const;  // Never nullptr.
 
@@ -83,8 +84,8 @@
   // applying them; they will later be applied by ApplyScheduledUpdates().
   bool ScheduleUpdate(uint64_t presentation_time,
                       std::vector<::fuchsia::ui::gfx::Command> commands,
-                      ::std::vector<zx::event> acquire_fences,
-                      ::std::vector<zx::event> release_fences,
+                      std::vector<zx::event> acquire_fences,
+                      std::vector<zx::event> release_fences,
                       fuchsia::ui::scenic::Session::PresentCallback callback);
 
   // Called by ImagePipe::PresentImage().  Stashes the arguments without
@@ -93,218 +94,32 @@
                                ImagePipePtr image_pipe);
 
   // Called by Engine() when it is notified by the FrameScheduler that
-  // a frame should be rendered for the specified |presentation_time|.  Return
-  // true if any updates were applied, and false otherwise.
-  bool ApplyScheduledUpdates(CommandContext* command_context,
-                             uint64_t presentation_time,
-                             uint64_t presentation_interval);
+  // a frame should be rendered for the specified |presentation_time|.
+  // Returns ApplyUpdateResult.success as true if updates were successfully
+  // applied, false if updates failed to be applied.
+  // Returns ApplyUpdateResult.needs_render as true if any changes were
+  // applied, false if none were.
+  ApplyUpdateResult ApplyScheduledUpdates(CommandContext* command_context,
+                                          uint64_t presentation_time,
+                                          uint64_t presentation_interval);
 
   // Convenience.  Forwards an event to the EventReporter.
   void EnqueueEvent(::fuchsia::ui::gfx::Event event);
   void EnqueueEvent(::fuchsia::ui::input::InputEvent event);
 
   // Called by SessionHandler::HitTest().
-  void HitTest(uint32_t node_id, ::fuchsia::ui::gfx::vec3 ray_origin,
-               ::fuchsia::ui::gfx::vec3 ray_direction,
+  void HitTest(uint32_t node_id, fuchsia::ui::gfx::vec3 ray_origin,
+               fuchsia::ui::gfx::vec3 ray_direction,
                fuchsia::ui::scenic::Session::HitTestCallback callback);
 
   // Called by SessionHandler::HitTestDeviceRay().
   void HitTestDeviceRay(::fuchsia::ui::gfx::vec3 ray_origin,
-                        ::fuchsia::ui::gfx::vec3 ray_direction,
+                        fuchsia::ui::gfx::vec3 ray_direction,
                         fuchsia::ui::scenic::Session::HitTestCallback callback);
 
   void SetDebugName(const std::string& debug_name) { debug_name_ = debug_name; }
 
- protected:
-  friend class SessionHandler;
-  // Called only by SessionHandler. Use BeginTearDown() instead when you need to
-  // teardown from within Session. Virtual to allow test subclasses to override.
-  //
-  // The chain of events is:
-  // Session::BeginTearDown or SessionHandler::BeginTearDown
-  // => Engine::TearDownSession
-  // => SessionHandler::TearDown
-  // => Session::TearDown
-  //
-  // We are guaranteed that by the time TearDown() is closed, SessionHandler
-  // has destroyed the channel to this session.
-  virtual void TearDown();
-
  private:
-  // Called internally to initiate teardown.
-  void BeginTearDown();
-
-  // Cmderation application functions, called by ApplyCommand().
-  bool ApplyCreateResourceCmd(CommandContext* command_context,
-                              ::fuchsia::ui::gfx::CreateResourceCmd command);
-  bool ApplyReleaseResourceCmd(::fuchsia::ui::gfx::ReleaseResourceCmd command);
-  bool ApplyExportResourceCmd(::fuchsia::ui::gfx::ExportResourceCmd command);
-  bool ApplyImportResourceCmd(::fuchsia::ui::gfx::ImportResourceCmd command);
-  bool ApplyAddChildCmd(::fuchsia::ui::gfx::AddChildCmd command);
-  bool ApplyAddPartCmd(::fuchsia::ui::gfx::AddPartCmd command);
-  bool ApplyDetachCmd(::fuchsia::ui::gfx::DetachCmd command);
-  bool ApplyDetachChildrenCmd(::fuchsia::ui::gfx::DetachChildrenCmd command);
-  bool ApplySetTagCmd(::fuchsia::ui::gfx::SetTagCmd command);
-  bool ApplySetTranslationCmd(::fuchsia::ui::gfx::SetTranslationCmd command);
-  bool ApplySetScaleCmd(::fuchsia::ui::gfx::SetScaleCmd command);
-  bool ApplySetRotationCmd(::fuchsia::ui::gfx::SetRotationCmd command);
-  bool ApplySetAnchorCmd(::fuchsia::ui::gfx::SetAnchorCmd command);
-  bool ApplySetSizeCmd(::fuchsia::ui::gfx::SetSizeCmd command);
-  bool ApplySetOpacityCmd(::fuchsia::ui::gfx::SetOpacityCmd command);
-  bool ApplySendSizeChangeHintCmd(
-      ::fuchsia::ui::gfx::SendSizeChangeHintCmdHACK command);
-  bool ApplySetShapeCmd(::fuchsia::ui::gfx::SetShapeCmd command);
-  bool ApplySetMaterialCmd(::fuchsia::ui::gfx::SetMaterialCmd command);
-  bool ApplySetClipCmd(::fuchsia::ui::gfx::SetClipCmd command);
-  bool ApplySetViewPropertiesCmd(
-      ::fuchsia::ui::gfx::SetViewPropertiesCmd command);
-  bool ApplySetHitTestBehaviorCmd(
-      ::fuchsia::ui::gfx::SetHitTestBehaviorCmd command);
-  bool ApplySetCameraCmd(::fuchsia::ui::gfx::SetCameraCmd command);
-  bool ApplySetCameraTransformCmd(
-      ::fuchsia::ui::gfx::SetCameraTransformCmd command);
-  bool ApplySetCameraProjectionCmd(
-      ::fuchsia::ui::gfx::SetCameraProjectionCmd command);
-  bool ApplySetStereoCameraProjectionCmd(
-      ::fuchsia::ui::gfx::SetStereoCameraProjectionCmd command);
-  bool ApplySetCameraPoseBufferCmd(
-      ::fuchsia::ui::gfx::SetCameraPoseBufferCmd command);
-  bool ApplySetLightColorCmd(::fuchsia::ui::gfx::SetLightColorCmd command);
-  bool ApplySetLightDirectionCmd(
-      ::fuchsia::ui::gfx::SetLightDirectionCmd command);
-  bool ApplyAddLightCmd(::fuchsia::ui::gfx::AddLightCmd command);
-  bool ApplyDetachLightCmd(::fuchsia::ui::gfx::DetachLightCmd command);
-  bool ApplyDetachLightsCmd(::fuchsia::ui::gfx::DetachLightsCmd command);
-  bool ApplySetTextureCmd(::fuchsia::ui::gfx::SetTextureCmd command);
-  bool ApplySetColorCmd(::fuchsia::ui::gfx::SetColorCmd command);
-  bool ApplyBindMeshBuffersCmd(::fuchsia::ui::gfx::BindMeshBuffersCmd command);
-  bool ApplyAddLayerCmd(::fuchsia::ui::gfx::AddLayerCmd command);
-  bool ApplyRemoveLayerCmd(::fuchsia::ui::gfx::RemoveLayerCmd command);
-  bool ApplyRemoveAllLayersCmd(::fuchsia::ui::gfx::RemoveAllLayersCmd command);
-  bool ApplySetLayerStackCmd(::fuchsia::ui::gfx::SetLayerStackCmd command);
-  bool ApplySetRendererCmd(::fuchsia::ui::gfx::SetRendererCmd command);
-  bool ApplySetRendererParamCmd(
-      ::fuchsia::ui::gfx::SetRendererParamCmd command);
-  bool ApplySetEventMaskCmd(::fuchsia::ui::gfx::SetEventMaskCmd command);
-  bool ApplySetLabelCmd(::fuchsia::ui::gfx::SetLabelCmd command);
-  bool ApplySetDisableClippingCmd(
-      ::fuchsia::ui::gfx::SetDisableClippingCmd command);
-
-  // Resource creation functions, called by ApplyCreateResourceCmd().
-  bool ApplyCreateMemory(ResourceId id, ::fuchsia::ui::gfx::MemoryArgs args);
-  bool ApplyCreateImage(ResourceId id, ::fuchsia::ui::gfx::ImageArgs args);
-  bool ApplyCreateImagePipe(ResourceId id,
-                            ::fuchsia::ui::gfx::ImagePipeArgs args);
-  bool ApplyCreateBuffer(ResourceId id, ::fuchsia::ui::gfx::BufferArgs args);
-  bool ApplyCreateScene(ResourceId id, ::fuchsia::ui::gfx::SceneArgs args);
-  bool ApplyCreateCamera(ResourceId id, ::fuchsia::ui::gfx::CameraArgs args);
-  bool ApplyCreateStereoCamera(ResourceId id,
-                               ::fuchsia::ui::gfx::StereoCameraArgs args);
-  bool ApplyCreateRenderer(ResourceId id,
-                           ::fuchsia::ui::gfx::RendererArgs args);
-  bool ApplyCreateAmbientLight(ResourceId id,
-                               ::fuchsia::ui::gfx::AmbientLightArgs args);
-  bool ApplyCreateDirectionalLight(
-      ResourceId id, ::fuchsia::ui::gfx::DirectionalLightArgs args);
-  bool ApplyCreateRectangle(ResourceId id,
-                            ::fuchsia::ui::gfx::RectangleArgs args);
-  bool ApplyCreateRoundedRectangle(
-      CommandContext* command_context, ResourceId id,
-      ::fuchsia::ui::gfx::RoundedRectangleArgs args);
-  bool ApplyCreateCircle(ResourceId id, ::fuchsia::ui::gfx::CircleArgs args);
-  bool ApplyCreateMesh(ResourceId id, ::fuchsia::ui::gfx::MeshArgs args);
-  bool ApplyCreateMaterial(ResourceId id,
-                           ::fuchsia::ui::gfx::MaterialArgs args);
-  bool ApplyCreateView(ResourceId id, ::fuchsia::ui::gfx::ViewArgs args);
-  bool ApplyCreateViewHolder(ResourceId id,
-                             ::fuchsia::ui::gfx::ViewHolderArgs args);
-  bool ApplyCreateClipNode(ResourceId id,
-                           ::fuchsia::ui::gfx::ClipNodeArgs args);
-  bool ApplyCreateEntityNode(ResourceId id,
-                             ::fuchsia::ui::gfx::EntityNodeArgs args);
-  bool ApplyCreateOpacityNode(ResourceId id,
-                              ::fuchsia::ui::gfx::OpacityNodeArgs args);
-  bool ApplyCreateShapeNode(ResourceId id,
-                            ::fuchsia::ui::gfx::ShapeNodeArgs args);
-  bool ApplyCreateCompositor(ResourceId id,
-                             ::fuchsia::ui::gfx::CompositorArgs args);
-  bool ApplyCreateDisplayCompositor(
-      ResourceId id, ::fuchsia::ui::gfx::DisplayCompositorArgs args);
-  bool ApplyCreateImagePipeCompositor(
-      ResourceId id, ::fuchsia::ui::gfx::ImagePipeCompositorArgs args);
-  bool ApplyCreateLayerStack(ResourceId id,
-                             ::fuchsia::ui::gfx::LayerStackArgs args);
-  bool ApplyCreateLayer(ResourceId id, ::fuchsia::ui::gfx::LayerArgs args);
-  bool ApplyCreateVariable(ResourceId id,
-                           ::fuchsia::ui::gfx::VariableArgs args);
-  bool ApplyTakeSnapshotCmdHACK(
-      ::fuchsia::ui::gfx::TakeSnapshotCmdHACK command);
-
-  // Actually create resources.
-  ResourcePtr CreateMemory(ResourceId id, ::fuchsia::ui::gfx::MemoryArgs args);
-  ResourcePtr CreateImage(ResourceId id, MemoryPtr memory,
-                          ::fuchsia::ui::gfx::ImageArgs args);
-  ResourcePtr CreateBuffer(ResourceId id, MemoryPtr memory,
-                           uint32_t memory_offset, uint32_t num_bytes);
-
-  ResourcePtr CreateScene(ResourceId id, ::fuchsia::ui::gfx::SceneArgs args);
-  ResourcePtr CreateCamera(ResourceId id, ::fuchsia::ui::gfx::CameraArgs args);
-  ResourcePtr CreateStereoCamera(ResourceId id,
-                                 ::fuchsia::ui::gfx::StereoCameraArgs args);
-  ResourcePtr CreateRenderer(ResourceId id,
-                             ::fuchsia::ui::gfx::RendererArgs args);
-
-  ResourcePtr CreateAmbientLight(ResourceId id);
-  ResourcePtr CreateDirectionalLight(ResourceId id);
-
-  ResourcePtr CreateView(ResourceId id, ::fuchsia::ui::gfx::ViewArgs args);
-  ResourcePtr CreateViewHolder(ResourceId id,
-                               ::fuchsia::ui::gfx::ViewHolderArgs args);
-  ResourcePtr CreateClipNode(ResourceId id,
-                             ::fuchsia::ui::gfx::ClipNodeArgs args);
-  ResourcePtr CreateEntityNode(ResourceId id,
-                               ::fuchsia::ui::gfx::EntityNodeArgs args);
-  ResourcePtr CreateOpacityNode(ResourceId id,
-                                ::fuchsia::ui::gfx::OpacityNodeArgs args);
-  ResourcePtr CreateShapeNode(ResourceId id,
-                              ::fuchsia::ui::gfx::ShapeNodeArgs args);
-
-  ResourcePtr CreateCompositor(ResourceId id,
-                               ::fuchsia::ui::gfx::CompositorArgs args);
-  ResourcePtr CreateDisplayCompositor(
-      ResourceId id, ::fuchsia::ui::gfx::DisplayCompositorArgs args);
-  ResourcePtr CreateImagePipeCompositor(
-      ResourceId id, ::fuchsia::ui::gfx::ImagePipeCompositorArgs args);
-  ResourcePtr CreateLayerStack(ResourceId id,
-                               ::fuchsia::ui::gfx::LayerStackArgs args);
-  ResourcePtr CreateLayer(ResourceId id, ::fuchsia::ui::gfx::LayerArgs args);
-  ResourcePtr CreateCircle(ResourceId id, float initial_radius);
-  ResourcePtr CreateRectangle(ResourceId id, float width, float height);
-  ResourcePtr CreateRoundedRectangle(CommandContext* command_context,
-                                     ResourceId id, float width, float height,
-                                     float top_left_radius,
-                                     float top_right_radius,
-                                     float bottom_right_radius,
-                                     float bottom_left_radius);
-  ResourcePtr CreateMesh(ResourceId id);
-  ResourcePtr CreateMaterial(ResourceId id);
-  ResourcePtr CreateVariable(ResourceId id,
-                             ::fuchsia::ui::gfx::VariableArgs args);
-
-  // Return false and log an error if the value is not of the expected type.
-  // NOTE: although failure does not halt execution of the program, it does
-  // indicate client error, and will be used by the caller to tear down the
-  // Session.
-  bool AssertValueIsOfType(const ::fuchsia::ui::gfx::Value& value,
-                           const ::fuchsia::ui::gfx::Value::Tag* tags,
-                           size_t tag_count);
-  template <size_t N>
-  bool AssertValueIsOfType(
-      const ::fuchsia::ui::gfx::Value& value,
-      const std::array<::fuchsia::ui::gfx::Value::Tag, N>& tags) {
-    return AssertValueIsOfType(value, tags.data(), N);
-  }
-
   friend class Resource;
   void IncrementResourceCount() { ++resource_count_; }
   void DecrementResourceCount() { --resource_count_; }
@@ -314,7 +129,7 @@
 
     std::vector<::fuchsia::ui::gfx::Command> commands;
     std::unique_ptr<escher::FenceSetListener> acquire_fences;
-    ::std::vector<zx::event> release_fences;
+    std::vector<zx::event> release_fences;
 
     // Callback to report when the update has been applied in response to
     // an invocation of |Session.Present()|.
@@ -323,7 +138,7 @@
   bool ApplyUpdate(CommandContext* command_context,
                    std::vector<::fuchsia::ui::gfx::Command> commands);
   std::queue<Update> scheduled_updates_;
-  ::std::vector<zx::event> fences_to_release_on_next_update_;
+  std::vector<zx::event> fences_to_release_on_next_update_;
 
   uint64_t last_applied_update_presentation_time_ = 0;
   uint64_t last_presentation_time_ = 0;
@@ -350,11 +165,8 @@
   // Resources; their lifecycle must exceed that of the Resources.
   SessionContext session_context_;
   ResourceContext resource_context_;
-
   ResourceMap resources_;
-
   size_t resource_count_ = 0;
-  bool is_valid_ = true;
 
   fxl::WeakPtrFactory<Session> weak_factory_;  // must be last
 };
diff --git a/lib/ui/gfx/engine/session_handler.cc b/lib/ui/gfx/engine/session_handler.cc
index 2ab7b52..1406226 100644
--- a/lib/ui/gfx/engine/session_handler.cc
+++ b/lib/ui/gfx/engine/session_handler.cc
@@ -4,6 +4,8 @@
 
 #include "garnet/lib/ui/gfx/engine/session_handler.h"
 
+#include <memory>
+
 #include "garnet/lib/ui/scenic/session.h"
 #include "lib/ui/scenic/cpp/commands.h"
 
@@ -20,15 +22,18 @@
       session_manager_(session_manager),
       event_reporter_(event_reporter),
       error_reporter_(error_reporter),
-      session_(::fxl::MakeRefCounted<scenic_impl::gfx::Session>(
-          session_id, std::move(session_context), event_reporter,
-          error_reporter)) {
+      session_(std::make_unique<Session>(session_id, std::move(session_context),
+                                         event_reporter, error_reporter)) {
   FXL_DCHECK(session_manager_);
 }
 
-SessionHandler::~SessionHandler() {
-  TearDown();
-  session_manager_->RemoveSession(session_->id());
+SessionHandler::~SessionHandler() { CleanUp(); }
+
+void SessionHandler::CleanUp() {
+  if (session_.get() != nullptr) {
+    session_manager_->RemoveSessionHandler(session_->id());
+    session_.reset();
+  }
 }
 
 void SessionHandler::Present(
@@ -40,8 +45,9 @@
           std::move(acquire_fences), std::move(release_fences),
           std::move(callback))) {
     BeginTearDown();
+  } else {
+    buffered_commands_.clear();
   }
-  buffered_commands_.clear();
 }
 
 void SessionHandler::HitTest(
@@ -65,17 +71,9 @@
 }
 
 void SessionHandler::BeginTearDown() {
-  session_manager_->TearDownSession(session_->id());
-  FXL_DCHECK(!session_->is_valid());
-}
-
-void SessionHandler::TearDown() {
-  session_->TearDown();
-
-  // Close the parent Mozart session.
-  if (context() && context()->session()) {
-    context()->scenic()->CloseSession(context()->session());
-  }
+  // Since this is essentially a self destruct
+  // call, it's safest not call anything after this
+  context()->KillSession();
 }
 
 }  // namespace gfx
diff --git a/lib/ui/gfx/engine/session_handler.h b/lib/ui/gfx/engine/session_handler.h
index e694996..30d136f 100644
--- a/lib/ui/gfx/engine/session_handler.h
+++ b/lib/ui/gfx/engine/session_handler.h
@@ -5,13 +5,13 @@
 #ifndef GARNET_LIB_UI_GFX_ENGINE_SESSION_HANDLER_H_
 #define GARNET_LIB_UI_GFX_ENGINE_SESSION_HANDLER_H_
 
+#include "garnet/lib/ui/gfx/engine/session.h"
 #include "lib/fidl/cpp/binding_set.h"
 #include "lib/fidl/cpp/interface_ptr_set.h"
 #include "lib/fxl/tasks/task_runner.h"
 
 #include <fuchsia/ui/scenic/cpp/fidl.h>
 #include "garnet/lib/ui/gfx/engine/engine.h"
-#include "garnet/lib/ui/gfx/engine/session.h"
 #include "garnet/lib/ui/scenic/command_dispatcher.h"
 #include "garnet/lib/ui/scenic/event_reporter.h"
 #include "garnet/lib/ui/scenic/util/error_reporter.h"
@@ -66,19 +66,21 @@
  private:
   friend class SessionManager;
 
-  // Called by |binding_| when the connection closes. Must be invoked within
-  // the SessionHandler MessageLoop.
+  // Called to initiate a session crash when an update fails.
+  // Requests the destruction of client fidl session, which
+  // then triggers the actual destruction of the SessionHandler
   void BeginTearDown();
 
-  // Called only by Engine. Use BeginTearDown() instead when you need to
-  // teardown from within SessionHandler.
-  void TearDown();
+  // Remove SessionHandler reference from SessionManager
+  // and destroy gfx::Session
+  void CleanUp();
 
   SessionManager* const session_manager_;
 
   EventReporter* const event_reporter_;
   ErrorReporter* const error_reporter_;
-  scenic_impl::gfx::SessionPtr session_;
+
+  std::unique_ptr<Session> session_;
 
   // TODO(SCN-710): We reallocate this everytime we std::move it into
   // ScheduleUpdate().  The bug has some ideas about how to do better.
diff --git a/lib/ui/gfx/engine/session_manager.cc b/lib/ui/gfx/engine/session_manager.cc
index 1e915e7..dff2a3b 100644
--- a/lib/ui/gfx/engine/session_manager.cc
+++ b/lib/ui/gfx/engine/session_manager.cc
@@ -28,9 +28,9 @@
   }
 }
 
-SessionHandler* SessionManager::FindSession(SessionId id) {
-  auto it = session_manager_.find(id);
-  if (it != session_manager_.end()) {
+SessionHandler* SessionManager::FindSessionHandler(SessionId id) {
+  auto it = session_handlers_.find(id);
+  if (it != session_handlers_.end()) {
     return it->second;
   }
   return nullptr;
@@ -51,18 +51,23 @@
   scenic_impl::Session* session = context.session();
   auto handler = CreateSessionHandler(std::move(context), engine, session_id,
                                       session, session->error_reporter());
-  session_manager_.insert({session_id, handler.get()});
-  ++session_count_;
-
+  InsertSessionHandler(session_id, handler.get());
   return handler;
 }
 
-void SessionManager::ScheduleUpdateForSession(UpdateScheduler* update_scheduler,
-                                              uint64_t presentation_time,
-                                              fxl::RefPtr<Session> session) {
+void SessionManager::InsertSessionHandler(SessionId session_id,
+                                          SessionHandler* session_handler) {
+  FXL_DCHECK(session_handlers_.find(session_id) == session_handlers_.end());
+  session_handlers_.insert({session_id, session_handler});
+  ++session_count_;
+}
+
+void SessionManager::ScheduleUpdateForSession(
+    UpdateScheduler* update_scheduler, uint64_t presentation_time,
+    fxl::WeakPtr<scenic_impl::gfx::Session> session) {
   FXL_DCHECK(update_scheduler);
-  if (session->is_valid()) {
-    updatable_sessions_.insert({presentation_time, std::move(session)});
+  if (session) {
+    updatable_sessions_.push({presentation_time, std::move(session)});
     update_scheduler->ScheduleUpdate(presentation_time);
   }
 }
@@ -75,14 +80,23 @@
 
   bool needs_render = false;
   while (!updatable_sessions_.empty()) {
-    auto top = updatable_sessions_.begin();
-    if (top->first > presentation_time)
+    auto& top = updatable_sessions_.top();
+    if (top.first > presentation_time)
       break;
-    auto session = std::move(top->second);
-    updatable_sessions_.erase(top);
-    if (session) {
-      needs_render |= session->ApplyScheduledUpdates(
+    auto session = std::move(top.second);
+    updatable_sessions_.pop();
+    if (session.get() != nullptr) {
+      auto update_results = session->ApplyScheduledUpdates(
           command_context, presentation_time, presentation_interval);
+
+      needs_render |= update_results.needs_render;
+
+      // If update fails, kill the entire client session
+      if (!update_results.success) {
+        auto session_handler = FindSessionHandler(session->id());
+        FXL_DCHECK(session_handler);
+        session_handler->BeginTearDown();
+      }
     } else {
       // Corresponds to a call to ScheduleUpdate(), which always triggers a
       // render.
@@ -92,26 +106,10 @@
   return needs_render;
 }
 
-void SessionManager::TearDownSession(SessionId id) {
-  auto it = session_manager_.find(id);
-  FXL_DCHECK(it != session_manager_.end());
-  if (it != session_manager_.end()) {
-    SessionHandler* handler = std::move(it->second);
-    session_manager_.erase(it);
-    FXL_DCHECK(session_count_ > 0);
-    --session_count_;
-
-    // Don't destroy handler immediately, since it may be the one calling
-    // TearDownSession().
-    async::PostTask(async_get_default_dispatcher(),
-                    [handler] { handler->TearDown(); });
-  }
-}
-
-void SessionManager::RemoveSession(SessionId id) {
-  auto it = session_manager_.find(id);
-  if (it != session_manager_.end()) {
-    session_manager_.erase(it);
+void SessionManager::RemoveSessionHandler(SessionId id) {
+  auto it = session_handlers_.find(id);
+  if (it != session_handlers_.end()) {
+    session_handlers_.erase(it);
     FXL_DCHECK(session_count_ > 0);
     --session_count_;
   }
diff --git a/lib/ui/gfx/engine/session_manager.h b/lib/ui/gfx/engine/session_manager.h
index 766de85..9fd4475 100644
--- a/lib/ui/gfx/engine/session_manager.h
+++ b/lib/ui/gfx/engine/session_manager.h
@@ -8,6 +8,7 @@
 #include <set>
 #include <unordered_map>
 
+#include "garnet/lib/ui/gfx/engine/session.h"
 #include "garnet/lib/ui/scenic/command_dispatcher.h"
 #include "lib/escher/renderer/batch_gpu_uploader.h"
 
@@ -20,9 +21,9 @@
 namespace gfx {
 
 using SessionId = ::scenic_impl::SessionId;
+using PresentationTime = uint64_t;
 
 class SessionHandler;
-class Session;
 class Engine;
 class UpdateScheduler;
 
@@ -55,7 +56,7 @@
   virtual ~SessionManager() = default;
 
   // Finds the session handler corresponding to the given id.
-  SessionHandler* FindSession(SessionId id);
+  SessionHandler* FindSessionHandler(SessionId id);
 
   size_t GetSessionCount() { return session_count_; }
 
@@ -66,9 +67,9 @@
 
   // Tell the UpdateScheduler to schedule a frame, and remember the Session so
   // that we can tell it to apply updates in ApplyScheduledSessionUpdates().
-  void ScheduleUpdateForSession(UpdateScheduler* update_scheduler,
-                                uint64_t presentation_time,
-                                fxl::RefPtr<Session> session);
+  void ScheduleUpdateForSession(
+      UpdateScheduler* update_scheduler, uint64_t presentation_time,
+      fxl::WeakPtr<scenic_impl::gfx::Session> session);
 
   // Executes updates that are schedule up to and including a given presentation
   // time. Returns true if rendering is needed.
@@ -76,29 +77,45 @@
                                     uint64_t presentation_time,
                                     uint64_t presentation_interval);
 
+ protected:
+  // Protected for testing subclass
+  void InsertSessionHandler(SessionId session_id,
+                            SessionHandler* session_handler);
+
  private:
-  friend class Session;
   friend class SessionHandler;
 
-  // Destroys the session with the given id.
-  void TearDownSession(SessionId id);
+  // Used to compare presentation times so that the priority_queue acts as a min
+  // heap, placing the earliest PresentationTime at the top
+  class UpdatableSessionsComparator {
+   public:
+    bool operator()(
+        std::pair<PresentationTime, fxl::WeakPtr<Session>> updatable_session1,
+        std::pair<PresentationTime, fxl::WeakPtr<Session>> updatable_session2) {
+      return updatable_session1.first > updatable_session2.first;
+    }
+  };
 
-  // Removes the session from the session_manager_ map.  We assume that the
-  // SessionHandler has already taken care of itself and its Session.
-  void RemoveSession(SessionId id);
+  // Removes the SessionHandler from the session_handlers_ map.  We assume that
+  // the SessionHandler has already taken care of itself and its Session.
+  void RemoveSessionHandler(SessionId id);
 
   virtual std::unique_ptr<SessionHandler> CreateSessionHandler(
       CommandDispatcherContext context, Engine* engine, SessionId session_id,
       EventReporter* event_reporter, ErrorReporter* error_reporter) const;
 
   // Map of all the sessions.
-  std::unordered_map<SessionId, SessionHandler*> session_manager_;
+  std::unordered_map<SessionId, SessionHandler*> session_handlers_;
   size_t session_count_ = 0;
   SessionId next_session_id_ = 1;
 
   // Lists all Session that have updates to apply, sorted by the earliest
   // requested presentation time of each update.
-  std::set<std::pair<uint64_t, fxl::RefPtr<Session>>> updatable_sessions_;
+  std::priority_queue<
+      std::pair<PresentationTime, fxl::WeakPtr<Session>>,
+      std::vector<std::pair<PresentationTime, fxl::WeakPtr<Session>>>,
+      UpdatableSessionsComparator>
+      updatable_sessions_;
 };
 
 }  // namespace gfx
diff --git a/lib/ui/gfx/gfx_system.cc b/lib/ui/gfx/gfx_system.cc
index f05b1e0..ffc3a7d 100644
--- a/lib/ui/gfx/gfx_system.cc
+++ b/lib/ui/gfx/gfx_system.cc
@@ -323,7 +323,8 @@
 }
 
 gfx::Session* GfxSystem::GetSession(SessionId session_id) const {
-  SessionHandler* handler = engine_->session_manager()->FindSession(session_id);
+  SessionHandler* handler =
+      engine_->session_manager()->FindSessionHandler(session_id);
   return handler ? handler->session() : nullptr;
 }
 
diff --git a/lib/ui/gfx/tests/BUILD.gn b/lib/ui/gfx/tests/BUILD.gn
index b9903b1..1f4a79f 100644
--- a/lib/ui/gfx/tests/BUILD.gn
+++ b/lib/ui/gfx/tests/BUILD.gn
@@ -20,6 +20,8 @@
     "gfx_test.h",
     "mocks.cc",
     "mocks.h",
+    "session_handler_test.cc",
+    "session_handler_test.h",
     "session_test.cc",
     "session_test.h",
     "vk_session_test.cc",
@@ -60,6 +62,7 @@
   sources = [
     "escher_vulkan_smoke_test.cc",
     "event_timestamper_unittest.cc",
+    "gfx_command_applier_unittest.cc",
     "hardware_layer_assignment_unittest.cc",
     "hittest_global_unittest.cc",
     "hittest_unittest.cc",
@@ -72,6 +75,7 @@
     "resource_linker_unittest.cc",
     "run_all_unittests.cc",
     "scene_graph_unittest.cc",
+    "session_handler_unittest.cc",
     "session_unittest.cc",
     "shape_unittest.cc",
     "size_change_hint_unittest.cc",
diff --git a/lib/ui/gfx/tests/gfx_apptest.cc b/lib/ui/gfx/tests/gfx_apptest.cc
index 6321bff..97351e1 100644
--- a/lib/ui/gfx/tests/gfx_apptest.cc
+++ b/lib/ui/gfx/tests/gfx_apptest.cc
@@ -66,9 +66,9 @@
   RunLoopUntilIdle();
   EXPECT_EQ(1U, scenic()->num_sessions());
   auto handler = static_cast<SessionHandlerForTest*>(
-      gfx_system()->engine()->session_manager()->FindSession(1));
+      gfx_system()->engine()->session_manager()->FindSessionHandler(1));
   {
-    ::std::vector<fuchsia::ui::scenic::Command> commands;
+    std::vector<fuchsia::ui::scenic::Command> commands;
     commands.push_back(scenic::NewCommand(scenic::NewCreateCircleCmd(1, 50.f)));
     commands.push_back(scenic::NewCommand(scenic::NewCreateCircleCmd(2, 25.f)));
 
@@ -77,22 +77,20 @@
   RunLoopUntilIdle();
   EXPECT_EQ(2u, handler->command_count());
   // Create release fences
-  ::std::vector<zx::event> release_fences = CreateEventArray(2);
+  std::vector<zx::event> release_fences = CreateEventArray(2);
   zx::event release_fence1 = CopyEvent(release_fences.at(0));
   zx::event release_fence2 = CopyEvent(release_fences.at(1));
   EXPECT_FALSE(IsFenceSignalled(release_fence1));
   EXPECT_FALSE(IsFenceSignalled(release_fence2));
   // Call Present with release fences.
-  session->Present(0u, std::vector<zx::event>(),
-                   std::move(release_fences),
+  session->Present(0u, std::vector<zx::event>(), std::move(release_fences),
                    [](fuchsia::images::PresentationInfo info) {});
   RunLoopUntilIdle();
   EXPECT_EQ(1u, handler->present_count());
   EXPECT_FALSE(IsFenceSignalled(release_fence1));
   EXPECT_FALSE(IsFenceSignalled(release_fence2));
   // Call Present again with no release fences.
-  session->Present(0u, ::std::vector<zx::event>(),
-                   ::std::vector<zx::event>(),
+  session->Present(0u, std::vector<zx::event>(), std::vector<zx::event>(),
                    [](fuchsia::images::PresentationInfo info) {});
   RunLoopUntilIdle();
   EXPECT_EQ(2u, handler->present_count());
@@ -109,9 +107,9 @@
   RunLoopUntilIdle();
   EXPECT_EQ(1U, scenic()->num_sessions());
   auto handler = static_cast<SessionHandlerForTest*>(
-      gfx_system()->engine()->session_manager()->FindSession(1));
+      gfx_system()->engine()->session_manager()->FindSessionHandler(1));
   {
-    ::std::vector<fuchsia::ui::scenic::Command> commands;
+    std::vector<fuchsia::ui::scenic::Command> commands;
     commands.push_back(scenic::NewCommand(scenic::NewCreateCircleCmd(1, 50.f)));
     commands.push_back(scenic::NewCommand(scenic::NewCreateCircleCmd(2, 25.f)));
 
@@ -124,9 +122,9 @@
   ASSERT_EQ(ZX_OK, zx::event::create(0, &acquire_fence));
   zx::event release_fence;
   ASSERT_EQ(ZX_OK, zx::event::create(0, &release_fence));
-  ::std::vector<zx::event> acquire_fences;
+  std::vector<zx::event> acquire_fences;
   acquire_fences.push_back(CopyEvent(acquire_fence));
-  ::std::vector<zx::event> release_fences;
+  std::vector<zx::event> release_fences;
   release_fences.push_back(CopyEvent(release_fence));
   // Call Present with both the acquire and release fences.
   session->Present(0u, std::move(acquire_fences), std::move(release_fences),
@@ -135,8 +133,7 @@
   EXPECT_EQ(1u, handler->present_count());
   EXPECT_FALSE(IsFenceSignalled(release_fence));
   // Call Present again with no fences.
-  session->Present(0u, ::std::vector<zx::event>(),
-                   ::std::vector<zx::event>(),
+  session->Present(0u, std::vector<zx::event>(), std::vector<zx::event>(),
                    [](fuchsia::images::PresentationInfo info) {});
   RunLoopUntilIdle();
   EXPECT_EQ(2u, handler->present_count());
diff --git a/lib/ui/gfx/tests/gfx_command_applier_unittest.cc b/lib/ui/gfx/tests/gfx_command_applier_unittest.cc
new file mode 100644
index 0000000..4f7b557
--- /dev/null
+++ b/lib/ui/gfx/tests/gfx_command_applier_unittest.cc
@@ -0,0 +1,72 @@
+// Copyright 2019 The Fuchsia 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 "garnet/lib/ui/gfx/engine/gfx_command_applier.h"
+#include "garnet/lib/ui/gfx/tests/session_test.h"
+
+#include "lib/ui/scenic/cpp/commands.h"
+
+#include "gtest/gtest.h"
+
+namespace scenic_impl {
+namespace gfx {
+namespace test {
+
+using GfxCommandApplierTest = SessionTest;
+
+TEST_F(GfxCommandApplierTest, NewCreateEntityNodeCmd) {
+  CommandContext empty_command_context(nullptr);
+
+  // Valid id passes
+  EXPECT_TRUE(GfxCommandApplier::ApplyCommand(
+      session_.get(), &empty_command_context,
+      scenic::NewCreateEntityNodeCmd(/*id*/ 1)));
+
+  // Invalid id fails
+  EXPECT_FALSE(GfxCommandApplier::ApplyCommand(
+      session_.get(), &empty_command_context,
+      scenic::NewCreateEntityNodeCmd(/*id*/ 0)));
+}
+
+TEST_F(GfxCommandApplierTest, EraseResource) {
+  CommandContext empty_command_context(nullptr);
+  EXPECT_TRUE(GfxCommandApplier::ApplyCommand(
+      session_.get(), &empty_command_context,
+      scenic::NewCreateEntityNodeCmd(/*id*/ 3)));
+  // Erasing non-existent resource fails
+  EXPECT_FALSE(
+      GfxCommandApplier::ApplyCommand(session_.get(), &empty_command_context,
+                                      scenic::NewReleaseResourceCmd(/*id*/ 2)));
+
+  // Erasing existing resource passes
+  EXPECT_TRUE(
+      GfxCommandApplier::ApplyCommand(session_.get(), &empty_command_context,
+                                      scenic::NewReleaseResourceCmd(/*id*/ 3)));
+}
+
+TEST_F(GfxCommandApplierTest, SeparateSessionsAreIndependent) {
+  auto session2 = CreateSession();
+
+  CommandContext empty_command_context(nullptr);
+
+  EXPECT_TRUE(GfxCommandApplier::ApplyCommand(
+      session_.get(), &empty_command_context,
+      scenic::NewCreateEntityNodeCmd(/*id*/ 3)));
+  EXPECT_FALSE(
+      GfxCommandApplier::ApplyCommand(session2.get(), &empty_command_context,
+                                      scenic::NewReleaseResourceCmd(/*id*/ 3)));
+  EXPECT_TRUE(GfxCommandApplier::ApplyCommand(
+      session2.get(), &empty_command_context,
+      scenic::NewCreateEntityNodeCmd(/*id*/ 3)));
+  EXPECT_TRUE(
+      GfxCommandApplier::ApplyCommand(session_.get(), &empty_command_context,
+                                      scenic::NewReleaseResourceCmd(/*id*/ 3)));
+  EXPECT_TRUE(
+      GfxCommandApplier::ApplyCommand(session2.get(), &empty_command_context,
+                                      scenic::NewReleaseResourceCmd(/*id*/ 3)));
+}
+
+}  // namespace test
+}  // namespace gfx
+}  // namespace scenic_impl
diff --git a/lib/ui/gfx/tests/hittest_global_unittest.cc b/lib/ui/gfx/tests/hittest_global_unittest.cc
index 1e4d3dc..8154a50 100644
--- a/lib/ui/gfx/tests/hittest_global_unittest.cc
+++ b/lib/ui/gfx/tests/hittest_global_unittest.cc
@@ -46,14 +46,10 @@
 class CustomSession {
  public:
   CustomSession(SessionId id, SessionContext session_context) {
-    session_ =
-        fxl::MakeRefCounted<SessionForTest>(id, std::move(session_context));
+    session_ = std::make_unique<SessionForTest>(id, std::move(session_context));
   }
 
-  ~CustomSession() {
-    session_->TearDown();
-    session_ = nullptr;
-  }
+  ~CustomSession() {}
 
   void Apply(::fuchsia::ui::gfx::Command command) {
     CommandContext empty_command_context(nullptr);
@@ -63,7 +59,7 @@
   }
 
  private:
-  fxl::RefPtr<SessionForTest> session_;
+  std::unique_ptr<SessionForTest> session_;
 };
 
 // Loop fixture provides dispatcher for Engine's EventTimestamper.
diff --git a/lib/ui/gfx/tests/image_pipe_unittest.cc b/lib/ui/gfx/tests/image_pipe_unittest.cc
index 75a842f..e52a2d4 100644
--- a/lib/ui/gfx/tests/image_pipe_unittest.cc
+++ b/lib/ui/gfx/tests/image_pipe_unittest.cc
@@ -39,7 +39,7 @@
  public:
   ImagePipeTest() : escher::ResourceManager(escher::EscherWeakPtr()) {}
 
-  fxl::RefPtr<SessionForTest> CreateSession() override {
+  std::unique_ptr<SessionForTest> CreateSession() override {
     SessionContext session_context = CreateBarebonesSessionContext();
 
     command_buffer_sequencer_ =
@@ -51,8 +51,8 @@
     session_context.release_fence_signaller =
         mock_release_fence_signaller_.get();
 
-    return fxl::MakeRefCounted<SessionForTest>(1, std::move(session_context),
-                                               this, error_reporter());
+    return std::make_unique<SessionForTest>(1, std::move(session_context), this,
+                                            error_reporter());
   }
 
   void OnReceiveOwnable(std::unique_ptr<escher::Resource> resource) override {}
@@ -364,8 +364,10 @@
       imageIdB, std::move(image_info_b), CopyVmo(gradient_b->vmo()), 0,
       GetVmoSize(gradient_b->vmo()), fuchsia::images::MemoryType::HOST_MEMORY);
 
-  image_pipe->PresentImage(imageIdA, 0, std::vector<zx::event>(), std::vector<zx::event>(), nullptr);
-  image_pipe->PresentImage(imageIdB, 0, std::vector<zx::event>(), std::vector<zx::event>(), nullptr);
+  image_pipe->PresentImage(imageIdA, 0, std::vector<zx::event>(),
+                           std::vector<zx::event>(), nullptr);
+  image_pipe->PresentImage(imageIdB, 0, std::vector<zx::event>(),
+                           std::vector<zx::event>(), nullptr);
 
   RunLoopUntilIdle();
 
@@ -384,9 +386,11 @@
   // In this case, we need to run to idle after presenting image A, so that
   // image B is returned by the pool, marked dirty, and is free to be acquired
   // again.
-  image_pipe->PresentImage(imageIdA, 0, std::vector<zx::event>(), std::vector<zx::event>(), nullptr);
+  image_pipe->PresentImage(imageIdA, 0, std::vector<zx::event>(),
+                           std::vector<zx::event>(), nullptr);
   RunLoopUntilIdle();
-  image_pipe->PresentImage(imageIdB, 0, std::vector<zx::event>(), std::vector<zx::event>(), nullptr);
+  image_pipe->PresentImage(imageIdB, 0, std::vector<zx::event>(),
+                           std::vector<zx::event>(), nullptr);
   RunLoopUntilIdle();
 
   image_out = image_pipe->GetEscherImage();
diff --git a/lib/ui/gfx/tests/import_unittest.cc b/lib/ui/gfx/tests/import_unittest.cc
index 0244ec1..3ceab15 100644
--- a/lib/ui/gfx/tests/import_unittest.cc
+++ b/lib/ui/gfx/tests/import_unittest.cc
@@ -18,14 +18,14 @@
  public:
   ImportTest() {}
 
-  fxl::RefPtr<SessionForTest> CreateSession() override {
+  std::unique_ptr<SessionForTest> CreateSession() override {
     SessionContext session_context = CreateBarebonesSessionContext();
 
     resource_linker_ = std::make_unique<ResourceLinker>();
     session_context.resource_linker = resource_linker_.get();
 
-    return fxl::MakeRefCounted<SessionForTest>(1, std::move(session_context),
-                                               this, error_reporter());
+    return std::make_unique<SessionForTest>(1, std::move(session_context), this,
+                                            error_reporter());
   }
 
   std::unique_ptr<ResourceLinker> resource_linker_;
diff --git a/lib/ui/gfx/tests/mocks.cc b/lib/ui/gfx/tests/mocks.cc
index 0ef6d86..c013d2f 100644
--- a/lib/ui/gfx/tests/mocks.cc
+++ b/lib/ui/gfx/tests/mocks.cc
@@ -4,6 +4,7 @@
 
 #include "garnet/lib/ui/gfx/tests/mocks.h"
 
+#include "garnet/lib/ui/gfx/tests/session_test.h"
 #include "garnet/lib/ui/scenic/command_dispatcher.h"
 
 namespace scenic_impl {
@@ -15,17 +16,15 @@
                                ErrorReporter* error_reporter)
     : Session(id, std::move(context), event_reporter, error_reporter) {}
 
-void SessionForTest::TearDown() { Session::TearDown(); }
-
-SessionHandlerForTest::SessionHandlerForTest(CommandDispatcherContext context,
-                                             SessionManager* session_manager,
+SessionHandlerForTest::SessionHandlerForTest(SessionManager* session_manager,
                                              SessionContext session_context,
                                              SessionId session_id,
+                                             Scenic* scenic,
                                              EventReporter* event_reporter,
                                              ErrorReporter* error_reporter)
-    : SessionHandler(std::move(context), session_manager,
-                     std::move(session_context), session_id, event_reporter,
-                     error_reporter),
+    : SessionHandler(CommandDispatcherContext(scenic, nullptr, session_id),
+                     session_manager, std::move(session_context), session_id,
+                     event_reporter, error_reporter),
       command_count_(0),
       present_count_(0) {}
 
@@ -56,12 +55,9 @@
 
 SessionManagerForTest::SessionManagerForTest() : SessionManager() {}
 
-std::unique_ptr<SessionHandler> SessionManagerForTest::CreateSessionHandler(
-    CommandDispatcherContext context, Engine* engine, SessionId session_id,
-    EventReporter* event_reporter, ErrorReporter* error_reporter) const {
-  return std::make_unique<SessionHandlerForTest>(
-      std::move(context), engine->session_manager(), engine->session_context(),
-      session_id, event_reporter, error_reporter);
+void SessionManagerForTest::InsertSessionHandler(
+    SessionId session_id, SessionHandler* session_handler) {
+  SessionManager::InsertSessionHandler(session_id, session_handler);
 }
 
 EngineForTest::EngineForTest(DisplayManager* display_manager,
diff --git a/lib/ui/gfx/tests/mocks.h b/lib/ui/gfx/tests/mocks.h
index 9739152..578c69d 100644
--- a/lib/ui/gfx/tests/mocks.h
+++ b/lib/ui/gfx/tests/mocks.h
@@ -9,6 +9,7 @@
 #include "garnet/lib/ui/gfx/engine/engine.h"
 #include "garnet/lib/ui/gfx/engine/session.h"
 #include "garnet/lib/ui/gfx/engine/session_handler.h"
+#include "garnet/lib/ui/scenic/scenic.h"
 #include "lib/escher/flib/release_fence_signaller.h"
 
 namespace scenic_impl {
@@ -20,15 +21,13 @@
   SessionForTest(SessionId id, SessionContext context,
                  EventReporter* event_reporter = EventReporter::Default(),
                  ErrorReporter* error_reporter = ErrorReporter::Default());
-
-  virtual void TearDown() override;
 };
 
 class SessionHandlerForTest : public SessionHandler {
  public:
   SessionHandlerForTest(
-      CommandDispatcherContext context, SessionManager* session_manager,
-      SessionContext session_context, SessionId session_id,
+      SessionManager* session_manager, SessionContext session_context,
+      SessionId session_id, Scenic* scenic,
       EventReporter* event_reporter = EventReporter::Default(),
       ErrorReporter* error_reporter = ErrorReporter::Default());
 
@@ -70,12 +69,8 @@
 class SessionManagerForTest : public SessionManager {
  public:
   SessionManagerForTest();
-
- private:
-  std::unique_ptr<SessionHandler> CreateSessionHandler(
-      CommandDispatcherContext context, Engine* engine, SessionId session_id,
-      EventReporter* event_reporter,
-      ErrorReporter* error_reporter) const override;
+  void InsertSessionHandler(SessionId session_id,
+                            SessionHandler* session_handler);
 };
 
 class EngineForTest : public Engine {
diff --git a/lib/ui/gfx/tests/resource_linker_unittest.cc b/lib/ui/gfx/tests/resource_linker_unittest.cc
index 71ec51d..1d57f64 100644
--- a/lib/ui/gfx/tests/resource_linker_unittest.cc
+++ b/lib/ui/gfx/tests/resource_linker_unittest.cc
@@ -21,14 +21,14 @@
  public:
   ResourceLinkerTest() {}
 
-  fxl::RefPtr<SessionForTest> CreateSession() override {
+  std::unique_ptr<SessionForTest> CreateSession() override {
     SessionContext session_context = CreateBarebonesSessionContext();
 
     resource_linker_ = std::make_unique<ResourceLinker>();
     session_context.resource_linker = resource_linker_.get();
 
-    return fxl::MakeRefCounted<SessionForTest>(1, std::move(session_context),
-                                               this, error_reporter());
+    return std::make_unique<SessionForTest>(1, std::move(session_context), this,
+                                            error_reporter());
   }
 
   std::unique_ptr<ResourceLinker> resource_linker_;
diff --git a/lib/ui/gfx/tests/session_handler_test.cc b/lib/ui/gfx/tests/session_handler_test.cc
new file mode 100644
index 0000000..5ac5b68
--- /dev/null
+++ b/lib/ui/gfx/tests/session_handler_test.cc
@@ -0,0 +1,42 @@
+// Copyright 2019 The Fuchsia 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 "garnet/lib/ui/gfx/tests/session_handler_test.h"
+
+namespace scenic_impl {
+namespace gfx {
+namespace test {
+
+void SessionHandlerTest::SetUp() { SessionTest::SetUp(); }
+
+void SessionHandlerTest::TearDown() {
+  SessionTest::TearDown();
+  session_handler_.reset();
+  scenic_.reset();
+  app_context_.reset();
+}
+
+void SessionHandlerTest::InitializeScenic() {
+  // TODO(SCN-720): Wrap CreateFromStartupInfo using ::gtest::Environment
+  // instead of this hack.  This code has the chance to break non-ScenicTests.
+  app_context_ = component::StartupContext::CreateFromStartupInfo();
+  scenic_ = std::make_unique<Scenic>(app_context_.get(), [] {});
+}
+
+void SessionHandlerTest::InitializeSessionHandler() {
+  if (!scenic_) {
+    InitializeScenic();
+  }
+
+  auto session_context = CreateBarebonesSessionContext();
+  session_handler_ = std::make_unique<SessionHandlerForTest>(
+      session_manager_.get(), std::move(session_context), session_->id(),
+      scenic_.get());
+  session_manager_->InsertSessionHandler(session_->id(),
+                                         session_handler_.get());
+}
+
+}  // namespace test
+}  // namespace gfx
+}  // namespace scenic_impl
diff --git a/lib/ui/gfx/tests/session_handler_test.h b/lib/ui/gfx/tests/session_handler_test.h
new file mode 100644
index 0000000..be07096
--- /dev/null
+++ b/lib/ui/gfx/tests/session_handler_test.h
@@ -0,0 +1,45 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GARNET_LIB_UI_GFX_TESTS_SESSION_HANDLER_TEST_H_
+#define GARNET_LIB_UI_GFX_TESTS_SESSION_HANDLER_TEST_H_
+
+#include "garnet/lib/ui/gfx/tests/session_test.h"
+
+#include <lib/fit/function.h>
+
+#include "garnet/lib/ui/gfx/displays/display_manager.h"
+#include "garnet/lib/ui/gfx/engine/engine.h"
+#include "garnet/lib/ui/gfx/engine/session.h"
+#include "garnet/lib/ui/gfx/tests/mocks.h"
+#include "garnet/lib/ui/scenic/event_reporter.h"
+#include "garnet/lib/ui/scenic/tests/scenic_test.h"
+#include "lib/gtest/test_loop_fixture.h"
+
+namespace scenic_impl {
+namespace gfx {
+namespace test {
+
+// For testing SessionHandler without having to manually provide all the state
+// necessary for SessionHandler to run
+class SessionHandlerTest : public SessionTest {
+ public:
+  void ResetSessionHandler() { session_handler_.reset(); }
+  void InitializeScenic();
+  void InitializeSessionHandler();
+
+  void SetUp() override;
+  void TearDown() override;
+
+ protected:
+  std::unique_ptr<component::StartupContext> app_context_;
+  std::unique_ptr<Scenic> scenic_;
+  std::unique_ptr<SessionHandlerForTest> session_handler_;
+};
+
+}  // namespace test
+}  // namespace gfx
+}  // namespace scenic_impl
+
+#endif  // GARNET_LIB_UI_GFX_TESTS_SESSION_HANDLER_TEST_H_
diff --git a/lib/ui/gfx/tests/session_handler_unittest.cc b/lib/ui/gfx/tests/session_handler_unittest.cc
new file mode 100644
index 0000000..3ba37e7
--- /dev/null
+++ b/lib/ui/gfx/tests/session_handler_unittest.cc
@@ -0,0 +1,30 @@
+// Copyright 2019 The Fuchsia 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 "garnet/lib/ui/gfx/tests/session_handler_test.h"
+
+#include "gtest/gtest.h"
+
+namespace scenic_impl {
+namespace gfx {
+namespace test {
+
+TEST_F(
+    SessionHandlerTest,
+    WhenSessionHandlerDestroyed_ShouldRemoveSessionHandlerPtrFromSessionManager) {
+  InitializeSessionHandler();
+  auto id = session_->id();
+
+  EXPECT_NE(session_handler_.get(), nullptr);
+  EXPECT_EQ(session_manager_->FindSessionHandler(id), session_handler_.get());
+
+  ResetSessionHandler();
+
+  EXPECT_EQ(session_handler_.get(), nullptr);
+  EXPECT_EQ(session_manager_->FindSessionHandler(id), nullptr);
+}
+
+}  // namespace test
+}  // namespace gfx
+}  // namespace scenic_impl
diff --git a/lib/ui/gfx/tests/session_test.cc b/lib/ui/gfx/tests/session_test.cc
index 185008d..a902842 100644
--- a/lib/ui/gfx/tests/session_test.cc
+++ b/lib/ui/gfx/tests/session_test.cc
@@ -6,6 +6,8 @@
 
 #include "garnet/lib/ui/gfx/tests/mocks.h"
 
+#include "lib/fxl/logging.h"
+
 namespace scenic_impl {
 namespace gfx {
 namespace test {
@@ -22,13 +24,15 @@
 void SessionTest::SetUp() { session_ = CreateSession(); }
 
 void SessionTest::TearDown() {
-  session_->TearDown();
-  session_ = nullptr;
+  session_manager_.reset();
+  if (session_) {
+    session_.reset();
+  }
   events_.clear();
 }
 
 SessionContext SessionTest::CreateBarebonesSessionContext() {
-  session_manager_ = std::make_unique<SessionManager>();
+  session_manager_ = std::make_unique<SessionManagerForTest>();
   update_scheduler_ =
       std::make_unique<FakeUpdateScheduler>(session_manager_.get());
   SessionContext session_context{
@@ -52,9 +56,9 @@
   return session_context;
 }
 
-fxl::RefPtr<SessionForTest> SessionTest::CreateSession() {
-  return fxl::MakeRefCounted<SessionForTest>(1, CreateBarebonesSessionContext(),
-                                             this, error_reporter());
+std::unique_ptr<SessionForTest> SessionTest::CreateSession() {
+  return std::make_unique<SessionForTest>(1, CreateBarebonesSessionContext(),
+                                          this, error_reporter());
 }
 
 void SessionTest::EnqueueEvent(fuchsia::ui::gfx::Event event) {
diff --git a/lib/ui/gfx/tests/session_test.h b/lib/ui/gfx/tests/session_test.h
index 7cdccb7..3916eaf 100644
--- a/lib/ui/gfx/tests/session_test.h
+++ b/lib/ui/gfx/tests/session_test.h
@@ -9,11 +9,11 @@
 
 #include <lib/fit/function.h>
 
-#include "garnet/lib/ui/gfx/displays/display_manager.h"
 #include "garnet/lib/ui/gfx/engine/engine.h"
 #include "garnet/lib/ui/gfx/engine/session.h"
 #include "garnet/lib/ui/gfx/tests/mocks.h"
 #include "garnet/lib/ui/scenic/event_reporter.h"
+#include "garnet/lib/ui/scenic/tests/scenic_test.h"
 #include "lib/gtest/test_loop_fixture.h"
 
 namespace scenic_impl {
@@ -42,7 +42,7 @@
   void EnqueueEvent(fuchsia::ui::scenic::Command unhandled) override;
 
   // Subclasses should override to provide their own Session.
-  virtual fxl::RefPtr<SessionForTest> CreateSession();
+  virtual std::unique_ptr<SessionForTest> CreateSession();
 
   // Creates a SessionContext with only a SessionManager and a
   // FakeUpdateScheduler.
@@ -60,9 +60,9 @@
     return session_->resources()->FindResource<ResourceT>(id);
   }
 
-  std::unique_ptr<SessionManager> session_manager_;
   std::unique_ptr<UpdateScheduler> update_scheduler_;
-  fxl::RefPtr<SessionForTest> session_;
+  std::unique_ptr<SessionForTest> session_;
+  std::unique_ptr<SessionManagerForTest> session_manager_;
   std::vector<fuchsia::ui::scenic::Event> events_;
 };
 
diff --git a/lib/ui/gfx/tests/session_unittest.cc b/lib/ui/gfx/tests/session_unittest.cc
index 5041b47..22b823b 100644
--- a/lib/ui/gfx/tests/session_unittest.cc
+++ b/lib/ui/gfx/tests/session_unittest.cc
@@ -19,14 +19,12 @@
 namespace test {
 
 TEST_F(SessionTest, ScheduleUpdateOutOfOrder) {
-  EXPECT_TRUE(
-      session_->ScheduleUpdate(1, std::vector<::fuchsia::ui::gfx::Command>(),
-                               ::std::vector<zx::event>(),
-                               ::std::vector<zx::event>(), [](auto) {}));
-  EXPECT_FALSE(
-      session_->ScheduleUpdate(0, std::vector<::fuchsia::ui::gfx::Command>(),
-                               ::std::vector<zx::event>(),
-                               ::std::vector<zx::event>(), [](auto) {}));
+  EXPECT_TRUE(session_->ScheduleUpdate(
+      /*presentation_time*/ 1, std::vector<::fuchsia::ui::gfx::Command>(),
+      std::vector<zx::event>(), std::vector<zx::event>(), [](auto) {}));
+  EXPECT_FALSE(session_->ScheduleUpdate(
+      /*presentation_time*/ 0, std::vector<::fuchsia::ui::gfx::Command>(),
+      std::vector<zx::event>(), std::vector<zx::event>(), [](auto) {}));
   ExpectLastReportedError(
       "scenic_impl::gfx::Session: Present called with out-of-order "
       "presentation "
@@ -35,14 +33,12 @@
 }
 
 TEST_F(SessionTest, ScheduleUpdateInOrder) {
-  EXPECT_TRUE(
-      session_->ScheduleUpdate(1, std::vector<::fuchsia::ui::gfx::Command>(),
-                               ::std::vector<zx::event>(),
-                               ::std::vector<zx::event>(), [](auto) {}));
-  EXPECT_TRUE(
-      session_->ScheduleUpdate(1, std::vector<::fuchsia::ui::gfx::Command>(),
-                               ::std::vector<zx::event>(),
-                               ::std::vector<zx::event>(), [](auto) {}));
+  EXPECT_TRUE(session_->ScheduleUpdate(
+      /*presentation_time*/ 1, std::vector<::fuchsia::ui::gfx::Command>(),
+      std::vector<zx::event>(), std::vector<zx::event>(), [](auto) {}));
+  EXPECT_TRUE(session_->ScheduleUpdate(
+      /*presentation_time*/ 1, std::vector<::fuchsia::ui::gfx::Command>(),
+      std::vector<zx::event>(), std::vector<zx::event>(), [](auto) {}));
   ExpectLastReportedError(nullptr);
 }
 
@@ -96,14 +92,14 @@
   EXPECT_TRUE(Apply(scenic::NewSetLabelCmd(kNodeId, kLongLabel)));
   EXPECT_EQ(kLongLabel, shape_node->label());
   EXPECT_TRUE(Apply(scenic::NewSetLabelCmd(kNodeId, kTooLongLabel)));
-  EXPECT_EQ(kTooLongLabel.substr(0, ::fuchsia::ui::gfx::kLabelMaxLength),
+  EXPECT_EQ(kTooLongLabel.substr(0, fuchsia::ui::gfx::kLabelMaxLength),
             shape_node->label());
   EXPECT_TRUE(Apply(scenic::NewSetLabelCmd(kNodeId, "")));
   EXPECT_TRUE(shape_node->label().empty());
 
   // Bypass the truncation performed by session helpers.
   shape_node->SetLabel(kTooLongLabel);
-  EXPECT_EQ(kTooLongLabel.substr(0, ::fuchsia::ui::gfx::kLabelMaxLength),
+  EXPECT_EQ(kTooLongLabel.substr(0, fuchsia::ui::gfx::kLabelMaxLength),
             shape_node->label());
 }
 
diff --git a/lib/ui/gfx/tests/size_change_hint_unittest.cc b/lib/ui/gfx/tests/size_change_hint_unittest.cc
index b5377a3..c5698d4 100644
--- a/lib/ui/gfx/tests/size_change_hint_unittest.cc
+++ b/lib/ui/gfx/tests/size_change_hint_unittest.cc
@@ -15,14 +15,14 @@
  public:
   SizeChangeHintTest() {}
 
-  fxl::RefPtr<SessionForTest> CreateSession() override {
+  std::unique_ptr<SessionForTest> CreateSession() override {
     SessionContext session_context = CreateBarebonesSessionContext();
 
     resource_linker_ = std::make_unique<ResourceLinker>();
     session_context.resource_linker = resource_linker_.get();
 
-    return fxl::MakeRefCounted<SessionForTest>(1, std::move(session_context),
-                                               this, error_reporter());
+    return std::make_unique<SessionForTest>(1, std::move(session_context), this,
+                                            error_reporter());
   }
 
   std::unique_ptr<ResourceLinker> resource_linker_;
diff --git a/lib/ui/gfx/tests/view_unittest.cc b/lib/ui/gfx/tests/view_unittest.cc
index 48b72c6..67f9420 100644
--- a/lib/ui/gfx/tests/view_unittest.cc
+++ b/lib/ui/gfx/tests/view_unittest.cc
@@ -23,14 +23,14 @@
  public:
   ViewTest() {}
 
-  fxl::RefPtr<SessionForTest> CreateSession() override {
+  std::unique_ptr<SessionForTest> CreateSession() override {
     SessionContext session_context = CreateBarebonesSessionContext();
 
     view_linker_ = std::make_unique<ViewLinker>();
     session_context.view_linker = view_linker_.get();
 
-    return fxl::MakeRefCounted<SessionForTest>(1, std::move(session_context),
-                                               this, error_reporter());
+    return std::make_unique<SessionForTest>(1, std::move(session_context), this,
+                                            error_reporter());
   }
 
   std::unique_ptr<ViewLinker> view_linker_;
diff --git a/lib/ui/gfx/tests/vk_session_test.cc b/lib/ui/gfx/tests/vk_session_test.cc
index 66aeec9..c5db90d 100644
--- a/lib/ui/gfx/tests/vk_session_test.cc
+++ b/lib/ui/gfx/tests/vk_session_test.cc
@@ -9,7 +9,7 @@
 namespace gfx {
 namespace test {
 
-fxl::RefPtr<SessionForTest> VkSessionTest::CreateSession() {
+std::unique_ptr<SessionForTest> VkSessionTest::CreateSession() {
   SessionContext session_context = CreateBarebonesSessionContext();
 
   // Initialize Vulkan.
@@ -37,8 +37,8 @@
   session_context.escher_image_factory = image_factory_.get();
   session_context.release_fence_signaller = release_fence_signaller_.get();
 
-  return fxl::MakeRefCounted<SessionForTest>(1, std::move(session_context),
-                                             this, error_reporter());
+  return std::make_unique<SessionForTest>(1, std::move(session_context), this,
+                                          error_reporter());
 }
 
 }  // namespace test
diff --git a/lib/ui/gfx/tests/vk_session_test.h b/lib/ui/gfx/tests/vk_session_test.h
index d1b1649..7eb8b7d 100644
--- a/lib/ui/gfx/tests/vk_session_test.h
+++ b/lib/ui/gfx/tests/vk_session_test.h
@@ -14,7 +14,7 @@
 class VkSessionTest : public SessionTest {
  public:
   // |SessionTest|
-  fxl::RefPtr<SessionForTest> CreateSession() override;
+  std::unique_ptr<SessionForTest> CreateSession() override;
 
  private:
   std::unique_ptr<escher::Escher> escher_;
diff --git a/lib/ui/scenic/command_dispatcher.cc b/lib/ui/scenic/command_dispatcher.cc
index d92a6f8..d3ec99c 100644
--- a/lib/ui/scenic/command_dispatcher.cc
+++ b/lib/ui/scenic/command_dispatcher.cc
@@ -4,21 +4,28 @@
 
 #include "garnet/lib/ui/scenic/command_dispatcher.h"
 
+#include "garnet/lib/ui/scenic/scenic.h"
 #include "garnet/lib/ui/scenic/session.h"
 
 namespace scenic_impl {
 
 CommandDispatcherContext::CommandDispatcherContext(Scenic* scenic,
                                                    Session* session)
-    : scenic_(scenic), session_(session), session_id_(session->id()) {
-  FXL_DCHECK(scenic_);
-  FXL_DCHECK(session_);
-  FXL_DCHECK(session_id_);
+    : CommandDispatcherContext(scenic, session, session->id()) {}
+
+CommandDispatcherContext::CommandDispatcherContext(Scenic* scenic,
+                                                   Session* session,
+                                                   SessionId id)
+    : scenic_(scenic), session_(session), session_id_(id) {
+  if (session) {
+    FXL_DCHECK(session->id() == id);
+  }
 }
 
 CommandDispatcherContext::CommandDispatcherContext(
     CommandDispatcherContext&& context)
-    : CommandDispatcherContext(context.scenic_, context.session_) {
+    : CommandDispatcherContext(context.scenic_, context.session_,
+                               context.session_id_) {
   auto& other_scenic = const_cast<Scenic*&>(context.scenic_);
   auto& other_session = const_cast<Session*&>(context.session_);
   auto& other_session_id = const_cast<SessionId&>(context.session_id_);
@@ -27,6 +34,10 @@
   other_session_id = 0;
 }
 
+void CommandDispatcherContext::KillSession() {
+  scenic_->CloseSession(session());
+}
+
 CommandDispatcher::CommandDispatcher(CommandDispatcherContext context)
     : context_(std::move(context)) {}
 
diff --git a/lib/ui/scenic/command_dispatcher.h b/lib/ui/scenic/command_dispatcher.h
index 62a1de6..daffeb9 100644
--- a/lib/ui/scenic/command_dispatcher.h
+++ b/lib/ui/scenic/command_dispatcher.h
@@ -15,15 +15,26 @@
 
 // Provides the capabilities that a CommandDispatcher needs to do its job,
 // without directly exposing the Session.
-class CommandDispatcherContext final {
+class CommandDispatcherContext {
  public:
   explicit CommandDispatcherContext(Scenic* scenic, Session* session);
+
+  explicit CommandDispatcherContext(Scenic* scenic, Session* session,
+                                    SessionId id);
+
   CommandDispatcherContext(CommandDispatcherContext&& context);
 
   // TODO(SCN-808): can/should we avoid exposing any/all of these?
-  Scenic* scenic() { return scenic_; }
-  Session* session() { return session_; }
-  SessionId session_id() { return session_id_; }
+  Session* session() {
+    FXL_DCHECK(session_);
+    return session_;
+  }
+  SessionId session_id() {
+    FXL_DCHECK(session_id_);
+    return session_id_;
+  }
+
+  void KillSession();
 
  private:
   Scenic* const scenic_;
diff --git a/lib/ui/scenic/scenic.cc b/lib/ui/scenic/scenic.cc
index 5036333..d5dd0f6 100644
--- a/lib/ui/scenic/scenic.cc
+++ b/lib/ui/scenic/scenic.cc
@@ -38,11 +38,15 @@
 }
 
 void Scenic::CloseSession(Session* session) {
+  // TODO(SCN-1065): Make it so that close session removes the binding from
+  // session_bindings_, then remove num_sessions_ and return
+  // session_bindings_.size() in num_sessions() instead
   for (auto& binding : session_bindings_.bindings()) {
     // It's possible that this is called by BindingSet::CloseAndCheckForEmpty.
     // In that case, binding could be empty, so check for that.
     if (binding && binding->impl().get() == session) {
       binding->Unbind();
+      --num_sessions_;
       return;
     }
   }
@@ -67,7 +71,7 @@
     ::fidl::InterfaceRequest<fuchsia::ui::scenic::Session> session_request,
     ::fidl::InterfaceHandle<fuchsia::ui::scenic::SessionListener> listener) {
   auto session =
-      std::make_unique<Session>(this, next_session_id_++, std::move(listener));
+      std::make_unique<Session>(next_session_id_++, std::move(listener));
 
   // Give each installed System an opportunity to install a CommandDispatcher in
   // the newly-created Session.
@@ -82,6 +86,7 @@
   session->SetCommandDispatchers(std::move(dispatchers));
 
   session_bindings_.AddBinding(std::move(session), std::move(session_request));
+  ++num_sessions_;
 }
 
 void Scenic::GetDisplayInfo(
diff --git a/lib/ui/scenic/scenic.h b/lib/ui/scenic/scenic.h
index 85521c5..4b28276 100644
--- a/lib/ui/scenic/scenic.h
+++ b/lib/ui/scenic/scenic.h
@@ -43,7 +43,7 @@
 
   component::StartupContext* app_context() const { return app_context_; }
 
-  size_t num_sessions() { return session_bindings_.size(); }
+  size_t num_sessions() { return num_sessions_; }
 
  private:
   void CreateSessionImmediately(
@@ -83,6 +83,7 @@
   fidl::BindingSet<fuchsia::ui::scenic::Scenic> scenic_bindings_;
 
   size_t next_session_id_ = 1;
+  size_t num_sessions_ = 0;
 
   FXL_DISALLOW_COPY_AND_ASSIGN(Scenic);
 };
diff --git a/lib/ui/scenic/session.cc b/lib/ui/scenic/session.cc
index fb2caf9..c39e344 100644
--- a/lib/ui/scenic/session.cc
+++ b/lib/ui/scenic/session.cc
@@ -10,11 +10,9 @@
 namespace scenic_impl {
 
 Session::Session(
-    Scenic* owner, SessionId id,
+    SessionId id,
     ::fidl::InterfaceHandle<fuchsia::ui::scenic::SessionListener> listener)
-    : scenic_(owner), id_(id), listener_(listener.Bind()), weak_factory_(this) {
-  FXL_DCHECK(scenic_);
-}
+    : id_(id), listener_(listener.Bind()), weak_factory_(this) {}
 
 Session::~Session() = default;
 
diff --git a/lib/ui/scenic/session.h b/lib/ui/scenic/session.h
index c8599f9..c3ff924 100644
--- a/lib/ui/scenic/session.h
+++ b/lib/ui/scenic/session.h
@@ -32,7 +32,7 @@
                       public ErrorReporter {
  public:
   Session(
-      Scenic* owner, SessionId id,
+      SessionId id,
       ::fidl::InterfaceHandle<fuchsia::ui::scenic::SessionListener> listener);
   ~Session() override;
 
@@ -102,7 +102,6 @@
   // invoke the callback for each event.
   void FlushEvents();
 
-  Scenic* const scenic_;
   const SessionId id_;
   ::fidl::InterfacePtr<fuchsia::ui::scenic::SessionListener> listener_;
 
diff --git a/lib/ui/scenic/tests/BUILD.gn b/lib/ui/scenic/tests/BUILD.gn
index 5faf04c..dd69baa 100644
--- a/lib/ui/scenic/tests/BUILD.gn
+++ b/lib/ui/scenic/tests/BUILD.gn
@@ -13,30 +13,23 @@
 source_set("testing_deps") {
   testonly = true
   sources = [
+    "scenic_gfx_test.cc",
+    "scenic_gfx_test.h",
     "scenic_test.cc",
     "scenic_test.h",
   ]
   public_deps = [
+    ":mocks",
+    "//garnet/lib/ui/gfx",
     "//garnet/lib/ui/scenic",
     "//garnet/public/lib/component/cpp",
     "//garnet/public/lib/fxl",
     "//garnet/public/lib/gtest",
+    "//garnet/public/lib/ui/scenic/cpp",
     "//third_party/googletest:gtest_main",
   ]
 }
 
-executable("unittests") {
-  output_name = "scenic_unittests"
-  testonly = true
-  sources = [
-    "scenic_unittest.cc",
-  ]
-  deps = [
-    ":dummy_system",
-    ":testing_deps",
-  ]
-}
-
 source_set("dummy_system") {
   sources = [
     "dummy_system.cc",
@@ -47,3 +40,27 @@
     "//garnet/public/fidl/fuchsia.ui.scenic",
   ]
 }
+
+source_set("mocks") {
+  sources = [
+    "mocks.cc",
+    "mocks.h",
+  ]
+  deps = [
+    ":dummy_system",
+    "//garnet/lib/ui/gfx",
+  ]
+}
+
+executable("unittests") {
+  output_name = "scenic_unittests"
+  testonly = true
+  sources = [
+    "scenic_unittest.cc",
+  ]
+  deps = [
+    ":dummy_system",
+    ":mocks",
+    ":testing_deps",
+  ]
+}
diff --git a/lib/ui/scenic/tests/mocks.cc b/lib/ui/scenic/tests/mocks.cc
new file mode 100644
index 0000000..047cac6
--- /dev/null
+++ b/lib/ui/scenic/tests/mocks.cc
@@ -0,0 +1,28 @@
+// Copyright 2019 The Fuchsia 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 "garnet/lib/ui/scenic/tests/mocks.h"
+
+namespace scenic_impl {
+namespace test {
+
+ReleaseFenceSignallerForTest::ReleaseFenceSignallerForTest(
+    escher::impl::CommandBufferSequencer* command_buffer_sequencer)
+    : ReleaseFenceSignaller(command_buffer_sequencer) {}
+
+void ReleaseFenceSignallerForTest::AddCPUReleaseFence(zx::event fence) {
+  ++num_calls_to_add_cpu_release_fence_;
+  // Signal immediately for testing purposes.
+  fence.signal(0u, escher::kFenceSignalled);
+}
+
+EngineForTest::EngineForTest(
+    gfx::DisplayManager* display_manager,
+    std::unique_ptr<escher::ReleaseFenceSignaller> release_signaler,
+    escher::EscherWeakPtr escher)
+    : gfx::Engine(display_manager, std::move(release_signaler),
+                  std::make_unique<gfx::SessionManager>(), std::move(escher)) {}
+
+}  // namespace test
+}  // namespace scenic_impl
diff --git a/lib/ui/scenic/tests/mocks.h b/lib/ui/scenic/tests/mocks.h
new file mode 100644
index 0000000..3dd58ea
--- /dev/null
+++ b/lib/ui/scenic/tests/mocks.h
@@ -0,0 +1,86 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GARNET_LIB_UI_SCENIC_TESTS_MOCKS_H_
+#define GARNET_LIB_UI_SCENIC_TESTS_MOCKS_H_
+
+#include "garnet/lib/ui/gfx/gfx_system.h"
+#include "garnet/lib/ui/scenic/tests/dummy_system.h"
+#include "lib/escher/flib/release_fence_signaller.h"
+
+namespace scenic_impl {
+namespace test {
+
+class ReleaseFenceSignallerForTest : public escher::ReleaseFenceSignaller {
+ public:
+  ReleaseFenceSignallerForTest(
+      escher::impl::CommandBufferSequencer* command_buffer_sequencer);
+
+  void AddCPUReleaseFence(zx::event fence) override;
+
+  uint32_t num_calls_to_add_cpu_release_fence() {
+    return num_calls_to_add_cpu_release_fence_;
+  }
+
+ private:
+  uint32_t num_calls_to_add_cpu_release_fence_ = 0;
+};
+
+class EngineForTest : public gfx::Engine {
+ public:
+  EngineForTest(gfx::DisplayManager* display_manager,
+                std::unique_ptr<escher::ReleaseFenceSignaller> release_signaler,
+                escher::EscherWeakPtr escher = escher::EscherWeakPtr());
+};
+
+class GfxSystemForTest : public gfx::GfxSystem {
+ public:
+  static constexpr TypeId kTypeId = kGfx;
+
+  explicit GfxSystemForTest(
+      SystemContext context,
+      std::unique_ptr<gfx::DisplayManager> display_manager,
+      escher::impl::CommandBufferSequencer* command_buffer_sequencer)
+      : GfxSystem(std::move(context), std::move(display_manager)),
+        command_buffer_sequencer_(command_buffer_sequencer) {}
+
+  gfx::Engine* engine() { return engine_.get(); }
+
+ private:
+  std::unique_ptr<gfx::Engine> InitializeEngine() override {
+    return std::make_unique<EngineForTest>(
+        display_manager_.get(), std::make_unique<ReleaseFenceSignallerForTest>(
+                                    command_buffer_sequencer_));
+  }
+
+  std::unique_ptr<escher::Escher> InitializeEscher() override {
+    return nullptr;
+  }
+
+  escher::impl::CommandBufferSequencer* command_buffer_sequencer_;
+};
+
+// Device-independent "display"; for testing only. Needed to ensure GfxSystem
+// doesn't wait for a device-driven "display ready" signal.
+class TestDisplay : public scenic_impl::gfx::Display {
+ public:
+  TestDisplay(uint64_t id, uint32_t width_px, uint32_t height_px)
+      : Display(id, width_px, height_px) {}
+  ~TestDisplay() = default;
+  bool is_test_display() const override { return true; }
+};
+
+class MockSystemWithDelayedInitialization : public DummySystem {
+ public:
+  // Expose to tests.
+  using System::SetToInitialized;
+
+  explicit MockSystemWithDelayedInitialization(SystemContext context)
+      : DummySystem(std::move(context), false) {}
+};
+
+}  // namespace test
+}  // namespace scenic_impl
+
+#endif  // GARNET_LIB_UI_SCENIC_TESTS_MOCKS_H_
diff --git a/lib/ui/scenic/tests/scenic_gfx_test.cc b/lib/ui/scenic/tests/scenic_gfx_test.cc
new file mode 100644
index 0000000..31e141a
--- /dev/null
+++ b/lib/ui/scenic/tests/scenic_gfx_test.cc
@@ -0,0 +1,34 @@
+// Copyright 2019 The Fuchsia 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 "garnet/lib/ui/scenic/tests/scenic_gfx_test.h"
+
+#include "garnet/lib/ui/gfx/displays/display.h"
+#include "garnet/lib/ui/gfx/displays/display_manager.h"
+#include "garnet/lib/ui/scenic/tests/mocks.h"
+#include <lib/async-testutils/test_loop.h>
+
+namespace scenic_impl {
+namespace test {
+
+void ScenicGfxTest::InitializeScenic(Scenic* scenic) {
+  auto display_manager = std::make_unique<gfx::DisplayManager>();
+  display_manager->SetDefaultDisplayForTests(
+      std::make_unique<test::TestDisplay>(
+          /*id*/ 0, /* width */ 0, /* height */ 0));
+  command_buffer_sequencer_ =
+      std::make_unique<escher::impl::CommandBufferSequencer>();
+  scenic_->RegisterSystem<GfxSystemForTest>(std::move(display_manager),
+                                            command_buffer_sequencer_.get());
+
+  RunLoopUntilIdle();  // Finish initialization
+}
+
+void ScenicGfxTest::TearDown() {
+  ScenicTest::TearDown();
+  command_buffer_sequencer_.reset();
+}
+
+}  // namespace test
+}  // namespace scenic_impl
diff --git a/lib/ui/scenic/tests/scenic_gfx_test.h b/lib/ui/scenic/tests/scenic_gfx_test.h
new file mode 100644
index 0000000..f94c6f9
--- /dev/null
+++ b/lib/ui/scenic/tests/scenic_gfx_test.h
@@ -0,0 +1,27 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GARNET_LIB_UI_SCENIC_TESTS_SCENIC_GFX_TEST_H_
+#define GARNET_LIB_UI_SCENIC_TESTS_SCENIC_GFX_TEST_H_
+
+#include "garnet/lib/ui/scenic/tests/scenic_test.h"
+#include "garnet/public/lib/escher/impl/command_buffer_sequencer.h"
+
+namespace scenic_impl {
+namespace test {
+
+// Subclass of ScenicTest for tests requiring Scenic with a gfx system installed
+class ScenicGfxTest : public ScenicTest {
+ protected:
+  void TearDown() override;
+  void InitializeScenic(Scenic* scenic) override;
+
+  std::unique_ptr<escher::impl::CommandBufferSequencer>
+      command_buffer_sequencer_;
+};
+
+}  // namespace test
+}  // namespace scenic_impl
+
+#endif  // GARNET_LIB_UI_SCENIC_TESTS_SCENIC_GFX_TEST_H_
diff --git a/lib/ui/scenic/tests/scenic_test.cc b/lib/ui/scenic/tests/scenic_test.cc
index 585edfd..2ce38e5 100644
--- a/lib/ui/scenic/tests/scenic_test.cc
+++ b/lib/ui/scenic/tests/scenic_test.cc
@@ -2,7 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "garnet/lib/ui/scenic/tests/scenic_test.h"
+#include "garnet/lib/ui/scenic/tests/scenic_gfx_test.h"
+
+#include "garnet/lib/ui/gfx/displays/display.h"
+#include "garnet/lib/ui/gfx/displays/display_manager.h"
+#include "garnet/lib/ui/scenic/tests/mocks.h"
 
 namespace scenic_impl {
 namespace test {
@@ -12,7 +16,7 @@
 void ScenicTest::SetUp() {
   // TODO(SCN-720): Wrap CreateFromStartupInfo using ::gtest::Environment
   // instead of this hack.  This code has the chance to break non-ScenicTests.
-  if (app_context_ == nullptr) {
+  if (app_context_.get() == nullptr) {
     app_context_ = component::StartupContext::CreateFromStartupInfo();
   }
   scenic_ =
@@ -24,10 +28,21 @@
   reported_errors_.clear();
   events_.clear();
   scenic_.reset();
+  app_context_.reset();
 }
 
 void ScenicTest::InitializeScenic(Scenic* scenic) {}
 
+std::unique_ptr<::scenic::Session> ScenicTest::CreateSession() {
+  fuchsia::ui::scenic::SessionPtr session_ptr;
+  fidl::InterfaceHandle<fuchsia::ui::scenic::SessionListener> listener_handle;
+  fidl::InterfaceRequest<fuchsia::ui::scenic::SessionListener>
+      listener_request = listener_handle.NewRequest();
+  scenic()->CreateSession(session_ptr.NewRequest(), std::move(listener_handle));
+  return std::make_unique<::scenic::Session>(std::move(session_ptr),
+                                             std::move(listener_request));
+}
+
 void ScenicTest::ReportError(fxl::LogSeverity severity,
                              std::string error_string) {
 // Typically, we don't want to log expected errors when running the tests.
diff --git a/lib/ui/scenic/tests/scenic_test.h b/lib/ui/scenic/tests/scenic_test.h
index 82eb15f..b2d692a 100644
--- a/lib/ui/scenic/tests/scenic_test.h
+++ b/lib/ui/scenic/tests/scenic_test.h
@@ -9,6 +9,7 @@
 
 #include "garnet/lib/ui/scenic/scenic.h"
 #include "garnet/lib/ui/scenic/util/error_reporter.h"
+#include "garnet/public/lib/ui/scenic/cpp/session.h"
 #include "gtest/gtest.h"
 #include "lib/component/cpp/startup_context.h"
 #include "lib/fxl/tasks/task_runner.h"
@@ -22,6 +23,9 @@
 class ScenicTest : public ::gtest::TestLoopFixture,
                    public ErrorReporter,
                    public EventReporter {
+ public:
+  std::unique_ptr<::scenic::Session> CreateSession();
+
  protected:
   // ::testing::Test virtual method.
   void SetUp() override;
diff --git a/lib/ui/scenic/tests/scenic_unittest.cc b/lib/ui/scenic/tests/scenic_unittest.cc
index 329d06c..ff9743b 100644
--- a/lib/ui/scenic/tests/scenic_unittest.cc
+++ b/lib/ui/scenic/tests/scenic_unittest.cc
@@ -3,39 +3,47 @@
 // found in the LICENSE file.
 
 #include "garnet/lib/ui/scenic/tests/dummy_system.h"
+#include "garnet/lib/ui/scenic/tests/mocks.h"
+#include "garnet/lib/ui/scenic/tests/scenic_gfx_test.h"
 #include "garnet/lib/ui/scenic/tests/scenic_test.h"
 
+#include "gtest/gtest.h"
+
 namespace scenic_impl {
 namespace test {
 
-namespace {
-
-class MockSystemWithDelayedInitialization : public DummySystem {
- public:
-  // Expose to tests.
-  using System::SetToInitialized;
-
-  explicit MockSystemWithDelayedInitialization(SystemContext context)
-      : DummySystem(std::move(context), false) {}
-};
-
-}  // anonymous namespace
-
 TEST_F(ScenicTest, SessionCreatedAfterAllSystemsInitialized) {
   auto mock_system =
-      scenic()->RegisterSystem<test::MockSystemWithDelayedInitialization>();
+      scenic()->RegisterSystem<MockSystemWithDelayedInitialization>();
 
-  EXPECT_EQ(0U, scenic()->num_sessions());
+  EXPECT_EQ(scenic()->num_sessions(), 0U);
 
   // Request session creation, which doesn't occur yet because system isn't
   // initialized.
-  fuchsia::ui::scenic::SessionPtr session;
-  scenic()->CreateSession(session.NewRequest(), nullptr);
-  EXPECT_EQ(0U, scenic()->num_sessions());
+  auto session = CreateSession();
+  EXPECT_EQ(scenic()->num_sessions(), 0U);
 
   // Initializing the system allows the session to be created.
   mock_system->SetToInitialized();
-  EXPECT_EQ(1U, scenic()->num_sessions());
+  EXPECT_EQ(scenic()->num_sessions(), 1U);
+}
+
+TEST_F(ScenicGfxTest, InvalidPresentCall_ShouldDestroySession) {
+  EXPECT_EQ(scenic()->num_sessions(), 0U);
+  auto session = CreateSession();
+  EXPECT_EQ(scenic()->num_sessions(), 1U);
+
+  session->Present(/*Presentation Time*/ 10,
+                   /*Present Callback*/ [](auto){});
+
+  // Trigger error by making a present call with an earlier presentation time
+  // than the previous call to present
+  session->Present(/*Presentation Time*/ 0,
+                   /*Present Callback*/ [](auto){});
+
+  RunLoopUntilIdle();
+
+  EXPECT_EQ(scenic()->num_sessions(), 0U);
 }
 
 }  // namespace test