Fix destruction tests.

mojo/services/public/cpp/view_manager/tests/view_manager_unittest.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/view_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/public/cpp/application/application.h"
@@ skipping 32 matching lines @@
   QuitRunLoop();
 }
 
 void WaitForAllChangesToBeAcked(ViewManager* manager) {
   ViewManagerPrivate(manager).synchronizer()->set_changes_acked_callback(
       base::Bind(&QuitRunLoopOnChangesAcked));
   DoRunLoop();
   ViewManagerPrivate(manager).synchronizer()->ClearChangesAckedCallback();
 }
 
-// Used with IViewManager::Connect(). Creates a TestViewManagerClientConnection,
-// which creates and owns the ViewManagerProxy.
 class ConnectServiceLoader : public ServiceLoader {
  public:
   explicit ConnectServiceLoader(base::Callback<void(ViewManager*)> callback)
       : callback_(callback) {}
   virtual ~ConnectServiceLoader() {}
 
-  // ServiceLoader:
+ private:
+  // Overridden from ServiceLoader:
   virtual void LoadService(ServiceManager* manager,
                            const GURL& url,
                            ScopedMessagePipeHandle shell_handle) OVERRIDE {
     scoped_ptr<Application> app(new Application(shell_handle.Pass()));
     ViewManager::Create(app.get(), callback_);
     apps_.push_back(app.release());
   }
   virtual void OnServiceError(ServiceManager* manager,
                               const GURL& url) OVERRIDE {
   }
 
- private:
   ScopedVector<Application> apps_;
   base::Callback<void(ViewManager*)> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectServiceLoader);
 };
 
 class ActiveViewChangedObserver : public ViewTreeNodeObserver {
  public:
   explicit ActiveViewChangedObserver(ViewTreeNode* node)
       : node_(node) {}
@@ skipping 231 matching lines @@
   void DestroyViewManager1() {}
   ViewManager* view_manager_1() { return NULL; }
   ViewManager* view_manager_2() { return NULL; }
 
   ViewManager* GetLoadedViewManager() {
     ViewManager* view_manager = loaded_view_manager_;
     loaded_view_manager_ = NULL;
     return view_manager;
   }
 
+  void UnloadApplication(const GURL& url) {
+    test_helper_.SetLoaderForURL(scoped_ptr<ServiceLoader>(), url);
+  }
+
  private:
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
     test_helper_.Init();
     test_helper_.SetLoaderForURL(
         scoped_ptr<ServiceLoader>(new ConnectServiceLoader(
             base::Bind(&ViewManagerTest::OnViewManagerLoaded,
                        base::Unretained(this)))),
         GURL(kTestServiceURL));
     test_helper_.SetLoaderForURL(
@@ skipping 134 matching lines @@
   nested->Destroy();
 
   std::set<TransportNodeId> nodes;
   nodes.insert(id);
   WaitForDestruction(embedded, &nodes, NULL);
 
   EXPECT_TRUE(embedded->tree()->children().empty());
   EXPECT_EQ(NULL, embedded->GetNodeById(id));
 }
 
-// TODO(beng): provide a way to terminate an application.
-TEST_F(ViewManagerTest, DISABLED_ViewManagerDestroyed_CleanupNode) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
+TEST_F(ViewManagerTest, ViewManagerDestroyed_CleanupNode) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
 
-  TransportNodeId id = node1->id();
-  DestroyViewManager1();
+  TransportNodeId node_id = node->id();
+
+  UnloadApplication(GURL(kTestServiceURL));
+
   std::set<TransportNodeId> nodes;
-  nodes.insert(id);
-  WaitForDestruction(view_manager_2(), &nodes, NULL);
+  nodes.insert(node_id);
+  WaitForDestruction(embedded, &nodes, NULL);
 
-  // tree() should still be valid, since it's owned by neither connection.
-  EXPECT_TRUE(view_manager_2()->tree()->children().empty());
+  EXPECT_EQ(NULL, embedded->tree());
 }
 
 TEST_F(ViewManagerTest, SetActiveView) {
   ViewTreeNode* node = ViewTreeNode::Create(window_manager());
   window_manager()->tree()->AddChild(node);
   ViewManager* embedded = Embed(window_manager(), node);
 
   View* view = View::Create(window_manager());
   node->SetActiveView(view);
 
@@ skipping 21 matching lines @@
 
   std::set<TransportViewId> views;
   views.insert(view_id);
   WaitForDestruction(embedded, NULL, &views);
   EXPECT_EQ(NULL, node_in_embedded->active_view());
   EXPECT_EQ(NULL, embedded->GetViewById(view_id));
 }
 
 // Destroying the connection that created a node and view should result in that
 // node and view disappearing from all connections that see them.
-TEST_F(ViewManagerTest, DISABLED_ViewManagerDestroyed_CleanupNodeAndView) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
+TEST_F(ViewManagerTest, ViewManagerDestroyed_CleanupNodeAndView) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  View* view = View::Create(window_manager());
+  node->SetActiveView(view);
+  ViewManager* embedded = Embed(window_manager(), node);
 
