Mandoline UI Process: Update namespaces and file names

components/mus/mus_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 "base/bind.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
-#include "components/mus/public/cpp/tests/view_manager_test_base.h"
+#include "components/mus/public/cpp/tests/mandoline_ui_services_test_base.h"
 #include "components/mus/public/cpp/util.h"
 #include "components/mus/public/cpp/view_observer.h"
 #include "components/mus/public/cpp/view_tree_connection.h"
 #include "components/mus/public/cpp/view_tree_delegate.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/application_test_base.h"
 #include "ui/mojo/geometry/geometry_util.h"
 
-namespace mojo {
+namespace mus {
 
 namespace {
 
 class BoundsChangeObserver : public ViewObserver {
  public:
   explicit BoundsChangeObserver(View* view) : view_(view) {
     view_->AddObserver(this);
   }
   ~BoundsChangeObserver() override { view_->RemoveObserver(this); }
 
  private:
   // Overridden from ViewObserver:
   void OnViewBoundsChanged(View* view,
-                           const Rect& old_bounds,
-                           const Rect& new_bounds) override {
+                           const mojo::Rect& old_bounds,
+                           const mojo::Rect& new_bounds) override {
     DCHECK_EQ(view, view_);
-    EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop());
+    EXPECT_TRUE(MandolineUIServicesTestBase::QuitRunLoop());
   }
 
   View* view_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(BoundsChangeObserver);
 };
 
 // Wait until the bounds of the supplied view change; returns false on timeout.
 bool WaitForBoundsToChange(View* view) {
   BoundsChangeObserver observer(view);
-  return ViewManagerTestBase::DoRunLoopWithTimeout();
+  return MandolineUIServicesTestBase::DoRunLoopWithTimeout();
 }
 
 // Spins a run loop until the tree beginning at |root| has |tree_size| views
 // (including |root|).
 class TreeSizeMatchesObserver : public ViewObserver {
  public:
   TreeSizeMatchesObserver(View* tree, size_t tree_size)
       : tree_(tree), tree_size_(tree_size) {
     tree_->AddObserver(this);
   }
   ~TreeSizeMatchesObserver() override { tree_->RemoveObserver(this); }
 
   bool IsTreeCorrectSize() { return CountViews(tree_) == tree_size_; }
 
  private:
   // Overridden from ViewObserver:
   void OnTreeChanged(const TreeChangeParams& params) override {
     if (IsTreeCorrectSize())
-      EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop());
+      EXPECT_TRUE(MandolineUIServicesTestBase::QuitRunLoop());
   }
 
   size_t CountViews(const View* view) const {
     size_t count = 1;
     View::Children::const_iterator it = view->children().begin();
     for (; it != view->children().end(); ++it)
       count += CountViews(*it);
     return count;
   }
 
   View* tree_;
   size_t tree_size_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TreeSizeMatchesObserver);
 };
 
 // Wait until |view| has |tree_size| descendants; returns false on timeout. The
 // count includes |view|. For example, if you want to wait for |view| to have
 // a single child, use a |tree_size| of 2.
 bool WaitForTreeSizeToMatch(View* view, size_t tree_size) {
   TreeSizeMatchesObserver observer(view, tree_size);
   return observer.IsTreeCorrectSize() ||
-         ViewManagerTestBase::DoRunLoopWithTimeout();
+         MandolineUIServicesTestBase::DoRunLoopWithTimeout();
 }
 
 class OrderChangeObserver : public ViewObserver {
  public:
   OrderChangeObserver(View* view) : view_(view) { view_->AddObserver(this); }
   ~OrderChangeObserver() override { view_->RemoveObserver(this); }
 
  private:
   // Overridden from ViewObserver:
   void OnViewReordered(View* view,
                        View* relative_view,
-                       OrderDirection direction) override {
+                       mojo::OrderDirection direction) override {
     DCHECK_EQ(view, view_);
-    EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop());
+    EXPECT_TRUE(MandolineUIServicesTestBase::QuitRunLoop());
   }
 
   View* view_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver);
 };
 
 // Wait until |view|'s tree size matches |tree_size|; returns false on timeout.
 bool WaitForOrderChange(ViewTreeConnection* connection, View* view) {
   OrderChangeObserver observer(view);
-  return ViewManagerTestBase::DoRunLoopWithTimeout();
+  return MandolineUIServicesTestBase::DoRunLoopWithTimeout();
 }
 
 // Tracks a view's destruction. Query is_valid() for current state.
 class ViewTracker : public ViewObserver {
  public:
   explicit ViewTracker(View* view) : view_(view) { view_->AddObserver(this); }
   ~ViewTracker() override {
     if (view_)
       view_->RemoveObserver(this);
   }
@@ skipping 25 matching lines @@
 
   // The id supplied to the callback from OnEmbed(). Depending upon the
   // access policy this may or may not match the connection id of
   // |connection|.
   ConnectionSpecificId connection_id;
 };
 
 // These tests model synchronization of two peer connections to the view manager
 // service, that are given access to some root view.
 
