Removes ServiceProviders from ViewManager::Embed

components/view_manager/view_manager_service_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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "components/view_manager/ids.h"
 #include "components/view_manager/public/interfaces/view_manager.mojom.h"
 #include "components/view_manager/public/interfaces/view_manager_root.mojom.h"
@@ skipping 51 matching lines @@
 void ViewTreeResultCallback(base::RunLoop* run_loop,
                             std::vector<TestView>* views,
                             Array<ViewDataPtr> results) {
   ViewDatasToTestViews(results, views);
   run_loop->Quit();
 }
 
 // -----------------------------------------------------------------------------
 
 // The following functions call through to the supplied ViewManagerService. They
-// block until call completes and return the result.
+// block until the call completes and return the result.
 bool CreateView(ViewManagerService* vm, Id view_id) {
   ErrorCode result = ERROR_CODE_NONE;
   base::RunLoop run_loop;
   vm->CreateView(view_id,
                  base::Bind(&ErrorCodeResultCallback, &run_loop, &result));
   run_loop.Run();
   return result == ERROR_CODE_NONE;
 }
 
-bool EmbedUrl(ViewManagerService* vm, const String& url, Id root_id) {
+bool EmbedUrl(mojo::ApplicationImpl* app,
+              ViewManagerService* vm,
+              const String& url,
+              Id root_id) {
   bool result = false;
   base::RunLoop run_loop;
   {
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From(url);
-    vm->EmbedRequest(request.Pass(), root_id, nullptr, nullptr,
-                     base::Bind(&BoolResultCallback, &run_loop, &result));
+    ApplicationConnection* connection =
+        app->ConnectToApplication(request.Pass());
+    mojo::ViewManagerClientPtr client;
+    connection->ConnectToService(&client);
+    vm->Embed(root_id, client.Pass(),
+              base::Bind(&BoolResultCallback, &run_loop, &result));
   }
   run_loop.Run();
   return result;
+}
+
+bool EmbedAllowingReembed(mojo::ApplicationImpl* app,
+                          ViewManagerService* vm,
+                          const String& url,
+                          Id root_id) {
+  bool result = false;
+  base::RunLoop run_loop;
+  {
+    mojo::URLRequestPtr request(mojo::URLRequest::New());
+    request->url = mojo::String::From(url);
+    vm->EmbedAllowingReembed(
+        root_id, request.Pass(),
+        base::Bind(&BoolResultCallback, &run_loop, &result));
+  }
+  run_loop.Run();
+  return result;
 }
 
 bool Embed(ViewManagerService* vm,
            Id root_id,
            mojo::ViewManagerClientPtr client) {
   bool result = false;
   base::RunLoop run_loop;
   {
     vm->Embed(root_id, client.Pass(),
               base::Bind(&BoolResultCallback, &run_loop, &result));
@@ skipping 121 matching lines @@
       return true;
   return false;
 }
 
 // -----------------------------------------------------------------------------
 
 // A ViewManagerClient implementation that logs all changes to a tracker.
 class ViewManagerClientImpl : public mojo::ViewManagerClient,
                               public TestChangeTracker::Delegate {
  public:
-  ViewManagerClientImpl() : binding_(this) { tracker_.set_delegate(this); }
+  explicit ViewManagerClientImpl(mojo::ApplicationImpl* app)
+      : binding_(this), app_(app) {
+    tracker_.set_delegate(this);
+  }
 
   void Bind(mojo::InterfaceRequest<mojo::ViewManagerClient> request) {
     binding_.Bind(request.Pass());
   }
 
   mojo::ViewManagerService* service() { return service_.get(); }
   TestChangeTracker* tracker() { return &tracker_; }
 
   // Runs a nested MessageLoop until |count| changes (calls to
   // ViewManagerClient functions) have been received.
@@ skipping 34 matching lines @@
   // TestChangeTracker::Delegate:
   void OnChangeAdded() override {
     if (wait_state_.get() &&
         wait_state_->change_count == tracker_.changes()->size()) {
       wait_state_->run_loop.Quit();
     }
   }
 
   // ViewManagerClient:
   void OnEmbed(ConnectionSpecificId connection_id,
-               const String& creator_url,
                ViewDataPtr root,
                mojo::ViewManagerServicePtr view_manager_service,
-               InterfaceRequest<ServiceProvider> services,
-               ServiceProviderPtr exposed_services,
                mojo::Id focused_view_id) override {
     // TODO(sky): add coverage of |focused_view_id|.
     service_ = view_manager_service.Pass();
-    tracker()->OnEmbed(connection_id, creator_url, root.Pass());
+    tracker()->OnEmbed(connection_id, root.Pass());
     if (embed_run_loop_)
       embed_run_loop_->Quit();
   }
-  void OnWillEmbed(uint32_t view,
-                   mojo::InterfaceRequest<mojo::ServiceProvider> services,
-                   mojo::ServiceProviderPtr exposed_services,
-                   const OnWillEmbedCallback& callback) override {
-    tracker()->OnWillEmbed(view);
-    callback.Run(true, services.Pass(), exposed_services.Pass());
+  void OnEmbedForDescendant(
+      uint32_t view,
+      mojo::URLRequestPtr request,
+      const OnEmbedForDescendantCallback& callback) override {
+    tracker()->OnEmbedForDescendant(view);
+    mojo::ViewManagerClientPtr client;
+    ApplicationConnection* connection =
+        app_->ConnectToApplication(request.Pass());
+    connection->ConnectToService(&client);
+    callback.Run(client.Pass());
   }
   void OnEmbeddedAppDisconnected(Id view_id) override {
     tracker()->OnEmbeddedAppDisconnected(view_id);
   }
   void OnViewBoundsChanged(Id view_id,
                            RectPtr old_bounds,
                            RectPtr new_bounds) override {
     tracker()->OnViewBoundsChanged(view_id, old_bounds.Pass(),
                                    new_bounds.Pass());
   }
@@ skipping 40 matching lines @@
   mojo::ViewManagerServicePtr service_;
 
   // If non-null we're waiting for OnEmbed() using this RunLoop.
   scoped_ptr<base::RunLoop> embed_run_loop_;
 
   // If non-null we're waiting for a certain number of change notifications to
   // be encountered.
   scoped_ptr<WaitState> wait_state_;
 
   mojo::Binding<ViewManagerClient> binding_;
+  mojo::ApplicationImpl* app_;
+
   DISALLOW_COPY_AND_ASSIGN(ViewManagerClientImpl);
 };
 
 // -----------------------------------------------------------------------------
 
 // InterfaceFactory for vending ViewManagerClientImpls.
 class ViewManagerClientFactory
     : public mojo::InterfaceFactory<ViewManagerClient> {
  public:
-  ViewManagerClientFactory() {}
+  explicit ViewManagerClientFactory(mojo::ApplicationImpl* app) : app_(app) {}
   ~ViewManagerClientFactory() override {}
 
   // Runs a nested MessageLoop until a new instance has been created.
   scoped_ptr<ViewManagerClientImpl> WaitForInstance() {
     if (!client_impl_.get()) {
       DCHECK(!run_loop_.get());
       run_loop_.reset(new base::RunLoop);
       run_loop_->Run();
       run_loop_.reset();
     }
     return client_impl_.Pass();
   }
 
  private:
   // InterfaceFactory<ViewManagerClient>:
   void Create(ApplicationConnection* connection,
               InterfaceRequest<ViewManagerClient> request) override {
-    client_impl_.reset(new ViewManagerClientImpl);
+    client_impl_.reset(new ViewManagerClientImpl(app_));
     client_impl_->Bind(request.Pass());
     if (run_loop_.get())
       run_loop_->Quit();
   }
 
+  mojo::ApplicationImpl* app_;
   scoped_ptr<ViewManagerClientImpl> client_impl_;
   scoped_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewManagerClientFactory);
 };
 
 class ViewManagerServiceAppTest : public mojo::test::ApplicationTestBase,
                                   public ApplicationDelegate {
  public:
   ViewManagerServiceAppTest() {}
   ~ViewManagerServiceAppTest() override {}
 
  protected:
+  enum class EmbedType {
+    ALLOW_REEMBED,
+    NO_REEMBED,
+  };
+
   // Returns the changes from the various connections.
   std::vector<Change>* changes1() { return vm_client1_->tracker()->changes(); }
   std::vector<Change>* changes2() { return vm_client2_->tracker()->changes(); }
   std::vector<Change>* changes3() { return vm_client3_->tracker()->changes(); }
 
   // Various connections. |vm1()|, being the first connection, has special
   // permissions (it's treated as the window manager).
   ViewManagerService* vm1() { return vm1_.get(); }
   ViewManagerService* vm2() { return vm_client2_->service(); }
   ViewManagerService* vm3() { return vm_client3_->service(); }
 
   void EstablishSecondConnectionWithRoot(Id root_id) {
     ASSERT_TRUE(vm_client2_.get() == nullptr);
-    vm_client2_ = EstablishConnectionViaEmbed(vm1(), root_id);
+    vm_client2_ =
+        EstablishConnectionViaEmbed(vm1(), root_id, EmbedType::NO_REEMBED);
     ASSERT_TRUE(vm_client2_.get() != nullptr);
   }
 
   void EstablishSecondConnection(bool create_initial_view) {
     if (create_initial_view)
       ASSERT_TRUE(CreateView(vm1_.get(), BuildViewId(1, 1)));
     ASSERT_NO_FATAL_FAILURE(
         EstablishSecondConnectionWithRoot(BuildViewId(1, 1)));
 
     if (create_initial_view)
       EXPECT_EQ("[view=1,1 parent=null]", ChangeViewDescription(*changes2()));
   }
 
   void EstablishThirdConnection(ViewManagerService* owner, Id root_id) {
     ASSERT_TRUE(vm_client3_.get() == nullptr);
-    vm_client3_ = EstablishConnectionViaEmbed(owner, root_id);
+    vm_client3_ =
+        EstablishConnectionViaEmbed(owner, root_id, EmbedType::NO_REEMBED);
     ASSERT_TRUE(vm_client3_.get() != nullptr);
   }
 
   // Establishes a new connection by way of Embed() on the specified
   // ViewManagerService.
   scoped_ptr<ViewManagerClientImpl> EstablishConnectionViaEmbed(
       ViewManagerService* owner,
-      Id root_id) {
-    if (!EmbedUrl(owner, application_impl()->url(), root_id)) {
+      Id root_id,
+      EmbedType embed_type) {
+    if (embed_type == EmbedType::NO_REEMBED &&
+        !EmbedUrl(application_impl(), owner, application_impl()->url(),
+                  root_id)) {
+      ADD_FAILURE() << "Embed() failed";
+      return nullptr;
+    } else if (embed_type == EmbedType::ALLOW_REEMBED &&
+               !EmbedAllowingReembed(application_impl(), owner,
+                                     application_impl()->url(), root_id)) {
       ADD_FAILURE() << "Embed() failed";
       return nullptr;
     }
     scoped_ptr<ViewManagerClientImpl> client =
-        client_factory_.WaitForInstance();
+        client_factory_->WaitForInstance();
     if (!client.get()) {
       ADD_FAILURE() << "WaitForInstance failed";
       return nullptr;
     }
     client->WaitForOnEmbed();
 
-    EXPECT_EQ("OnEmbed creator=" + application_impl()->url(),
+    EXPECT_EQ("OnEmbed",
               SingleChangeToDescription(*client->tracker()->changes()));
     return client.Pass();
   }
 
   // ApplicationTestBase:
   ApplicationDelegate* GetApplicationDelegate() override { return this; }
   void SetUp() override {
     ApplicationTestBase::SetUp();
+    client_factory_.reset(new ViewManagerClientFactory(application_impl()));
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From("mojo:view_manager");
     ApplicationConnection* vm_connection =
         application_impl()->ConnectToApplication(request.Pass());
     vm_connection->ConnectToService(&vm1_);
     vm_connection->ConnectToService(&view_manager_root_);
-    vm_connection->AddService(&client_factory_);
-    vm_client1_ = client_factory_.WaitForInstance();
+    vm_connection->AddService(client_factory_.get());
+    vm_client1_ = client_factory_->WaitForInstance();
     ASSERT_TRUE(vm_client1_);
     // Next we should get an embed call on the "window manager" client.
     vm_client1_->WaitForIncomingMethodCall();
     ASSERT_EQ(1u, changes1()->size());
     EXPECT_EQ(CHANGE_TYPE_EMBED, (*changes1())[0].type);
     // All these tests assume 1 for the client id. The only real assertion here
     // is the client id is not zero, but adding this as rest of code here
     // assumes 1.
     ASSERT_EQ(1, (*changes1())[0].connection_id);
     changes1()->clear();
   }
 
   // ApplicationDelegate implementation.
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
-    connection->AddService(&client_factory_);
+    connection->AddService(client_factory_.get());
     return true;
   }
 
   scoped_ptr<ViewManagerClientImpl> vm_client1_;
   scoped_ptr<ViewManagerClientImpl> vm_client2_;
   scoped_ptr<ViewManagerClientImpl> vm_client3_;
 
   mojo::ViewManagerRootPtr view_manager_root_;
 
  private:
   mojo::ViewManagerServicePtr vm1_;
-  ViewManagerClientFactory client_factory_;
+  scoped_ptr<ViewManagerClientFactory> client_factory_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ViewManagerServiceAppTest);
 };
 
 // Verifies two clients/connections get different ids.
 TEST_F(ViewManagerServiceAppTest, TwoClientsGetDifferentConnectionIds) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   // It isn't strictly necessary that the second connection gets 2, but these
   // tests are written assuming that is the case. The key thing is the
@@ skipping 679 matching lines @@
     vm_client1_->WaitForChangeCount(1);
     EXPECT_EQ("HierarchyChanged view=3,1 new_parent=1,1 old_parent=null",
               SingleChangeToDescription(*changes1()));
   }
 
   // Embed 1,1 again.
   {
     changes3()->clear();
 
     // We should get a new connection for the new embedding.
-    scoped_ptr<ViewManagerClientImpl> connection4(
-        EstablishConnectionViaEmbed(vm1(), BuildViewId(1, 1)));
+    scoped_ptr<ViewManagerClientImpl> connection4(EstablishConnectionViaEmbed(
+        vm1(), BuildViewId(1, 1), EmbedType::NO_REEMBED));
     ASSERT_TRUE(connection4.get());
     EXPECT_EQ("[view=1,1 parent=null]",
               ChangeViewDescription(*connection4->tracker()->changes()));
 
     // And 3 should get a delete.
     vm_client3_->WaitForChangeCount(1);
     EXPECT_EQ("ViewDeleted view=1,1", SingleChangeToDescription(*changes3()));
   }
 
   // vm3() has no root. Verify it can't see view 1,1 anymore.
@@ skipping 332 matching lines @@
   views.clear();
 
   GetViewTree(vm2(), BuildViewId(1, 1), &views);
   EXPECT_FALSE(HasClonedView(views));
 }
 
 // Verifies Embed() works when supplying a ViewManagerClient.
 TEST_F(ViewManagerServiceAppTest, EmbedSupplyingViewManagerClient) {
   ASSERT_TRUE(CreateView(vm1(), BuildViewId(1, 1)));
 
-  ViewManagerClientImpl client2;
+  ViewManagerClientImpl client2(application_impl());
   mojo::ViewManagerClientPtr client2_ptr;
   mojo::Binding<ViewManagerClient> client2_binding(&client2, &client2_ptr);
   ASSERT_TRUE(Embed(vm1(), BuildViewId(1, 1), client2_ptr.Pass()));
   client2.WaitForOnEmbed();
-  EXPECT_EQ("OnEmbed creator=" + application_impl()->url(),
+  EXPECT_EQ("OnEmbed",
             SingleChangeToDescription(*client2.tracker()->changes()));
 }
 
 // TODO(msw|sky): Fails on Android; see http://crbug.com/497920
 #if defined(OS_ANDROID)
 #define MAYBE_OnWillEmbed DISABLED_OnWillEmbed
 #else
 #define MAYBE_OnWillEmbed OnWillEmbed
 #endif
 TEST_F(ViewManagerServiceAppTest, MAYBE_OnWillEmbed) {
   // Create connections 2 and 3, marking 2 as an embed root.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   ASSERT_TRUE(AddView(vm1(), BuildViewId(0, 1), BuildViewId(1, 1)));
   ASSERT_TRUE(CreateView(vm2(), BuildViewId(2, 2)));
   ASSERT_TRUE(AddView(vm2(), BuildViewId(1, 1), BuildViewId(2, 2)));
   ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(vm2(), BuildViewId(2, 2)));
   ASSERT_TRUE(CreateView(vm3(), BuildViewId(3, 3)));
   ASSERT_TRUE(AddView(vm3(), BuildViewId(2, 2), BuildViewId(3, 3)));
   vm2()->SetEmbedRoot();
   // Make sure the viewmanager processed the SetEmbedRoot() call.
   ASSERT_TRUE(WaitForAllMessages(vm2()));
   changes2()->clear();
 
   // Embed 4 into 3, connection 2 should get the OnWillEmbed.
-  scoped_ptr<ViewManagerClientImpl> connection4(
-      EstablishConnectionViaEmbed(vm3(), BuildViewId(3, 3)));
+  scoped_ptr<ViewManagerClientImpl> connection4(EstablishConnectionViaEmbed(
+      vm3(), BuildViewId(3, 3), EmbedType::ALLOW_REEMBED));
   ASSERT_TRUE(connection4.get());
-  EXPECT_EQ("OnWillEmbed view=3,3", SingleChangeToDescription(*changes2()));
+  EXPECT_EQ("OnEmbedForDescendant view=3,3",
+            SingleChangeToDescription(*changes2()));
 
   // Mark 3 as an embed root.
   vm3()->SetEmbedRoot();
   // Make sure the viewmanager processed the SetEmbedRoot() call.
   ASSERT_TRUE(WaitForAllMessages(vm3()));
   changes2()->clear();
   changes3()->clear();
 
   // Embed 5 into 4. Only 3 should get the will embed.
   ASSERT_TRUE(CreateView(connection4->service(), BuildViewId(4, 4)));
   ASSERT_TRUE(
       AddView(connection4->service(), BuildViewId(3, 3), BuildViewId(4, 4)));
-  scoped_ptr<ViewManagerClientImpl> connection5(
-      EstablishConnectionViaEmbed(connection4->service(), BuildViewId(4, 4)));
+  scoped_ptr<ViewManagerClientImpl> connection5(EstablishConnectionViaEmbed(
+      connection4->service(), BuildViewId(4, 4), EmbedType::ALLOW_REEMBED));
   ASSERT_TRUE(connection5.get());
-  EXPECT_EQ("OnWillEmbed view=4,4", SingleChangeToDescription(*changes3()));
+  EXPECT_EQ("OnEmbedForDescendant view=4,4",
+            SingleChangeToDescription(*changes3()));
   ASSERT_TRUE(changes2()->empty());
 }
 
 // TODO(sky): need to better track changes to initial connection. For example,
 // that SetBounsdViews/AddView and the like don't result in messages to the
 // originating connection.
 
 // TODO(sky): make sure coverage of what was
 // ViewManagerTest.SecondEmbedRoot_InitService and
 // ViewManagerTest.MultipleEmbedRootsBeforeWTHReady gets added to window manager
 // tests.
 
 }  // namespace view_manager