Reify view ownership as a message pipe.

services/ui/view_manager/view_state.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_state.h"
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
-#include "services/ui/view_manager/view_tree_state.h"
+#include "services/ui/view_manager/view_host_impl.h"
+#include "services/ui/view_manager/view_registry.h"
+#include "services/ui/view_manager/view_stub.h"
 
 namespace view_manager {
 
-ViewState::ViewState(mojo::ui::ViewPtr view,
-                     mojo::ui::ViewTokenPtr view_token,
-                     const std::string& label)
+ViewState::ViewState(
+    ViewRegistry* registry,
+    mojo::ui::ViewPtr view,
+    mojo::ui::ViewTokenPtr view_token,
+    mojo::InterfaceRequest<mojo::ui::ViewHost> view_host_request,
+    const std::string& label)
     : view_(view.Pass()),
       view_token_(view_token.Pass()),
       label_(label),
+      impl_(new ViewHostImpl(registry, this)),
+      host_binding_(impl_.get(), view_host_request.Pass()),
+      owner_binding_(impl_.get()),
       weak_factory_(this) {
   DCHECK(view_);
   DCHECK(view_token_);
+
+  view_.set_connection_error_handler(
+      base::Bind(&ViewRegistry::OnViewDied, base::Unretained(registry),
+                 base::Unretained(this), "View connection closed"));
+  host_binding_.set_connection_error_handler(
+      base::Bind(&ViewRegistry::OnViewDied, base::Unretained(registry),
+                 base::Unretained(this), "ViewHost connection closed"));
+  owner_binding_.set_connection_error_handler(
+      base::Bind(&ViewRegistry::OnViewDied, base::Unretained(registry),
+                 base::Unretained(this), "ViewOwner connection closed"));
 }
 
 ViewState::~ViewState() {}
 
-void ViewState::SetTree(ViewTreeState* tree, uint32_t key) {
-  DCHECK(tree);
-  DCHECK(!parent_);  // must be the root
-  if (tree_ != tree) {
-    SetTreeUnchecked(tree);
-  }
-  key_ = key;
+void ViewState::LinkChild(uint32_t key, std::unique_ptr<ViewStub> child) {
+  DCHECK(children_.find(key) == children_.end());
+  DCHECK(child);
+  DCHECK(!child->is_linked());
+
+  child->SetParent(this, key);
+  children_.emplace(key, std::move(child));
 }
 
-void ViewState::SetTreeUnchecked(ViewTreeState* tree) {
-  tree_ = tree;
-  for (const auto& pair : children_) {
-    pair.second->SetTreeUnchecked(tree);
-  }
+std::unique_ptr<ViewStub> ViewState::UnlinkChild(uint32_t key) {
+  auto child_it = children_.find(key);
+  DCHECK(child_it != children_.end());
+  std::unique_ptr<ViewStub> child(std::move(child_it->second));
+  child->Unlink();
+  children_.erase(child_it);
+  children_needing_layout_.erase(child->key());
+  return child;
 }
 
-void ViewState::SetParent(ViewState* parent, uint32_t key) {
-  DCHECK(parent);
-  parent_ = parent;
-  key_ = key;
-  SetTreeUnchecked(parent->tree_);
+std::vector<std::unique_ptr<ViewStub>> ViewState::UnlinkAllChildren() {
+  std::vector<std::unique_ptr<ViewStub>> stubs;
+  for (auto& pair : children_) {
+    pair.second->Unlink();
+    stubs.push_back(std::move(pair.second));
+  }
+  children_.clear();
+  children_needing_layout_.clear();
+  return stubs;
 }
 
-void ViewState::ResetContainer() {
-  parent_ = nullptr;
-  key_ = 0;
-  SetTreeUnchecked(nullptr);
+void ViewState::BindOwner(
+    mojo::InterfaceRequest<mojo::ui::ViewOwner> view_owner_request) {
+  DCHECK(!owner_binding_.is_bound());
+  owner_binding_.Bind(view_owner_request.Pass());
+}
+
+void ViewState::ReleaseOwner() {
+  DCHECK(owner_binding_.is_bound());
+  owner_binding_.Close();
 }
 
 mojo::ui::ViewLayoutInfoPtr ViewState::CreateLayoutInfo() {
   if (!layout_result_ || !scene_token_)
     return nullptr;
 
   auto info = mojo::ui::ViewLayoutInfo::New();
   info->size = layout_result_->size.Clone();
   info->scene_token = scene_token_.Clone();
   return info;
 }
 
-const std::string& ViewState::FormattedLabel() {
+const std::string& ViewState::FormattedLabel() const {
   if (formatted_label_cache_.empty()) {
     formatted_label_cache_ =
         label_.empty()
             ? base::StringPrintf("<%d>", view_token_->value)
             : base::StringPrintf("<%d:%s>", view_token_->value, label_.c_str());
   }
   return formatted_label_cache_;
 }
 
 std::ostream& operator<<(std::ostream& os, ViewState* view_state) {
   if (!view_state)
     return os << "null";
   return os << view_state->FormattedLabel();
 }
 
 }  // namespace view_manager