-class ViewManagerTest : public ViewManagerTestBase {
+class ViewManagerTest : public MandolineUIServicesTestBase {
  public:
   ViewManagerTest() {}
 
   // 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.
   EmbedResult Embed(View* view) {
     DCHECK(!embed_details_);
     embed_details_.reset(new EmbedDetails);
     view->Embed(ConnectToApplicationAndGetViewManagerClient(),
                 base::Bind(&ViewManagerTest::EmbedCallbackImpl,
                            base::Unretained(this)));
     embed_details_->waiting = true;
-    if (!ViewManagerTestBase::DoRunLoopWithTimeout())
+    if (!MandolineUIServicesTestBase::DoRunLoopWithTimeout())
       return EmbedResult();
     const EmbedResult result(embed_details_->connection,
                              embed_details_->connection_id);
     embed_details_.reset();
     return result;
   }
 
   // Establishes a connection to this application and asks for a
   // ViewTreeClient.
   mojo::ViewTreeClientPtr ConnectToApplicationAndGetViewManagerClient() {
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From(application_impl()->url());
-    scoped_ptr<ApplicationConnection> connection =
+    scoped_ptr<mojo::ApplicationConnection> connection =
         application_impl()->ConnectToApplication(request.Pass());
     mojo::ViewTreeClientPtr client;
     connection->ConnectToService(&client);
     return client.Pass();
   }
 
-  // ViewManagerTestBase:
+  // MandolineUIServicesTestBase:
   void OnEmbed(View* root) override {
     if (!embed_details_) {
-      ViewManagerTestBase::OnEmbed(root);
+      MandolineUIServicesTestBase::OnEmbed(root);
       return;
     }
 
     embed_details_->connection = root->connection();
     if (embed_details_->callback_run)
-      EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop());
+      EXPECT_TRUE(MandolineUIServicesTestBase::QuitRunLoop());
   }
 
  private:
   // Used to track the state of a call to view->Embed().
   struct EmbedDetails {
     EmbedDetails()
         : callback_run(false),
           result(false),
           waiting(false),
           connection_id(0),
@@ skipping 14 matching lines @@
     // The ViewTreeConnection that resulted from the Embed(). null if |result|
     // is false.
     ViewTreeConnection* connection;
   };
 
   void EmbedCallbackImpl(bool result, ConnectionSpecificId connection_id) {
     embed_details_->callback_run = true;
     embed_details_->result = result;
     embed_details_->connection_id = connection_id;
     if (embed_details_->waiting && (!result || embed_details_->connection))
-      EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop());
+      EXPECT_TRUE(MandolineUIServicesTestBase::QuitRunLoop());
   }
 
   scoped_ptr<EmbedDetails> embed_details_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ViewManagerTest);
 };
 
 TEST_F(ViewManagerTest, RootView) {
   ASSERT_NE(nullptr, window_manager());
   EXPECT_NE(nullptr, window_manager()->GetRoot());
@@ skipping 51 matching lines @@
 TEST_F(ViewManagerTest, SetBounds) {
   View* view = window_manager()->CreateView();
   view->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view);
   ViewTreeConnection* embedded = Embed(view).connection;
   ASSERT_NE(nullptr, embedded);
 
   View* view_in_embedded = embedded->GetViewById(view->id());
   EXPECT_EQ(view->bounds(), view_in_embedded->bounds());
 
-  Rect rect;
+  mojo::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);
   ViewTreeConnection* embedded = Embed(view).connection;
   ASSERT_NE(nullptr, embedded);
 
   View* view_in_embedded = embedded->GetViewById(view->id());
