Removes ServiceProviders from ViewManager::Embed

components/view_manager/view_manager_client_apptest.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 "components/view_manager/public/cpp/view_manager.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 206 matching lines @@
   }
 
   // ApplicationDelegate implementation.
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     connection->AddService(view_manager_client_factory_.get());
     return true;
   }
 
   ViewManager* window_manager() { return window_manager_; }
 
-  // Embeds another version of the test app @ view; returns nullptr on timeout.
-  ViewManager* Embed(ViewManager* view_manager, View* view) {
-    return EmbedImpl(view_manager, view, EmbedType::NO_REEMBED);
+  // Embeds another version of the test app @ view. This runs a run loop until
+  // a response is received, or a timeout. On success the new ViewManager is
+  // returned.
+  ViewManager* Embed(View* view) {
+    return EmbedImpl(view, EmbedType::NO_REEMBED);
   }
 
-  ViewManager* EmbedAllowingReembed(ViewManager* view_manager, View* view) {
-    return EmbedImpl(view_manager, view, EmbedType::ALLOW_REEMBED);
+  // Same as Embed(), but uses EmbedAllowingReembed().
+  ViewManager* EmbedAllowingReembed(View* view) {
+    return EmbedImpl(view, EmbedType::ALLOW_REEMBED);
+  }
+
+  // Establishes a connection to this application and asks for a
+  // ViewManagerClient. The ViewManagerClient is then embedded in |view|.
+  // This does *not* wait for the connection to complete.
+  void ConnectToApplicationAndEmbed(View* view) {
+    mojo::URLRequestPtr request(mojo::URLRequest::New());
+    request->url = mojo::String::From(application_impl()->url());
+    ApplicationConnection* connection =
+        application_impl()->ConnectToApplication(request.Pass());
+    mojo::ViewManagerClientPtr client;
+    connection->ConnectToService(&client);
+    view->Embed(client.Pass());
   }
 
   bool got_disconnect() const { return got_disconnect_; }
 
   ApplicationDelegate* GetApplicationDelegate() override { return this; }
 
   // Overridden from ViewManagerDelegate:
-  void OnEmbed(View* root,
-               InterfaceRequest<ServiceProvider> services,
-               ServiceProviderPtr exposed_services) override {
+  void OnEmbed(View* root) override {
     most_recent_view_manager_ = root->view_manager();
     QuitRunLoop();
   }
-  bool OnWillEmbed(View* view,
-                   InterfaceRequest<ServiceProvider>* services,
-                   ServiceProviderPtr* exposed_services) override {
-    if (!on_will_embed_return_value_)
+  void OnEmbedForDescendant(View* view,
+                            mojo::URLRequestPtr request,
+                            mojo::ViewManagerClientPtr* client) override {
+    on_will_embed_count_++;
+    if (on_will_embed_return_value_) {
+      ApplicationConnection* connection =
+          application_impl()->ConnectToApplication(request.Pass());
+      connection->ConnectToService(client);
+    } else {
       QuitRunLoop();
-    on_will_embed_count_++;
-    return on_will_embed_return_value_;
+    }
   }
   void OnViewManagerDestroyed(ViewManager* view_manager) override {
     got_disconnect_ = true;
   }
 
  private:
   enum class EmbedType {
     ALLOW_REEMBED,
     NO_REEMBED,
   };
 
-  ViewManager* EmbedImpl(ViewManager* view_manager,
-                         View* view,
-                         EmbedType type) {
-    DCHECK_EQ(view_manager, view->view_manager());
+  ViewManager* EmbedImpl(View* view, EmbedType type) {
     most_recent_view_manager_ = nullptr;
     if (type == EmbedType::ALLOW_REEMBED) {
       mojo::URLRequestPtr request(mojo::URLRequest::New());
       request->url = mojo::String::From(application_impl()->url());
       view->EmbedAllowingReembed(request.Pass());
     } else {
-      view->Embed(application_impl()->url());
+      ConnectToApplicationAndEmbed(view);
     }
     if (!DoRunLoopWithTimeout())
       return nullptr;
     ViewManager* vm = nullptr;
     std::swap(vm, most_recent_view_manager_);
     return vm;
   }
 
   // Overridden from testing::Test:
   void SetUp() override {
@@ skipping 28 matching lines @@
 
   // Value OnWillEmbed() should return.
   bool on_will_embed_return_value_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ViewManagerTest);
 };
 
 TEST_F(ViewManagerTest, RootView) {
   ASSERT_NE(nullptr, window_manager());
   EXPECT_NE(nullptr, window_manager()->GetRoot());
-  // No one embedded the window_manager(), so it has no url.
-  EXPECT_TRUE(window_manager()->GetEmbedderURL().empty());
 }
 
 TEST_F(ViewManagerTest, Embed) {
   View* view = window_manager()->CreateView();
   ASSERT_NE(nullptr, view);
   view->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view);
-  ViewManager* embedded = Embed(window_manager(), view);
+  ViewManager* embedded = Embed(view);
   ASSERT_NE(nullptr, embedded);
 
   View* view_in_embedded = embedded->GetRoot();
   ASSERT_NE(nullptr, view_in_embedded);
   EXPECT_EQ(view->id(), view_in_embedded->id());
   EXPECT_EQ(nullptr, view_in_embedded->parent());
   EXPECT_TRUE(view_in_embedded->children().empty());
 }
 
 // Window manager has two views, N1 and N11. Embeds A at N1. A should not see
 // N11.
 TEST_F(ViewManagerTest, EmbeddedDoesntSeeChild) {
   View* view = window_manager()->CreateView();
   ASSERT_NE(nullptr, view);
   view->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view);
   View* nested = window_manager()->CreateView();
   ASSERT_NE(nullptr, nested);
   nested->SetVisible(true);
   view->AddChild(nested);
 
-  ViewManager* embedded = Embed(window_manager(), view);
+  ViewManager* embedded = Embed(view);
   ASSERT_NE(nullptr, embedded);
   View* view_in_embedded = embedded->GetRoot();
   EXPECT_EQ(view->id(), view_in_embedded->id());
   EXPECT_EQ(nullptr, view_in_embedded->parent());
   EXPECT_TRUE(view_in_embedded->children().empty());
 }
 
 // TODO(beng): write a replacement test for the one that once existed here:
 // This test validates the following scenario:
 // -  a view originating from one connection
 // -  a view originating from a second connection
 // +  the connection originating the view is destroyed
 // -> the view should still exist (since the second connection is live) but
 //    should be disconnected from any views.
 // http://crbug.com/396300
 //
 // TODO(beng): The new test should validate the scenario as described above
 //             except that the second connection still has a valid tree.
 
 // Verifies that bounds changes applied to a view hierarchy in one connection
 // are reflected to another.
 TEST_F(ViewManagerTest, SetBounds) {
   View* view = window_manager()->CreateView();
   view->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view);
-  ViewManager* embedded = Embed(window_manager(), view);
+  ViewManager* embedded = Embed(view);
   ASSERT_NE(nullptr, embedded);
 
   View* view_in_embedded = embedded->GetViewById(view->id());
   EXPECT_EQ(view->bounds(), view_in_embedded->bounds());
 
   Rect rect;
   rect.width = rect.height = 100;
   view->SetBounds(rect);
   ASSERT_TRUE(WaitForBoundsToChange(view_in_embedded));
   EXPECT_EQ(view->bounds(), view_in_embedded->bounds());
 }
 
 // Verifies that bounds changes applied to a view owned by a different
 // connection are refused.
 TEST_F(ViewManagerTest, SetBoundsSecurity) {
   View* view = window_manager()->CreateView();
   view->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view);
-  ViewManager* embedded = Embed(window_manager(), view);
+  ViewManager* embedded = Embed(view);
   ASSERT_NE(nullptr, embedded);
 
   View* view_in_embedded = embedded->GetViewById(view->id());
   Rect rect;
   rect.width = 800;
   rect.height = 600;
   view->SetBounds(rect);
   ASSERT_TRUE(WaitForBoundsToChange(view_in_embedded));
 
   rect.width = 1024;
   rect.height = 768;
   view_in_embedded->SetBounds(rect);
   // Bounds change should have been rejected.
   EXPECT_EQ(view->bounds(), view_in_embedded->bounds());
 }
 
 // Verifies that a view can only be destroyed by the connection that created it.
 TEST_F(ViewManagerTest, DestroySecurity) {
   View* view = window_manager()->CreateView();
   view->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view);
