Mandoline UI Process: Update namespaces and file names

components/mus/view_tree_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 "base/strings/stringprintf.h"
 #include "components/mus/ids.h"
 #include "components/mus/public/interfaces/view_tree.mojom.h"
 #include "components/mus/public/interfaces/view_tree_host.mojom.h"
 #include "components/mus/test_change_tracker.h"
 #include "mojo/application/public/cpp/application_delegate.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/application_test_base.h"
 
 using mojo::ApplicationConnection;
 using mojo::ApplicationDelegate;
 using mojo::Array;
 using mojo::Callback;
-using mojo::ConnectionSpecificId;
 using mojo::ERROR_CODE_NONE;
 using mojo::ErrorCode;
 using mojo::EventPtr;
-using mojo::Id;
 using mojo::InterfaceRequest;
 using mojo::ORDER_DIRECTION_ABOVE;
 using mojo::ORDER_DIRECTION_BELOW;
 using mojo::OrderDirection;
 using mojo::RectPtr;
 using mojo::ServiceProvider;
 using mojo::ServiceProviderPtr;
 using mojo::String;
 using mojo::ViewDataPtr;
 using mojo::ViewTree;
 using mojo::ViewTreeClient;
 using mojo::ViewportMetricsPtr;
 
-namespace view_manager {
+namespace mus {
+
+namespace {
 
 // 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 function from ViewTree functions. ----------------------------------
 
 void BoolResultCallback(base::RunLoop* run_loop,
@@ skipping 159 matching lines @@
   ErrorCode result = ERROR_CODE_NONE;
   base::RunLoop run_loop;
   vm->CreateView(ViewIdToTransportId(InvalidViewId()),
                  base::Bind(&ErrorCodeResultCallback, &run_loop, &result));
   run_loop.Run();
   return result != ERROR_CODE_NONE;
 }
 
 const Id kNullParentId = 0;
 std::string IdToString(Id id) {
-  return (id == kNullParentId)
-             ? "null"
-             : base::StringPrintf("%d,%d", mojo::HiWord(id), mojo::LoWord(id));
+  return (id == kNullParentId) ? "null" : base::StringPrintf(
+                                              "%d,%d", HiWord(id), LoWord(id));
 }
 
 std::string ViewParentToString(Id view, Id parent) {
   return base::StringPrintf("view=%s parent=%s", IdToString(view).c_str(),
                             IdToString(parent).c_str());
 }
 
 // -----------------------------------------------------------------------------
 
 // A ViewTreeClient implementation that logs all changes to a tracker.
-class ViewTreeClientImpl : public mojo::ViewTreeClient,
-                           public TestChangeTracker::Delegate {
+class TestViewTreeClientImpl : public mojo::ViewTreeClient,
+                               public TestChangeTracker::Delegate {
  public:
-  explicit ViewTreeClientImpl(mojo::ApplicationImpl* app)
+  explicit TestViewTreeClientImpl(mojo::ApplicationImpl* app)
       : binding_(this), app_(app), connection_id_(0), root_view_id_(0) {
     tracker_.set_delegate(this);
   }
 
   void Bind(mojo::InterfaceRequest<mojo::ViewTreeClient> request) {
     binding_.Bind(request.Pass());
   }
 
   mojo::ViewTree* tree() { return tree_.get(); }
   TestChangeTracker* tracker() { return &tracker_; }
@@ skipping 51 matching lines @@
     if (wait_state_.get() &&
         wait_state_->change_count == tracker_.changes()->size()) {
       wait_state_->run_loop.Quit();
     }
   }
 
   // ViewTreeClient:
   void OnEmbed(ConnectionSpecificId connection_id,
                ViewDataPtr root,
                mojo::ViewTreePtr tree,
-               mojo::Id focused_view_id,
+               Id focused_view_id,
                uint32_t access_policy) override {
     // TODO(sky): add coverage of |focused_view_id|.
     tree_ = tree.Pass();
     connection_id_ = connection_id;
     tracker()->OnEmbed(connection_id, root.Pass());
     if (embed_run_loop_)
       embed_run_loop_->Quit();
   }
   void OnEmbeddedAppDisconnected(Id view_id) override {
     tracker()->OnEmbeddedAppDisconnected(view_id);
@@ skipping 57 matching lines @@
 
   // If non-null we're waiting for a certain number of change notifications to
   // be encountered.
   scoped_ptr<WaitState> wait_state_;
 
   mojo::Binding<ViewTreeClient> binding_;
   mojo::ApplicationImpl* app_;
   Id connection_id_;
   Id root_view_id_;
 
-  DISALLOW_COPY_AND_ASSIGN(ViewTreeClientImpl);
+  DISALLOW_COPY_AND_ASSIGN(TestViewTreeClientImpl);
 };
 
 // -----------------------------------------------------------------------------
 
-// InterfaceFactory for vending ViewTreeClientImpls.
+// InterfaceFactory for vending TestViewTreeClientImpls.
 class ViewTreeClientFactory : public mojo::InterfaceFactory<ViewTreeClient> {
  public:
   explicit ViewTreeClientFactory(mojo::ApplicationImpl* app) : app_(app) {}
   ~ViewTreeClientFactory() override {}
 
   // Runs a nested MessageLoop until a new instance has been created.
-  scoped_ptr<ViewTreeClientImpl> WaitForInstance() {
+  scoped_ptr<TestViewTreeClientImpl> 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<ViewTreeClient>:
   void Create(ApplicationConnection* connection,
               InterfaceRequest<ViewTreeClient> request) override {
-    client_impl_.reset(new ViewTreeClientImpl(app_));
+    client_impl_.reset(new TestViewTreeClientImpl(app_));
     client_impl_->Bind(request.Pass());
     if (run_loop_.get())
       run_loop_->Quit();
   }
 
   mojo::ApplicationImpl* app_;
-  scoped_ptr<ViewTreeClientImpl> client_impl_;
+  scoped_ptr<TestViewTreeClientImpl> client_impl_;
   scoped_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewTreeClientFactory);
 };
 
+}  // namespace
+
 class ViewTreeAppTest : public mojo::test::ApplicationTestBase,
                         public ApplicationDelegate {
  public:
   ViewTreeAppTest()
       : connection_id_1_(0), connection_id_2_(0), root_view_id_(0) {}
   ~ViewTreeAppTest() override {}
 
  protected:
   // 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).
   ViewTree* vm1() { return vm_client1_->tree(); }
   ViewTree* vm2() { return vm_client2_->tree(); }
   ViewTree* vm3() { return vm_client3_->tree(); }
 
-  ViewTreeClientImpl* vm_client1() { return vm_client1_.get(); }
-  ViewTreeClientImpl* vm_client2() { return vm_client2_.get(); }
-  ViewTreeClientImpl* vm_client3() { return vm_client3_.get(); }
+  TestViewTreeClientImpl* vm_client1() { return vm_client1_.get(); }
+  TestViewTreeClientImpl* vm_client2() { return vm_client2_.get(); }
+  TestViewTreeClientImpl* vm_client3() { return vm_client3_.get(); }
 
   Id root_view_id() const { return root_view_id_; }
 
   int connection_id_1() const { return connection_id_1_; }
   int connection_id_2() const { return connection_id_2_; }
 
   void EstablishSecondConnectionWithRoot(Id root_id) {
     ASSERT_TRUE(vm_client2_.get() == nullptr);
     vm_client2_ =
         EstablishConnectionViaEmbed(vm1(), root_id, &connection_id_2_);
@@ skipping 17 matching lines @@
     }
   }
 
   void EstablishThirdConnection(ViewTree* owner, Id root_id) {
     ASSERT_TRUE(vm_client3_.get() == nullptr);
     vm_client3_ = EstablishConnectionViaEmbed(owner, root_id, nullptr);
     ASSERT_TRUE(vm_client3_.get() != nullptr);
     vm_client3_->set_root_view(root_view_id_);
   }
 
-  scoped_ptr<ViewTreeClientImpl> WaitForViewTreeClient() {
+  scoped_ptr<TestViewTreeClientImpl> WaitForViewTreeClient() {
     return client_factory_->WaitForInstance();
   }
 
   // Establishes a new connection by way of Embed() on the specified
   // ViewTree.
-  scoped_ptr<ViewTreeClientImpl>
+  scoped_ptr<TestViewTreeClientImpl>
   EstablishConnectionViaEmbed(ViewTree* owner, Id root_id, int* connection_id) {
     return EstablishConnectionViaEmbedWithPolicyBitmask(
         owner, root_id, mojo::ViewTree::ACCESS_POLICY_DEFAULT, connection_id);
   }
 
-  scoped_ptr<ViewTreeClientImpl> EstablishConnectionViaEmbedWithPolicyBitmask(
-      ViewTree* owner,
-      Id root_id,
-      uint32_t policy_bitmask,
-      int* connection_id) {
+  scoped_ptr<TestViewTreeClientImpl>
+  EstablishConnectionViaEmbedWithPolicyBitmask(ViewTree* owner,
+                                               Id root_id,
+                                               uint32_t policy_bitmask,
+                                               int* connection_id) {
     if (!EmbedUrl(application_impl(), owner, application_impl()->url(),
                   root_id)) {
       ADD_FAILURE() << "Embed() failed";
       return nullptr;
     }
-    scoped_ptr<ViewTreeClientImpl> client = client_factory_->WaitForInstance();
+    scoped_ptr<TestViewTreeClientImpl> client =
+        client_factory_->WaitForInstance();
     if (!client.get()) {
       ADD_FAILURE() << "WaitForInstance failed";
       return nullptr;
     }
     client->WaitForOnEmbed();
 
     EXPECT_EQ("OnEmbed",
               SingleChangeToDescription(*client->tracker()->changes()));
     if (connection_id)
       *connection_id = (*client->tracker()->changes())[0].connection_id;
     return client.Pass();
   }
 
   // ApplicationTestBase:
   ApplicationDelegate* GetApplicationDelegate() override { return this; }
   void SetUp() override {
     ApplicationTestBase::SetUp();
     client_factory_.reset(new ViewTreeClientFactory(application_impl()));
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From("mojo:mus");
 
     mojo::ViewTreeHostFactoryPtr factory;
     application_impl()->ConnectToService(request.Pass(), &factory);
 
     mojo::ViewTreeClientPtr tree_client_ptr;
-    vm_client1_.reset(new ViewTreeClientImpl(application_impl()));
+    vm_client1_.reset(new TestViewTreeClientImpl(application_impl()));
     vm_client1_->Bind(GetProxy(&tree_client_ptr));
 
     factory->CreateViewTreeHost(GetProxy(&host_), mojo::ViewTreeHostClientPtr(),
                                 tree_client_ptr.Pass());
 
     // 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_GT((*changes1())[0].connection_id, 0);
     connection_id_1_ = (*changes1())[0].connection_id;
     ASSERT_FALSE((*changes1())[0].views.empty());
     root_view_id_ = (*changes1())[0].views[0].view_id;
     vm_client1_->set_root_view(root_view_id_);
     changes1()->clear();
   }
 
   // ApplicationDelegate implementation.
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     connection->AddService(client_factory_.get());
     return true;
   }
 
-  scoped_ptr<ViewTreeClientImpl> vm_client1_;
-  scoped_ptr<ViewTreeClientImpl> vm_client2_;
-  scoped_ptr<ViewTreeClientImpl> vm_client3_;
+  scoped_ptr<TestViewTreeClientImpl> vm_client1_;
+  scoped_ptr<TestViewTreeClientImpl> vm_client2_;
+  scoped_ptr<TestViewTreeClientImpl> vm_client3_;
 
   mojo::ViewTreeHostPtr host_;
 
  private:
   scoped_ptr<ViewTreeClientFactory> client_factory_;
   int connection_id_1_;
   int connection_id_2_;
   Id root_view_id_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ViewTreeAppTest);
@@ skipping 686 matching lines @@
     EXPECT_EQ("HierarchyChanged view=" + IdToString(view_3_1) + " new_parent=" +
                   IdToString(view_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<ViewTreeClientImpl> connection4(
+    scoped_ptr<TestViewTreeClientImpl> connection4(
         EstablishConnectionViaEmbed(vm1(), view_1_1, nullptr));
     ASSERT_TRUE(connection4.get());
     EXPECT_EQ("[" + ViewParentToString(view_1_1, kNullParentId) + "]",
               ChangeViewDescription(*connection4->tracker()->changes()));
 
     // And 3 should get an unembed and delete.
     vm_client3_->WaitForChangeCount(2);
     EXPECT_EQ("OnUnembed", ChangesToDescription1(*changes3())[0]);
     EXPECT_EQ("ViewDeleted view=" + IdToString(view_1_1),
               ChangesToDescription1(*changes3())[1]);
@@ skipping 300 matching lines @@
             SingleChangeToDescription(*changes1()));
   std::vector<TestView> views;
   GetViewTree(vm1(), view_1_1, &views);
   EXPECT_FALSE(views.empty());
 }
 
 // Verifies Embed() works when supplying a ViewTreeClient.
 TEST_F(ViewTreeAppTest, EmbedSupplyingViewTreeClient) {
   ASSERT_TRUE(vm_client1()->CreateView(1));
 
-  ViewTreeClientImpl client2(application_impl());
+  TestViewTreeClientImpl client2(application_impl());
   mojo::ViewTreeClientPtr client2_ptr;
   mojo::Binding<ViewTreeClient> client2_binding(&client2, &client2_ptr);
   ASSERT_TRUE(
       Embed(vm1(), BuildViewId(connection_id_1(), 1), client2_ptr.Pass()));
   client2.WaitForOnEmbed();
   EXPECT_EQ("OnEmbed",
             SingleChangeToDescription(*client2.tracker()->changes()));
 }
 
 TEST_F(ViewTreeAppTest, EmbedFailsFromOtherConnection) {
@@ skipping 67 matching lines @@
 
 // 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
+}  // namespace mus