-  Rect rect;
+  mojo::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());
@@ skipping 81 matching lines @@
  public:
   explicit VisibilityChangeObserver(View* view) : view_(view) {
     view_->AddObserver(this);
   }
   ~VisibilityChangeObserver() override { view_->RemoveObserver(this); }
 
  private:
   // Overridden from ViewObserver:
   void OnViewVisibilityChanged(View* view) override {
     EXPECT_EQ(view, view_);
-    EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop());
+    EXPECT_TRUE(MandolineUIServicesTestBase::QuitRunLoop());
   }
 
   View* view_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(VisibilityChangeObserver);
 };
 
 }  // 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.
   ViewTreeConnection* embedded = Embed(view1).connection;
   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);
     view1->SetVisible(false);
-    ASSERT_TRUE(ViewManagerTestBase::DoRunLoopWithTimeout());
+    ASSERT_TRUE(MandolineUIServicesTestBase::DoRunLoopWithTimeout());
   }
 
   EXPECT_FALSE(view1->visible());
   EXPECT_FALSE(view1->IsDrawn());
 
   EXPECT_FALSE(embedded_root->visible());
   EXPECT_FALSE(embedded_root->IsDrawn());
 
   // Make the node visible again.
   {
     VisibilityChangeObserver observer(embedded_root);
     view1->SetVisible(true);
-    ASSERT_TRUE(ViewManagerTestBase::DoRunLoopWithTimeout());
+    ASSERT_TRUE(MandolineUIServicesTestBase::DoRunLoopWithTimeout());
   }
 
   EXPECT_TRUE(view1->visible());
   EXPECT_TRUE(view1->IsDrawn());
 
   EXPECT_TRUE(embedded_root->visible());
   EXPECT_TRUE(embedded_root->IsDrawn());
 }
 
 namespace {
 
 class DrawnChangeObserver : public ViewObserver {
  public:
   explicit DrawnChangeObserver(View* view) : view_(view) {
     view_->AddObserver(this);
   }
   ~DrawnChangeObserver() override { view_->RemoveObserver(this); }
 
  private:
   // Overridden from ViewObserver:
   void OnViewDrawnChanged(View* view) override {
     EXPECT_EQ(view, view_);
-    EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop());
+    EXPECT_TRUE(MandolineUIServicesTestBase::QuitRunLoop());
   }
 
   View* view_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(DrawnChangeObserver);
 };
 
 }  // namespace
 
 TEST_F(ViewManagerTest, Drawn) {
@@ skipping 41 matching lines @@
 
   View* last_lost_focus() { return last_lost_focus_; }
 
  private:
   // Overridden from ViewObserver.
   void OnViewFocusChanged(View* gained_focus, View* lost_focus) override {
     EXPECT_TRUE(!gained_focus || gained_focus->HasFocus());
     EXPECT_FALSE(lost_focus && lost_focus->HasFocus());
     last_gained_focus_ = gained_focus;
     last_lost_focus_ = lost_focus;
-    EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop());
+    EXPECT_TRUE(MandolineUIServicesTestBase::QuitRunLoop());
   }
 
   View* view_;
   View* last_gained_focus_;
   View* last_lost_focus_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(FocusChangeObserver);
 };
 
 }  // namespace