-  ViewManager* embedded = Embed(window_manager(), view);
+  ViewManager* embedded = Embed(view);
   ASSERT_NE(nullptr, embedded);
 
   View* view_in_embedded = embedded->GetViewById(view->id());
 
   ViewTracker tracker2(view_in_embedded);
   view_in_embedded->Destroy();
   // View should not have been destroyed.
   EXPECT_TRUE(tracker2.is_valid());
 
   ViewTracker tracker1(view);
   view->Destroy();
   EXPECT_FALSE(tracker1.is_valid());
 }
 
 TEST_F(ViewManagerTest, MultiRoots) {
   View* view1 = window_manager()->CreateView();
   view1->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view1);
   View* view2 = window_manager()->CreateView();
   view2->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view2);
-  ViewManager* embedded1 = Embed(window_manager(), view1);
+  ViewManager* embedded1 = Embed(view1);
   ASSERT_NE(nullptr, embedded1);
-  ViewManager* embedded2 = Embed(window_manager(), view2);
+  ViewManager* embedded2 = Embed(view2);
   ASSERT_NE(nullptr, embedded2);
   EXPECT_NE(embedded1, embedded2);
 }
 
-TEST_F(ViewManagerTest, EmbeddingIdentity) {
-  View* view = window_manager()->CreateView();
-  view->SetVisible(true);
-  window_manager()->GetRoot()->AddChild(view);
-  ViewManager* embedded = Embed(window_manager(), view);
-  ASSERT_NE(nullptr, embedded);
-  EXPECT_EQ(application_impl()->url(), embedded->GetEmbedderURL());
-}
-
 // TODO(alhaad): Currently, the RunLoop gets stuck waiting for order change.
 // Debug and re-enable this.
 TEST_F(ViewManagerTest, DISABLED_Reorder) {
   View* view1 = window_manager()->CreateView();
   view1->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view1);
 