-  View* view1 = View::Create(view_manager_1());
-  node1->SetActiveView(view1);
+  TransportNodeId node_id = node->id();
+  TransportViewId view_id = view->id();
 
-  ViewTreeNode* node1_2 = view_manager_2()->tree()->GetChildById(node1->id());
-  WaitForActiveViewToChange(node1_2);
+  UnloadApplication(GURL(kTestServiceURL));
 
-  TransportNodeId node1_id = node1->id();
-  TransportViewId view1_id = view1->id();
+  std::set<TransportNodeId> observed_nodes;
+  observed_nodes.insert(node_id);
+  std::set<TransportViewId> observed_views;
+  observed_views.insert(view_id);
+  WaitForDestruction(embedded, &observed_nodes, &observed_views);
 
-  DestroyViewManager1();
-  std::set<TransportNodeId> observed_nodes;
-  observed_nodes.insert(node1_id);
-  std::set<TransportViewId> observed_views;
-  observed_views.insert(view1_id);
-  WaitForDestruction(view_manager_2(), &observed_nodes, &observed_views);
-
-  // tree() should still be valid, since it's owned by neither connection.
-  EXPECT_TRUE(view_manager_2()->tree()->children().empty());
-  EXPECT_EQ(NULL, view_manager_2()->GetNodeById(node1_id));
-  EXPECT_EQ(NULL, view_manager_2()->GetViewById(view1_id));
+  EXPECT_EQ(NULL, embedded->tree());
+  EXPECT_EQ(NULL, embedded->GetNodeById(node_id));
+  EXPECT_EQ(NULL, embedded->GetViewById(view_id));
 }
 
 // This test validates the following scenario:
 // -  a node originating from one connection
 // -  a view originating from a second connection
 // +  the connection originating the node is destroyed
 // -> the view should still exist (since the second connection is live) but
 //    should be disconnected from any nodes.
 TEST_F(ViewManagerTest,
-    DISABLED_ViewManagerDestroyed_CleanupNodeAndViewFromDifferentConnections) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
+       ViewManagerDestroyed_CleanupNodeAndViewFromDifferentConnections) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
+  View* view_in_embedded = View::Create(embedded);
+  ViewTreeNode* node_in_embedded = embedded->GetNodeById(node->id());
+  node_in_embedded->SetActiveView(view_in_embedded);
 
-  View* view1_2 = View::Create(view_manager_2());
-  ViewTreeNode* node1_2 = view_manager_2()->tree()->GetChildById(node1->id());
-  node1_2->SetActiveView(view1_2);
-  WaitForActiveViewToChange(node1);
+  WaitForActiveViewToChange(node);
 
-  TransportNodeId node1_id = node1->id();
-  TransportViewId view1_2_id = view1_2->id();
+  TransportNodeId node_id = node->id();
+  TransportViewId view_id = view_in_embedded->id();
 
-  DestroyViewManager1();
+  UnloadApplication(GURL(kTestServiceURL));
   std::set<TransportNodeId> nodes;
-  nodes.insert(node1_id);
-  WaitForDestruction(view_manager_2(), &nodes, NULL);
+  nodes.insert(node_id);
+  WaitForDestruction(embedded, &nodes, NULL);
 
-  // tree() should still be valid, since it's owned by neither connection.
-  EXPECT_TRUE(view_manager_2()->tree()->children().empty());
-  // node1 was owned by the first connection, so it should be gone.
-  EXPECT_EQ(NULL, view_manager_2()->GetNodeById(node1_id));
-  // view1_2 was owned by the second connection, so it should still exist, but
-  // disconnected from the node tree.
-  View* another_view1_2 = view_manager_2()->GetViewById(view1_2_id);
-  EXPECT_EQ(view1_2, another_view1_2);
-  EXPECT_EQ(NULL, view1_2->node());
+  EXPECT_EQ(NULL, embedded->tree());
+  // node was owned by the window manager, so it should be gone.
+  EXPECT_EQ(NULL, embedded->GetNodeById(node_id));
+  // view_in_embedded was owned by the embedded app, so it should still exist,
+  // but disconnected from the node tree.
+  EXPECT_EQ(view_in_embedded, embedded->GetViewById(view_id));
+  EXPECT_EQ(NULL, view_in_embedded->node());
 }
 
 // This test verifies that it is not possible to set the active view to a view
 // defined in a different connection.
 // TODO(beng): write these tests for ViewTreeNode::AddChild(), RemoveChild() and
 //             Contains().
 TEST_F(ViewManagerTest, SetActiveViewAcrossConnection) {
   ViewTreeNode* node = ViewTreeNode::Create(window_manager());
   window_manager()->tree()->AddChild(node);
   ViewManager* embedded = Embed(window_manager(), node);
@@ skipping 77 matching lines @@
   // Node should not have been destroyed.
   EXPECT_TRUE(tracker2.is_valid());
 
   NodeTracker tracker1(node);
   node->Destroy();
   EXPECT_FALSE(tracker1.is_valid());
 }
 
 }  // namespace view_manager
 }  // namespace mojo