@@ skipping 38 matching lines @@
     ASSERT_NE(nullptr, observer.last_lost_focus());
     EXPECT_EQ(view11->id(), observer.last_lost_focus()->id());
     EXPECT_EQ(embedded->GetRoot()->id(), observer.last_gained_focus()->id());
   }
 }
 
 namespace {
 
 class DestroyedChangedObserver : public ViewObserver {
  public:
-  DestroyedChangedObserver(ViewManagerTestBase* test,
+  DestroyedChangedObserver(MandolineUIServicesTestBase* test,
                            View* view,
                            bool* got_destroy)
       : test_(test), view_(view), got_destroy_(got_destroy) {
     view_->AddObserver(this);
   }
   ~DestroyedChangedObserver() override {
     if (view_)
       view_->RemoveObserver(this);
   }
 
  private:
   // Overridden from ViewObserver:
   void OnViewDestroyed(View* view) override {
     EXPECT_EQ(view, view_);
     view_->RemoveObserver(this);
     *got_destroy_ = true;
     view_ = nullptr;
 
     // We should always get OnViewDestroyed() before OnConnectionLost().
     EXPECT_FALSE(test_->view_tree_connection_destroyed());
   }
 
-  ViewManagerTestBase* test_;
+  MandolineUIServicesTestBase* test_;
   View* view_;
   bool* got_destroy_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(DestroyedChangedObserver);
 };
 
 }  // namespace
 
 // Verifies deleting a ViewManager sends the right notifications.
 TEST_F(ViewManagerTest, DeleteViewManager) {
@@ skipping 66 matching lines @@
   // 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());
 }
 
 namespace {
 
 class DestroyObserver : public ViewObserver {
  public:
-  DestroyObserver(ViewManagerTestBase* test,
+  DestroyObserver(MandolineUIServicesTestBase* test,
                   ViewTreeConnection* connection,
                   bool* got_destroy)
       : test_(test), got_destroy_(got_destroy) {
     connection->GetRoot()->AddObserver(this);
   }
   ~DestroyObserver() override {}
 
  private:
   // Overridden from ViewObserver:
   void OnViewDestroyed(View* view) override {
     *got_destroy_ = true;
     view->RemoveObserver(this);
 
     // We should always get OnViewDestroyed() before OnViewManagerDestroyed().
     EXPECT_FALSE(test_->view_tree_connection_destroyed());
 
-    EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop());
+    EXPECT_TRUE(MandolineUIServicesTestBase::QuitRunLoop());
   }
 
-  ViewManagerTestBase* test_;
+  MandolineUIServicesTestBase* test_;
   bool* got_destroy_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(DestroyObserver);
 };
 
 }  // namespace
 
 // Verifies deleting a View that is the root of another connection notifies
 // observers in the right order (OnViewDestroyed() before
 // OnViewManagerDestroyed()).
@@ skipping 11 matching lines @@
   EXPECT_TRUE(DoRunLoopWithTimeout());
   EXPECT_TRUE(got_destroy);
 }
 
 // Verifies an embed root sees views created beneath it from another
 // connection.
 TEST_F(ViewManagerTest, EmbedRootSeesHierarchyChanged) {
   View* embed_view = window_manager()->CreateView();
   window_manager()->GetRoot()->AddChild(embed_view);
 
-  embed_view->SetAccessPolicy(ViewTree::ACCESS_POLICY_EMBED_ROOT);
+  embed_view->SetAccessPolicy(mojo::ViewTree::ACCESS_POLICY_EMBED_ROOT);
   ViewTreeConnection* vm2 = Embed(embed_view).connection;
   View* vm2_v1 = vm2->CreateView();
   vm2->GetRoot()->AddChild(vm2_v1);
 
   ViewTreeConnection* vm3 = Embed(vm2_v1).connection;
   View* vm3_v1 = vm3->CreateView();
   vm3->GetRoot()->AddChild(vm3_v1);
 
   // As |vm2| is an embed root it should get notified about |vm3_v1|.
   ASSERT_TRUE(WaitForTreeSizeToMatch(vm2_v1, 2));
 }
 
 TEST_F(ViewManagerTest, EmbedFromEmbedRoot) {
   View* embed_view = window_manager()->CreateView();
   window_manager()->GetRoot()->AddChild(embed_view);
 
   // Give the connection embedded at |embed_view| embed root powers.
-  embed_view->SetAccessPolicy(ViewTree::ACCESS_POLICY_EMBED_ROOT);
+  embed_view->SetAccessPolicy(mojo::ViewTree::ACCESS_POLICY_EMBED_ROOT);
   const EmbedResult result1 = Embed(embed_view);
   ViewTreeConnection* vm2 = result1.connection;
   EXPECT_EQ(result1.connection_id, vm2->GetConnectionId());
   View* vm2_v1 = vm2->CreateView();
   vm2->GetRoot()->AddChild(vm2_v1);
 
   const EmbedResult result2 = Embed(vm2_v1);
   ViewTreeConnection* vm3 = result2.connection;
   EXPECT_EQ(result2.connection_id, vm3->GetConnectionId());
   View* vm3_v1 = vm3->CreateView();
@@ skipping 10 matching lines @@
 
   // Embed() from vm2 in vm3_v1. This is allowed as vm2 is an embed root, and
   // further the callback should see the connection id.
   ASSERT_EQ(1u, vm2_v1->children().size());
   View* vm3_v1_in_vm2 = vm2_v1->children()[0];
   const EmbedResult result4 = Embed(vm3_v1_in_vm2);
   ASSERT_TRUE(result4.connection);
   EXPECT_EQ(result4.connection_id, result4.connection->GetConnectionId());
 }
 
-}  // namespace mojo
+}  // namespace mus