-  ViewManager* embedded = Embed(window_manager(), view1);
+  ViewManager* embedded = Embed(view1);
   ASSERT_NE(nullptr, embedded);
 
   View* view11 = embedded->CreateView();
   view11->SetVisible(true);
   embedded->GetRoot()->AddChild(view11);
   View* view12 = embedded->CreateView();
   view12->SetVisible(true);
   embedded->GetRoot()->AddChild(view12);
 
   View* root_in_embedded = embedded->GetRoot();
@@ skipping 43 matching lines @@
 };
 
 }  // namespace
 
 TEST_F(ViewManagerTest, Visible) {
   View* view1 = window_manager()->CreateView();
   view1->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view1);
 
   // Embed another app and verify initial state.
-  ViewManager* embedded = Embed(window_manager(), view1);
+  ViewManager* embedded = Embed(view1);
   ASSERT_NE(nullptr, embedded);
   ASSERT_NE(nullptr, embedded->GetRoot());
   View* embedded_root = embedded->GetRoot();
   EXPECT_TRUE(embedded_root->visible());
   EXPECT_TRUE(embedded_root->IsDrawn());
 
   // Change the visible state from the first connection and verify its mirrored
   // correctly to the embedded app.
   {
     VisibilityChangeObserver observer(embedded_root);
@@ skipping 43 matching lines @@
 };
 
 }  // namespace
 
 TEST_F(ViewManagerTest, Drawn) {
   View* view1 = window_manager()->CreateView();
   view1->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view1);
 
   // Embed another app and verify initial state.
-  ViewManager* embedded = Embed(window_manager(), view1);
+  ViewManager* embedded = Embed(view1);
   ASSERT_NE(nullptr, embedded);
   ASSERT_NE(nullptr, embedded->GetRoot());
   View* embedded_root = embedded->GetRoot();
   EXPECT_TRUE(embedded_root->visible());
   EXPECT_TRUE(embedded_root->IsDrawn());
 
   // Change the visibility of the root, this should propagate a drawn state
   // change to |embedded|.
   {
     DrawnChangeObserver observer(embedded_root);
@@ skipping 40 matching lines @@
   MOJO_DISALLOW_COPY_AND_ASSIGN(FocusChangeObserver);
 };
 
 }  // namespace
 
 TEST_F(ViewManagerTest, Focus) {
   View* view1 = window_manager()->CreateView();
   view1->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view1);
 
