Mozart: Directly associate the renderer with the view tree.

services/ui/view_manager/view_registry.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "services/ui/view_manager/view_registry.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 260 matching lines @@
 void ViewRegistry::ConnectToViewService(
     ViewState* view_state,
     const mojo::String& service_name,
     mojo::ScopedMessagePipeHandle client_handle) {
   DCHECK(IsViewStateRegisteredDebug(view_state));
 
   associate_table_.ConnectToViewService(view_state->view_token()->Clone(),
                                         service_name, client_handle.Pass());
 }
 
+void ViewRegistry::SetRenderer(ViewTreeState* tree_state,
+                               mojo::gfx::composition::RendererPtr renderer) {
+  DCHECK(IsViewTreeStateRegisteredDebug(tree_state));
+  DVLOG(1) << "SetRenderer";
+
+  if (renderer) {
+    renderer.set_connection_error_handler(
+        base::Bind(&ViewRegistry::OnRendererDied, base::Unretained(this),
+                   base::Unretained(tree_state)));
+  }
+
+  tree_state->set_renderer(renderer.Pass());
+  UpdateViewTreeRootScene(tree_state);
+}
+
 void ViewRegistry::RequestLayout(ViewTreeState* tree_state) {
   DCHECK(IsViewTreeStateRegisteredDebug(tree_state));
   DVLOG(1) << "RequestLayout: tree=" << tree_state;
 
   InvalidateLayoutForRoot(tree_state);
 }
 
 void ViewRegistry::SetRoot(
     ViewTreeState* tree_state,
     uint32_t root_key,
     mojo::InterfaceHandle<mojo::ui::ViewOwner> root_view_owner) {
   DCHECK(IsViewTreeStateRegisteredDebug(tree_state));
   DCHECK(root_view_owner);
   DVLOG(1) << "SetRoot: tree=" << tree_state << ", root_key=" << root_key;
 
   // Ensure there isn't already a root.
   if (tree_state->root()) {
     LOG(ERROR)
         << "View tree attempted to set the root while one is already set: tree="
         << tree_state << ", root_key=" << root_key;
     UnregisterViewTree(tree_state);
     return;
   }
 
   // Set the root to a stub, pending resolution of the view owner.
   tree_state->LinkRoot(root_key, std::unique_ptr<ViewStub>(new ViewStub(
                                      this, root_view_owner.Pass())));
+  UpdateViewTreeRootScene(tree_state);
 
   // Schedule layout of the tree on behalf of its newly added root.
   // We don't need to schedule layout of the root until the tree provides
   // new layout parameters.
   InvalidateLayoutForRoot(tree_state);
 }
 
 void ViewRegistry::ResetRoot(ViewTreeState* tree_state,
                              mojo::InterfaceRequest<mojo::ui::ViewOwner>
                                  transferred_view_owner_request) {
   DCHECK(IsViewTreeStateRegisteredDebug(tree_state));
   DVLOG(1) << "ResetRoot: tree=" << tree_state;
 
   // Ensure there is a root.
   if (!tree_state->root()) {
     LOG(ERROR)
         << "View tree attempted to reset the root but there is none: tree="
         << tree_state;
     UnregisterViewTree(tree_state);
     return;
   }
 
   // Unlink the root from its tree.
   TransferOrUnregisterViewStub(tree_state->UnlinkRoot(),
                                transferred_view_owner_request.Pass());
+  UpdateViewTreeRootScene(tree_state);
 
   // Note: We don't need to schedule layout for the root since it will retain
   // its old layout parameters.  And there's no need to tell the tree
   // either since it won't have any work to do.  So we're done.
 }
 
 void ViewRegistry::LayoutRoot(ViewTreeState* tree_state,
                               mojo::ui::ViewLayoutParamsPtr root_layout_params,
                               const ViewLayoutCallback& callback) {
   DCHECK(IsViewTreeStateRegisteredDebug(tree_state));
@@ skipping 318 matching lines @@
 
   if (recurse && view_state->view_stub()) {
     if (view_state->view_stub()->parent()) {
       InvalidateLayoutForChild(view_state->view_stub()->parent(),
                                view_state->view_stub()->key());
     } else if (view_state->view_stub()->tree()) {
       InvalidateLayoutForRoot(view_state->view_stub()->tree());
     }
   }
 
+  if (view_state->view_stub()->is_root_of_tree() && size_changed)
+    UpdateViewTreeRootScene(view_state->view_stub()->tree());
+
   IssueNextViewLayoutRequest(view_state);
 }
 
 void ViewRegistry::OnViewTreeLayoutResult(
     base::WeakPtr<ViewTreeState> tree_state_weak) {
   ViewTreeState* tree_state = tree_state_weak.get();
   if (tree_state) {
     DCHECK(tree_state->layout_request_issued());
 
     DVLOG(1) << "OnViewTreeLayoutResult";
 
     tree_state->set_layout_request_issued(false);
     IssueNextViewTreeLayoutRequest(tree_state);
   }
 }
 
