Embedding demo in View manager

mojo/services/public/cpp/view_manager/lib/view_manager_synchronizer.cc

 // Copyright 2014 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 "mojo/services/public/cpp/view_manager/lib/view_manager_synchronizer.h"
 
 #include "base/bind.h"
-#include "base/run_loop.h"
+#include "base/message_loop/message_loop.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/interfaces/service_provider/service_provider.mojom.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_manager_private.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_private.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_tree_node_private.h"
 #include "mojo/services/public/cpp/view_manager/util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace mojo {
@@ skipping 82 matching lines @@
     TYPE_CREATE_VIEW_TREE_NODE,
     TYPE_DESTROY_VIEW_TREE_NODE,
     // Modifications to the hierarchy (addition of or removal of nodes from a
     // parent.)
     TYPE_HIERARCHY,
     // View replacement.
     TYPE_SET_ACTIVE_VIEW,
     // Node bounds.
     TYPE_SET_BOUNDS,
     // View contents
-    TYPE_SET_VIEW_CONTENTS
+    TYPE_SET_VIEW_CONTENTS,
+    // Embed.
+    TYPE_EMBED
   };
 
   ViewManagerTransaction(TransactionType transaction_type,
                          ViewManagerSynchronizer* synchronizer)
       : transaction_type_(transaction_type),
         committed_(false),
         synchronizer_(synchronizer) {
   }
 
   // Overridden to perform transaction-specific commit actions.
   virtual void DoCommit() = 0;
 
   // Overridden to perform transaction-specific cleanup on commit ack from the
   // service.
   virtual void DoActionCompleted(bool success) = 0;
 
-  IViewManager* service() { return synchronizer_->service_.get(); }
+  IViewManager* service() { return synchronizer_->service_; }
 
   TransportChangeId GetAndAdvanceNextServerChangeId() {
     return synchronizer_->next_server_change_id_++;
   }
 
   base::Callback<void(bool)> ActionCompletedCallback() {
     return base::Bind(&ViewManagerTransaction::OnActionCompleted,
                       base::Unretained(this));
   }
 
@@ skipping 259 matching lines @@
     return true;
   }
 
   const TransportViewId view_id_;
   const SkBitmap contents_;
   ScopedSharedBufferHandle shared_state_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(SetViewContentsTransaction);
 };
 
+class EmbedTransaction : public ViewManagerTransaction {
+ public:
+  EmbedTransaction(const String& url,
+                   TransportNodeId node_id,
+                   ViewManagerSynchronizer* synchronizer)
+      : ViewManagerTransaction(TYPE_EMBED, synchronizer),
+        url_(url),
+        node_id_(node_id) {}
+  virtual ~EmbedTransaction() {}
+
+ private:
+  // Overridden from ViewManagerTransaction:
+  virtual void DoCommit() OVERRIDE {
+    std::vector<TransportNodeId> ids;
+    ids.push_back(node_id_);
+    service()->Connect(url_, Array<TransportNodeId>::From(ids),
+                       ActionCompletedCallback());
+  }
+  virtual void DoActionCompleted(bool success) OVERRIDE {
+    // TODO(beng): recovery?
+  }
+
+  const String url_;
+  const TransportNodeId node_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(EmbedTransaction);
+};
+
 ViewManagerSynchronizer::ViewManagerSynchronizer(ViewManager* view_manager)
     : view_manager_(view_manager),
       connected_(false),
       connection_id_(0),
       next_id_(1),
       next_server_change_id_(0),
-      sync_factory_(this),
-      init_loop_(NULL) {
-  ConnectToService(
-      ViewManagerPrivate(view_manager_).service_provider(),
-      "mojo:mojo_view_manager",
-      &service_);
-  service_.set_client(this);
-
-  // Start a runloop. This loop is quit when the server tells us about the
-  // connection (OnConnectionEstablished()).
-  base::RunLoop loop;
-  init_loop_ = &loop;
-  init_loop_->Run();
-  init_loop_ = NULL;
+      sync_factory_(this) {
+  ViewManagerPrivate(view_manager).set_synchronizer(this);
 }
 
 ViewManagerSynchronizer::~ViewManagerSynchronizer() {
   Sync();
 }
 
 TransportNodeId ViewManagerSynchronizer::CreateViewTreeNode() {
   DCHECK(connected_);
   const TransportNodeId node_id(
       MakeTransportId(connection_id_, ++next_id_));
@@ skipping 72 matching lines @@
 }
 
 void ViewManagerSynchronizer::SetViewContents(TransportViewId view_id,
                                               const SkBitmap& contents) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new SetViewContentsTransaction(view_id, contents, this));
   Sync();
 }
 