-  ViewManager* embedded = Embed(window_manager(), view1);
+  ViewManager* embedded = Embed(view1);
   ASSERT_NE(nullptr, embedded);
   View* view11 = embedded->CreateView();
   view11->SetVisible(true);
   embedded->GetRoot()->AddChild(view11);
 
   // TODO(alhaad): Figure out why switching focus between views from different
   // connections is causing the tests to crash and add tests for that.
   {
     View* embedded_root = embedded->GetRoot();
     FocusChangeObserver observer(embedded_root);
@@ skipping 43 matching lines @@
 };
 
 }  // namespace
 
 // Verifies deleting a ViewManager sends the right notifications.
 TEST_F(ViewManagerTest, DeleteViewManager) {
   View* view = window_manager()->CreateView();
   ASSERT_NE(nullptr, view);
   view->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view);
-  ViewManager* view_manager = Embed(window_manager(), view);
+  ViewManager* view_manager = Embed(view);
   ASSERT_TRUE(view_manager);
   bool got_destroy = false;
   DestroyedChangedObserver observer(view_manager->GetRoot(), &got_destroy);
   delete view_manager;
   EXPECT_TRUE(got_disconnect());
   EXPECT_TRUE(got_destroy);
 }
 
 // Verifies two Embed()s in the same view trigger deletion of the first
 // ViewManager.
 TEST_F(ViewManagerTest, DisconnectTriggersDelete) {
   View* view = window_manager()->CreateView();
   ASSERT_NE(nullptr, view);
   view->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view);
-  ViewManager* view_manager = Embed(window_manager(), view);
+  ViewManager* view_manager = Embed(view);
   EXPECT_NE(view_manager, window_manager());
   View* embedded_view = view_manager->CreateView();
   // Embed again, this should trigger disconnect and deletion of view_manager.
   bool got_destroy;
   DestroyedChangedObserver observer(embedded_view, &got_destroy);
   EXPECT_FALSE(got_disconnect());