+void ViewRegistry::UpdateViewTreeRootScene(ViewTreeState* tree_state) {
+  DCHECK(IsViewTreeStateRegisteredDebug(tree_state));
+  DVLOG(1) << "UpdateViewTreeRootScene: tree_state=" << tree_state;
+
+  if (!tree_state->renderer())
+    return;
+
+  if (tree_state->root()) {
+    ViewState* root_state = tree_state->root()->state();
+    if (root_state && root_state->scene_token() &&
+        root_state->layout_result()) {
+      // TODO(jeffbrown): Take the scene version from the layout parameters
+      // once we've figured out that part of the layout protocol.
+      mojo::Rect viewport;
+      viewport.width = root_state->layout_result()->size->width;
+      viewport.height = root_state->layout_result()->size->height;
+      tree_state->renderer()->SetRootScene(
+          tree_state->root()->state()->scene_token()->Clone(),
+          mojo::gfx::composition::kSceneVersionNone, viewport.Clone());
+      return;
+    }
+  }
+
+  tree_state->renderer()->ResetRootScene();
+}
+
+void ViewRegistry::OnRendererDied(ViewTreeState* tree_state) {
+  DCHECK(IsViewTreeStateRegisteredDebug(tree_state));
+  DVLOG(1) << "UpdateViewTreeRootScene: tree_state=" << tree_state;
+
+  tree_state->set_renderer(nullptr);
+  SendRendererDied(tree_state);
+}
+
 void ViewRegistry::SendChildUnavailable(ViewState* parent_state,
                                         uint32_t child_key) {
   DCHECK(IsViewStateRegisteredDebug(parent_state));
 
   // TODO: Detect ANRs
   DVLOG(1) << "SendChildUnavailable: parent_state=" << parent_state
            << ", child_key=" << child_key;
   parent_state->view_listener()->OnChildUnavailable(
       child_key, base::Bind(&base::DoNothing));
 }
 
 void ViewRegistry::SendRootUnavailable(ViewTreeState* tree_state,
                                        uint32_t root_key) {
   DCHECK(IsViewTreeStateRegisteredDebug(tree_state));
 
   // TODO: Detect ANRs
   DVLOG(1) << "SendRootUnavailable: tree_state=" << tree_state
            << ", root_key=" << root_key;
   tree_state->view_tree_listener()->OnRootUnavailable(
       root_key, base::Bind(&base::DoNothing));
 }
 
+void ViewRegistry::SendRendererDied(ViewTreeState* tree_state) {
+  DCHECK(IsViewTreeStateRegisteredDebug(tree_state));
+
+  // TODO: Detect ANRs
+  DVLOG(1) << "SendRendererDied: tree_state=" << tree_state;
+  tree_state->view_tree_listener()->OnRendererDied(
+      base::Bind(&base::DoNothing));
+}
+
 }  // namespace view_manager