Renames view manager Connect methods to Embed

mojo/services/view_manager/view_manager_connection_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/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 119 matching lines @@
     RunMainLoop();
     return result;
   }
   void GetNodeTree(Id node_id, std::vector<TestNode>* nodes) {
     changes_.clear();
     view_manager_->GetNodeTree(node_id,
                                base::Bind(&ViewManagerProxy::GotNodeTree,
                                           base::Unretained(this), nodes));
     RunMainLoop();
   }
-  bool Connect(const std::vector<Id>& nodes) {
+  bool Embed(const std::vector<Id>& nodes) {
     changes_.clear();
-    base::AutoReset<bool> auto_reset(&in_connect_, true);
+    base::AutoReset<bool> auto_reset(&in_embed_, true);
     bool result = false;
-    view_manager_->Connect(kTestServiceURL, Array<Id>::From(nodes),
-                           base::Bind(&ViewManagerProxy::GotResult,
-                                      base::Unretained(this), &result));
+    view_manager_->Embed(kTestServiceURL, Array<Id>::From(nodes),
+                         base::Bind(&ViewManagerProxy::GotResult,
+                                    base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
   bool DeleteNode(Id node_id) {
     changes_.clear();
     bool result = false;
     view_manager_->DeleteNode(node_id,
                               base::Bind(&ViewManagerProxy::GotResult,
                                          base::Unretained(this), &result));
     RunMainLoop();
@@ skipping 42 matching lines @@
 
   void CopyChangesFromTracker() {
     std::vector<Change> changes;
     tracker_->changes()->swap(changes);
     changes_.swap(changes);
   }
 
   static void SetInstance(ViewManagerProxy* instance) {
     DCHECK(!instance_);
     instance_ = instance;
-    // Connect() runs its own run loop that is quit when the result is
-    // received. Connect() also results in a new instance. If we quit here while
-    // waiting for a Connect() we would prematurely return before we got the
-    // result from Connect().
-    if (!in_connect_ && main_run_loop_)
+    // Embed() runs its own run loop that is quit when the result is
+    // received. Embed() also results in a new instance. If we quit here while
+    // waiting for a Embed() we would prematurely return before we got the
+    // result from Embed().
+    if (!in_embed_ && main_run_loop_)
       main_run_loop_->Quit();
   }
 
   // Callbacks from the various IViewManager functions.
   void GotResult(bool* result_cache, bool result) {
     *result_cache = result;
     DCHECK(main_run_loop_);
     main_run_loop_->Quit();
   }
 
   void GotNodeTree(std::vector<TestNode>* nodes, Array<INodePtr> results) {
     INodesToTestNodes(results, nodes);
     DCHECK(main_run_loop_);
     main_run_loop_->Quit();
   }
 
   // TestChangeTracker::Delegate:
   virtual void OnChangeAdded() OVERRIDE {
     if (quit_count_ > 0 && --quit_count_ == 0)
       QuitCountReached();
   }
 
   static ViewManagerProxy* instance_;
   static base::RunLoop* main_run_loop_;
-  static bool in_connect_;
+  static bool in_embed_;
 
   TestChangeTracker* tracker_;
 
   // MessageLoop of the test.
   base::MessageLoop* main_loop_;
 
   IViewManager* view_manager_;
 
   // Number of changes we're waiting on until we quit the current loop.
   size_t quit_count_;
 
   std::vector<Change> changes_;
 
   mojo::internal::Router* router_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewManagerProxy);
 };
 
 // static
 ViewManagerProxy* ViewManagerProxy::instance_ = NULL;
 
 // static
 base::RunLoop* ViewManagerProxy::main_run_loop_ = NULL;
 
 // static
-bool ViewManagerProxy::in_connect_ = false;
+bool ViewManagerProxy::in_embed_ = false;
 
 class TestViewManagerClientConnection
     : public InterfaceImpl<IViewManagerClient> {
  public:
   TestViewManagerClientConnection() : connection_(&tracker_) {
     tracker_.set_delegate(&connection_);
   }
 
   // InterfaceImp:
   virtual void OnConnectionEstablished() OVERRIDE {
@@ skipping 46 matching lines @@
     tracker_.OnViewInputEvent(view_id, event.Pass());
   }
 
  private:
   TestChangeTracker tracker_;
   ViewManagerProxy connection_;
 
   DISALLOW_COPY_AND_ASSIGN(TestViewManagerClientConnection);
 };
 
-// Used with IViewManager::Connect(). Creates a TestViewManagerClientConnection,
+// Used with IViewManager::Embed(). Creates a TestViewManagerClientConnection,
 // which creates and owns the ViewManagerProxy.
-class ConnectServiceLoader : public ServiceLoader {
+class EmbedServiceLoader : public ServiceLoader {
  public:
-  ConnectServiceLoader() {}
-  virtual ~ConnectServiceLoader() {}
+  EmbedServiceLoader() {}
+  virtual ~EmbedServiceLoader() {}
 
   // ServiceLoader:
   virtual void LoadService(ServiceManager* manager,
                            const GURL& url,
                            ScopedMessagePipeHandle shell_handle) OVERRIDE {
     scoped_ptr<Application> app(new Application(shell_handle.Pass()));
     app->AddService<TestViewManagerClientConnection>();
     apps_.push_back(app.release());
   }
   virtual void OnServiceError(ServiceManager* manager,
                               const GURL& url) OVERRIDE {
   }
 
  private:
   ScopedVector<Application> apps_;
 
-  DISALLOW_COPY_AND_ASSIGN(ConnectServiceLoader);
+  DISALLOW_COPY_AND_ASSIGN(EmbedServiceLoader);
 };
 
 // Creates an id used for transport from the specified parameters.
 Id BuildNodeId(ConnectionSpecificId connection_id,
                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 ViewManagerInitConnect(). |result| is the result of the
-// Connect() call and |run_loop| the nested RunLoop.
-void ViewManagerInitConnectCallback(bool* result_cache,
-                                    base::RunLoop* run_loop,
-                                    bool result) {
+// Callback from EmbedRoot(). |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) {
   *result_cache = result;
   run_loop->Quit();
 }
 
-// Resposible for establishing  connection to the viewmanager. Blocks until get
-// back result.
-bool ViewManagerInitConnect(IViewManagerInit* view_manager_init,
-                            const std::string& url) {
+// Resposible for establishing the initial IViewManager connection. Blocks until
+// result is determined.
+bool EmbedRoot(IViewManagerInit* view_manager_init, const std::string& url) {
   bool result = false;
   base::RunLoop run_loop;
-  view_manager_init->Connect(url,
-                             base::Bind(&ViewManagerInitConnectCallback,
-                                        &result, &run_loop));
+  view_manager_init->EmbedRoot(url, base::Bind(&EmbedRootCallback,
+                                               &result, &run_loop));
   run_loop.Run();
   return result;
 }
 
 }  // namespace
 
 typedef std::vector<std::string> Changes;
 
 class ViewManagerConnectionTest : public testing::Test {
  public:
   ViewManagerConnectionTest() : connection_(NULL), connection2_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     test_helper_.Init();
 
     test_helper_.SetLoaderForURL(
-        scoped_ptr<ServiceLoader>(new ConnectServiceLoader()),
+        scoped_ptr<ServiceLoader>(new EmbedServiceLoader()),
         GURL(kTestServiceURL));
 
     ConnectToService(test_helper_.service_provider(),
                      "mojo:mojo_view_manager",
                      &view_manager_init_);
-    ASSERT_TRUE(ViewManagerInitConnect(view_manager_init_.get(),
-                                       kTestServiceURL));
+    ASSERT_TRUE(EmbedRoot(view_manager_init_.get(), kTestServiceURL));
 
     connection_ = ViewManagerProxy::WaitForInstance();
     ASSERT_TRUE(connection_ != NULL);
     connection_->DoRunLoopUntilChangesCount(1);
   }
 
   virtual void TearDown() OVERRIDE {
     if (connection2_)
       connection2_->Destroy();
     if (connection_)
       connection_->Destroy();
   }
 
  protected:
   void EstablishSecondConnectionWithRoots(Id id1, Id id2) {
     std::vector<Id> node_ids;
     node_ids.push_back(id1);
     if (id2 != 0)
       node_ids.push_back(id2);
-    ASSERT_TRUE(connection_->Connect(node_ids));
+    ASSERT_TRUE(connection_->Embed(node_ids));
     connection2_ = ViewManagerProxy::WaitForInstance();
     ASSERT_TRUE(connection2_ != NULL);
     connection2_->DoRunLoopUntilChangesCount(1);
     ASSERT_EQ(1u, connection2_->changes().size());
   }
 
   // Creates a second connection to the viewmanager.
   void EstablishSecondConnection(bool create_initial_node) {
     if (create_initial_node)
       ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
@@ skipping 759 matching lines @@
 TEST_F(ViewManagerConnectionTest, ConnectTwice) {
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Try to connect again to 1,1, this should fail as already connected to that
   // root.
   {
     std::vector<Id> node_ids;
     node_ids.push_back(BuildNodeId(1, 1));
-    ASSERT_FALSE(connection_->Connect(node_ids));
+    ASSERT_FALSE(connection_->Embed(node_ids));
   }
 
   // Connecting to 1,2 should succeed and end up in connection2.
   {
     std::vector<Id> node_ids;
     node_ids.push_back(BuildNodeId(1, 2));
-    ASSERT_TRUE(connection_->Connect(node_ids));
+    ASSERT_TRUE(connection_->Embed(node_ids));
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ("OnRootsAdded", changes[0]);
     EXPECT_EQ("[node=1,2 parent=null view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 }
 
 // TODO(sky): add coverage of test that destroys connections and ensures other
 // connections get deletion notification (or advanced server id).
 
 // TODO(sky): need to better track changes to initial connection. For example,
 // that SetBounsdNodes/AddNode and the like don't result in messages to the
 // originating connection.
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo