Mandoline UI Process: Update namespaces and file names

components/mus/public/cpp/tests/mandoline_ui_services_test_base.cc

 // Copyright 2015 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 "components/mus/public/cpp/tests/view_manager_test_base.h"
+#include "components/mus/public/cpp/tests/mandoline_ui_services_test_base.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "components/mus/public/cpp/view.h"
 #include "components/mus/public/cpp/view_tree_connection.h"
 #include "components/mus/public/cpp/view_tree_host_factory.h"
 #include "mojo/application/public/cpp/application_impl.h"
 
-namespace mojo {
+namespace mus {
+
 namespace {
 
 base::RunLoop* current_run_loop = nullptr;
 
 void TimeoutRunLoop(const base::Closure& timeout_task, bool* timeout) {
   CHECK(current_run_loop);
   *timeout = true;
   timeout_task.Run();
 }
 
 }  // namespace
 
-ViewManagerTestBase::ViewManagerTestBase()
+MandolineUIServicesTestBase::MandolineUIServicesTestBase()
     : most_recent_connection_(nullptr),
       window_manager_(nullptr),
       view_tree_connection_destroyed_(false) {}
 
-ViewManagerTestBase::~ViewManagerTestBase() {}
+MandolineUIServicesTestBase::~MandolineUIServicesTestBase() {}
 
 // static
-bool ViewManagerTestBase::DoRunLoopWithTimeout() {
+bool MandolineUIServicesTestBase::DoRunLoopWithTimeout() {
   if (current_run_loop != nullptr)
     return false;
 
   bool timeout = false;
   base::RunLoop run_loop;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(&TimeoutRunLoop, run_loop.QuitClosure(), &timeout),
       TestTimeouts::action_timeout());
 
   current_run_loop = &run_loop;
   current_run_loop->Run();
   current_run_loop = nullptr;
   return !timeout;
 }
 
 // static
-bool ViewManagerTestBase::QuitRunLoop() {
+bool MandolineUIServicesTestBase::QuitRunLoop() {
   if (!current_run_loop)
     return false;
 
   current_run_loop->Quit();
   current_run_loop = nullptr;
   return true;
 }
 
-void ViewManagerTestBase::SetUp() {
+void MandolineUIServicesTestBase::SetUp() {
   ApplicationTestBase::SetUp();
 
   CreateSingleViewTreeHost(application_impl(), this, &host_);
 
   ASSERT_TRUE(DoRunLoopWithTimeout());  // RunLoop should be quit by OnEmbed().
   std::swap(window_manager_, most_recent_connection_);
 }
 
-void ViewManagerTestBase::TearDown() {
+void MandolineUIServicesTestBase::TearDown() {
   ApplicationTestBase::TearDown();
 }
 
-ApplicationDelegate* ViewManagerTestBase::GetApplicationDelegate() {
+mojo::ApplicationDelegate*
+MandolineUIServicesTestBase::GetApplicationDelegate() {
   return this;
 }
 
-bool ViewManagerTestBase::ConfigureIncomingConnection(
-    ApplicationConnection* connection) {
-  connection->AddService<ViewTreeClient>(this);
+bool MandolineUIServicesTestBase::ConfigureIncomingConnection(
+    mojo::ApplicationConnection* connection) {
+  connection->AddService<mojo::ViewTreeClient>(this);
   return true;
 }
 
-void ViewManagerTestBase::OnEmbed(View* root) {
+void MandolineUIServicesTestBase::OnEmbed(View* root) {
   most_recent_connection_ = root->connection();
   EXPECT_TRUE(QuitRunLoop());
 }
 
-void ViewManagerTestBase::OnConnectionLost(ViewTreeConnection* connection) {
+void MandolineUIServicesTestBase::OnConnectionLost(
+    ViewTreeConnection* connection) {
   view_tree_connection_destroyed_ = true;
 }
 
-void ViewManagerTestBase::Create(ApplicationConnection* connection,
-                                 InterfaceRequest<ViewTreeClient> request) {
+void MandolineUIServicesTestBase::Create(
+    mojo::ApplicationConnection* connection,
+    mojo::InterfaceRequest<mojo::ViewTreeClient> request) {
   ViewTreeConnection::Create(this, request.Pass());
 }
 
-}  // namespace mojo
+}  // namespace mus