-  Embed(window_manager(), view);
+  Embed(view);
   EXPECT_TRUE(got_disconnect());
 }
 
 class ViewRemovedFromParentObserver : public ViewObserver {
  public:
   explicit ViewRemovedFromParentObserver(View* view)
       : view_(view), was_removed_(false) {
     view_->AddObserver(this);
   }
   ~ViewRemovedFromParentObserver() override { view_->RemoveObserver(this); }
@@ skipping 13 matching lines @@
   MOJO_DISALLOW_COPY_AND_ASSIGN(ViewRemovedFromParentObserver);
 };
 
 TEST_F(ViewManagerTest, EmbedRemovesChildren) {
   View* view1 = window_manager()->CreateView();
   View* view2 = window_manager()->CreateView();
   window_manager()->GetRoot()->AddChild(view1);
   view1->AddChild(view2);
 
   ViewRemovedFromParentObserver observer(view2);
-  view1->Embed(application_impl()->url());
+  ConnectToApplicationAndEmbed(view1);
   EXPECT_TRUE(observer.was_removed());
   EXPECT_EQ(nullptr, view2->parent());
   EXPECT_TRUE(view1->children().empty());
 
   // Run the message loop so the Embed() call above completes. Without this
   // we may end up reconnecting to the test and rerunning the test, which is
   // problematic since the other services don't shut down.
   ASSERT_TRUE(DoRunLoopWithTimeout());
 }
 
 TEST_F(ViewManagerTest, OnWillEmbed) {
   window_manager()->SetEmbedRoot();
 
   View* view1 = window_manager()->CreateView();
   window_manager()->GetRoot()->AddChild(view1);
 
-  ViewManager* view_manager = Embed(window_manager(), view1);
+  ViewManager* view_manager = EmbedAllowingReembed(view1);
   View* view2 = view_manager->CreateView();
   view_manager->GetRoot()->AddChild(view2);
 
-  Embed(view_manager, view2);
+  EmbedAllowingReembed(view2);
   EXPECT_EQ(1u, on_will_embed_count());
 }
 
 // Verifies Embed() doesn't succeed if OnWillEmbed() returns false.
 TEST_F(ViewManagerTest, OnWillEmbedFails) {
   window_manager()->SetEmbedRoot();
 
   View* view1 = window_manager()->CreateView();
   window_manager()->GetRoot()->AddChild(view1);
 
-  ViewManager* view_manager = Embed(window_manager(), view1);
+  ViewManager* view_manager = Embed(view1);
   View* view2 = view_manager->CreateView();
   view_manager->GetRoot()->AddChild(view2);
 
   clear_on_will_embed_count();
   set_on_will_embed_return_value(false);
-  view2->Embed(application_impl()->url());
+  mojo::URLRequestPtr request(mojo::URLRequest::New());
+  request->url = application_impl()->url();
+  view2->EmbedAllowingReembed(request.Pass());
 
   EXPECT_TRUE(DoRunLoopWithTimeout());
   EXPECT_EQ(1u, on_will_embed_count());
 
   // The run loop above quits when OnWillEmbed() returns, which means it's
   // possible there is still an OnEmbed() message in flight. Sets the bounds of
   // |view1| and wait for it to the change in |view_manager|, that way we know
   // |view_manager| has processed all messages for it.
   EXPECT_TRUE(IncrementWidthAndWaitForChange(view1, view_manager));
 
   EXPECT_EQ(1u, on_will_embed_count());
 }
 
 // Verify an Embed() from an ancestor is not allowed.
 TEST_F(ViewManagerTest, ReembedFails) {
   window_manager()->SetEmbedRoot();
 
   View* view1 = window_manager()->CreateView();
   window_manager()->GetRoot()->AddChild(view1);
 
-  ViewManager* view_manager = Embed(window_manager(), view1);
+  ViewManager* view_manager = Embed(view1);
   ASSERT_TRUE(view_manager);
   View* view2 = view_manager->CreateView();
   view_manager->GetRoot()->AddChild(view2);
-  Embed(view_manager, view2);
+  Embed(view2);
 
   // Try to embed in view2 from the window_manager. This should fail as the
   // Embed() didn't grab reembed.
   View* view2_in_wm = window_manager()->GetViewById(view2->id());
-  view2_in_wm->Embed(application_impl()->url());
+  ConnectToApplicationAndEmbed(view2_in_wm);
 
   // The Embed() call above returns immediately. To ensure the server has
   // processed it nudge the bounds and wait for it to be processed.
   EXPECT_TRUE(IncrementWidthAndWaitForChange(view1, view_manager));
 
   EXPECT_EQ(nullptr, most_recent_view_manager());
 }
 
 // Verify an Embed() from an ancestor is allowed if the ancestor is an embed
 // root and Embed was done by way of EmbedAllowingReembed().
 TEST_F(ViewManagerTest, ReembedSucceeds) {
   window_manager()->SetEmbedRoot();
 
   View* view1 = window_manager()->CreateView();
   window_manager()->GetRoot()->AddChild(view1);
 
-  ViewManager* view_manager = Embed(window_manager(), view1);
+  ViewManager* view_manager = Embed(view1);
   View* view2 = view_manager->CreateView();
   view_manager->GetRoot()->AddChild(view2);
-  EmbedAllowingReembed(view_manager, view2);
+  EmbedAllowingReembed(view2);
 
   View* view2_in_wm = window_manager()->GetViewById(view2->id());
-  ViewManager* view_manager2 = Embed(window_manager(), view2_in_wm);
+  ViewManager* view_manager2 = Embed(view2_in_wm);
   ASSERT_TRUE(view_manager2);
 
   // The Embed() call above returns immediately. To ensure the server has
   // processed it nudge the bounds and wait for it to be processed.
   EXPECT_TRUE(IncrementWidthAndWaitForChange(view1, view_manager));
 
   EXPECT_EQ(nullptr, most_recent_view_manager());
 }
 
 }  // namespace mojo