+void ViewManagerSynchronizer::Embed(const String& url,
+                                    TransportNodeId node_id) {
+  DCHECK(connected_);
+  pending_transactions_.push_back(new EmbedTransaction(url, node_id, this));
+  Sync();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ViewManagerSynchronizer, InterfaceImpl overrides:
+
+void ViewManagerSynchronizer::OnConnectionEstablished() {
+  service_ = client();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, IViewManagerClient implementation:
 
 void ViewManagerSynchronizer::OnViewManagerConnectionEstablished(
     TransportConnectionId connection_id,
     TransportChangeId next_server_change_id,
     mojo::Array<INodePtr> nodes) {
   connected_ = true;
   connection_id_ = connection_id;
   next_server_change_id_ = next_server_change_id;
 
-  ViewManagerPrivate(view_manager_).set_root(
-      BuildNodeTree(view_manager_, nodes));
-  if (init_loop_)
-    init_loop_->Quit();
+  ViewManagerPrivate(view_manager()).set_root(
+      BuildNodeTree(view_manager(), nodes));
 
   Sync();
+
+  base::MessageLoop::current()->Quit();
 }
 
 void ViewManagerSynchronizer::OnServerChangeIdAdvanced(
     uint32_t next_server_change_id) {
   next_server_change_id_ = next_server_change_id;
 }
 
 void ViewManagerSynchronizer::OnNodeBoundsChanged(uint32 node_id,
                                                   RectPtr old_bounds,
                                                   RectPtr new_bounds) {
-  ViewTreeNode* node = view_manager_->GetNodeById(node_id);
+  ViewTreeNode* node = view_manager()->GetNodeById(node_id);
   ViewTreeNodePrivate(node).LocalSetBounds(old_bounds.To<gfx::Rect>(),
                                            new_bounds.To<gfx::Rect>());
 }
 
 void ViewManagerSynchronizer::OnNodeHierarchyChanged(
     uint32_t node_id,
     uint32_t new_parent_id,
     uint32_t old_parent_id,
     TransportChangeId server_change_id,
     mojo::Array<INodePtr> nodes) {
   // TODO: deal with |nodes|.
   next_server_change_id_ = server_change_id + 1;
 
-  BuildNodeTree(view_manager_, nodes);
+  BuildNodeTree(view_manager(), nodes);
 
-  ViewTreeNode* new_parent = view_manager_->GetNodeById(new_parent_id);
-  ViewTreeNode* old_parent = view_manager_->GetNodeById(old_parent_id);
-  ViewTreeNode* node = view_manager_->GetNodeById(node_id);
+  ViewTreeNode* new_parent = view_manager()->GetNodeById(new_parent_id);
+  ViewTreeNode* old_parent = view_manager()->GetNodeById(old_parent_id);
+  ViewTreeNode* node = view_manager()->GetNodeById(node_id);
   if (new_parent)
     ViewTreeNodePrivate(new_parent).LocalAddChild(node);
   else
     ViewTreeNodePrivate(old_parent).LocalRemoveChild(node);
 }
 
 void ViewManagerSynchronizer::OnNodeDeleted(uint32_t node_id,
                                             uint32_t server_change_id) {
   next_server_change_id_ = server_change_id + 1;
 
-  ViewTreeNode* node = view_manager_->GetNodeById(node_id);
+  ViewTreeNode* node = view_manager()->GetNodeById(node_id);
   if (node)
     ViewTreeNodePrivate(node).LocalDestroy();
 }
 
 void ViewManagerSynchronizer::OnNodeViewReplaced(uint32_t node_id,
                                                  uint32_t new_view_id,
                                                  uint32_t old_view_id) {
-  ViewTreeNode* node = view_manager_->GetNodeById(node_id);
-  View* new_view = view_manager_->GetViewById(new_view_id);
+  ViewTreeNode* node = view_manager()->GetNodeById(node_id);
+  View* new_view = view_manager()->GetViewById(new_view_id);
   if (!new_view && new_view_id != 0) {
     // This client wasn't aware of this View until now.
     new_view = ViewPrivate::LocalCreate();
     ViewPrivate private_view(new_view);
-    private_view.set_view_manager(view_manager_);
+    private_view.set_view_manager(view_manager());
     private_view.set_id(new_view_id);
     private_view.set_node(node);
-    ViewManagerPrivate(view_manager_).AddView(new_view->id(), new_view);
+    ViewManagerPrivate(view_manager()).AddView(new_view->id(), new_view);
   }
-  View* old_view = view_manager_->GetViewById(old_view_id);
+  View* old_view = view_manager()->GetViewById(old_view_id);
   DCHECK_EQ(old_view, node->active_view());
   ViewTreeNodePrivate(node).LocalSetActiveView(new_view);
 }
 
 void ViewManagerSynchronizer::OnViewDeleted(uint32_t view_id) {
-  View* view = view_manager_->GetViewById(view_id);
+  View* view = view_manager()->GetViewById(view_id);
   if (view)
     ViewPrivate(view).LocalDestroy();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, private:
 
 void ViewManagerSynchronizer::Sync() {
   // The service connection may not be set up yet. OnConnectionEstablished()
   // will schedule another sync when it is.
@@ skipping 10 matching lines @@
 void ViewManagerSynchronizer::RemoveFromPendingQueue(
     ViewManagerTransaction* transaction) {
   DCHECK_EQ(transaction, pending_transactions_.front());
   pending_transactions_.erase(pending_transactions_.begin());
   if (pending_transactions_.empty() && !changes_acked_callback_.is_null())
     changes_acked_callback_.Run();
 }
 
 }  // namespace view_manager
 }  // namespace mojo