Add EmbedRoot to ViewManagerService.

mojo/services/view_manager/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 <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 345 matching lines @@
                                   Id old_view_id) OVERRIDE {
     tracker_.OnNodeViewReplaced(node, new_view_id, old_view_id);
   }
   virtual void OnViewInputEvent(Id view_id,
                                 EventPtr event,
                                 const Callback<void()>& callback) OVERRIDE {
     tracker_.OnViewInputEvent(view_id, event.Pass());
   }
   virtual void OnFocusChanged(Id gained_focus_id,
                               Id lost_focus_id) OVERRIDE {}
-  virtual void EmbedRoot(const String& url) OVERRIDE {
-    tracker_.OnEmbedRoot(url);
+  virtual void Embed(const String& url) OVERRIDE {
+    tracker_.OnEmbed(url);
   }
   virtual void DispatchOnViewInputEvent(Id view_id,
                                         mojo::EventPtr event) OVERRIDE {
   }
 
  private:
   TestChangeTracker tracker_;
   ViewManagerProxy connection_;
 
   DISALLOW_COPY_AND_ASSIGN(TestViewManagerClientConnection);
@@ skipping 36 matching lines @@
                ConnectionSpecificId node_id) {
   return (connection_id << 16) | node_id;
 }
 
 // Creates an id used for transport from the specified parameters.
 Id BuildViewId(ConnectionSpecificId connection_id,
                ConnectionSpecificId view_id) {
   return (connection_id << 16) | view_id;
 }
 
-// Callback from EmbedRoot(). |result| is the result of the
+// Callback from Embed(). |result| is the result of the
 // Embed() call and |run_loop| the nested RunLoop.
-void EmbedRootCallback(bool* result_cache,
-                       base::RunLoop* run_loop,
-                       bool result) {
+void EmbedCallback(bool* result_cache, base::RunLoop* run_loop, bool result) {
   *result_cache = result;
   run_loop->Quit();
 }
 
-// Responsible for establishing the initial ViewManagerService connection.
+// Embed from an application that does not yet have a view manager connection.
 // Blocks until result is determined.
-bool EmbedRoot(ViewManagerInitService* view_manager_init,
-               const std::string& url) {
+bool InitEmbed(ViewManagerInitService* view_manager_init,
+               const std::string& url,
+               size_t number_of_calls) {
   bool result = false;
   base::RunLoop run_loop;
-  view_manager_init->EmbedRoot(url, base::Bind(&EmbedRootCallback,
-                                               &result, &run_loop));
+  for (size_t i = 0; i < number_of_calls; ++i) {
+    view_manager_init->Embed(url, base::Bind(&EmbedCallback,
+                                             &result, &run_loop));
+  }
   run_loop.Run();
   return result;
 }
 
 }  // namespace
 
 typedef std::vector<std::string> Changes;
 
 class ViewManagerTest : public testing::Test {
  public:
   ViewManagerTest() : connection_(NULL), connection2_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     test_helper_.Init();
 
     test_helper_.SetLoaderForURL(
         scoped_ptr<ServiceLoader>(new EmbedServiceLoader()),
         GURL(kTestServiceURL));
 
     test_helper_.SetLoaderForURL(
         scoped_ptr<ServiceLoader>(new EmbedServiceLoader()),
         GURL(kTestServiceURL2));
 
     test_helper_.service_manager()->ConnectToService(
         GURL("mojo:mojo_view_manager"),
         &view_manager_init_);
-    ASSERT_TRUE(EmbedRoot(view_manager_init_.get(), kTestServiceURL));
+    ASSERT_TRUE(InitEmbed(view_manager_init_.get(), kTestServiceURL, 1));
 
     connection_ = ViewManagerProxy::WaitForInstance();
     ASSERT_TRUE(connection_ != NULL);
     connection_->DoRunLoopUntilChangesCount(1);
   }
 
   virtual void TearDown() OVERRIDE {
     if (connection2_)
       connection2_->Destroy();
     if (connection_)
@@ skipping 35 matching lines @@
   shell::ShellTestHelper test_helper_;
 
   ViewManagerInitServicePtr view_manager_init_;
 
   ViewManagerProxy* connection_;
   ViewManagerProxy* connection2_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewManagerTest);
 };
 
-TEST_F(ViewManagerTest, SecondEmbedRoot) {
-  ASSERT_TRUE(EmbedRoot(view_manager_init_.get(), kTestServiceURL));
+TEST_F(ViewManagerTest, SecondEmbedRoot_InitService) {
+  ASSERT_TRUE(InitEmbed(view_manager_init_.get(), kTestServiceURL, 1));
   connection_->DoRunLoopUntilChangesCount(1);
   EXPECT_EQ(kTestServiceURL, connection_->changes()[0].embed_url);
 }
 
+TEST_F(ViewManagerTest, SecondEmbedRoot_Service) {
+  ASSERT_TRUE(connection_->Embed(BuildNodeId(0, 0), kTestServiceURL));
+  connection_->DoRunLoopUntilChangesCount(1);
+  EXPECT_EQ(kTestServiceURL, connection_->changes()[0].embed_url);
+}
+
+TEST_F(ViewManagerTest, MultipleEmbedRootsBeforeWTHReady) {
+  ASSERT_TRUE(InitEmbed(view_manager_init_.get(), kTestServiceURL, 2));
+  connection_->DoRunLoopUntilChangesCount(2);
+  EXPECT_EQ(kTestServiceURL, connection_->changes()[0].embed_url);
+  EXPECT_EQ(kTestServiceURL, connection_->changes()[1].embed_url);
+}
+
 // Verifies client gets a valid id.
 TEST_F(ViewManagerTest, ValidId) {
   // TODO(beng): this should really have the URL of the application that
   //             connected to ViewManagerInit.
   EXPECT_EQ("OnConnectionEstablished creator=",
             ChangesToDescription1(connection_->changes())[0]);
 
   // 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.
   EXPECT_EQ(1, connection_->changes()[0].connection_id);
@@ skipping 855 matching lines @@
 // originating connection.
 
 // TODO(beng): Add tests for focus:
 // - focus between two nodes known to a connection
 // - focus between nodes unknown to one of the connections.
 // - focus between nodes unknown to either connection.
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo