Revert of Mandoline UI Process: Update namespaces and file names

components/web_view/frame_apptest.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/web_view/frame.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.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_observer.h"
 #include "components/mus/public/cpp/view_tree_connection.h"
 #include "components/mus/public/cpp/view_tree_delegate.h"
 #include "components/mus/public/cpp/view_tree_host_factory.h"
 #include "components/web_view/frame.h"
 #include "components/web_view/frame_connection.h"
 #include "components/web_view/frame_tree.h"
 #include "components/web_view/frame_tree_delegate.h"
 #include "components/web_view/frame_user_data.h"
 #include "components/web_view/test_frame_tree_delegate.h"
 #include "mojo/application/public/cpp/application_connection.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"
 #include "mojo/application/public/cpp/service_provider_impl.h"
 
-using mus::View;
-using mus::ViewTreeConnection;
+using mojo::View;
+using mojo::ViewTreeConnection;
 
 namespace web_view {
 
 namespace {
 
 base::RunLoop* current_run_loop = nullptr;
 
 void TimeoutRunLoop(const base::Closure& timeout_task, bool* timeout) {
   CHECK(current_run_loop);
   *timeout = true;
@@ skipping 93 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TestFrameTreeClient);
 };
 
 class FrameTest;
 
 // ViewAndFrame maintains the View and TestFrameTreeClient associated with
 // a single FrameTreeClient. In other words this maintains the data structures
 // needed to represent a client side frame. To obtain one use
 // FrameTest::WaitForViewAndFrame().
-class ViewAndFrame : public mus::ViewTreeDelegate {
+class ViewAndFrame : public mojo::ViewTreeDelegate {
  public:
   ~ViewAndFrame() override {
     if (view_)
       delete view_->connection();
   }
 
   // The View associated with the frame.
-  mus::View* view() { return view_; }
+  mojo::View* view() { return view_; }
   TestFrameTreeClient* test_frame_tree_client() {
     return &test_frame_tree_client_;
   }
   FrameTreeServer* frame_tree_server() {
     return test_frame_tree_client_.server();
   }
 
  private:
   friend class FrameTest;
 
@@ skipping 19 matching lines @@
 
   // Overridden from ViewTreeDelegate:
   void OnEmbed(View* root) override {
     view_ = root;
     QuitRunLoopIfNecessary();
   }
   void OnConnectionLost(ViewTreeConnection* connection) override {
     view_ = nullptr;
   }
 
-  mus::View* view_;
+  mojo::View* view_;
   base::RunLoop run_loop_;
   TestFrameTreeClient test_frame_tree_client_;
   mojo::Binding<FrameTreeClient> frame_tree_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewAndFrame);
 };
 
 class FrameTest : public mojo::test::ApplicationTestBase,
                   public mojo::ApplicationDelegate,
-                  public mus::ViewTreeDelegate,
+                  public mojo::ViewTreeDelegate,
                   public mojo::InterfaceFactory<mojo::ViewTreeClient>,
                   public mojo::InterfaceFactory<FrameTreeClient> {
  public:
   FrameTest() : most_recent_connection_(nullptr), window_manager_(nullptr) {}
 
   ViewTreeConnection* most_recent_connection() {
     return most_recent_connection_;
   }
 
  protected:
   ViewTreeConnection* window_manager() { return window_manager_; }
   TestFrameTreeDelegate* frame_tree_delegate() {
     return frame_tree_delegate_.get();
   }
   FrameTree* frame_tree() { return frame_tree_.get(); }
   ViewAndFrame* root_view_and_frame() { return root_view_and_frame_.get(); }
 
   mojo::Binding<FrameTreeServer>* frame_tree_server_binding(Frame* frame) {
     return frame->frame_tree_server_binding_.get();
   }
 
   // Creates a new shared frame as a child of |parent|.
   Frame* CreateSharedFrame(ViewAndFrame* parent) {
-    mus::View* child_frame_view = parent->view()->connection()->CreateView();
+    mojo::View* child_frame_view = parent->view()->connection()->CreateView();
     parent->view()->AddChild(child_frame_view);
     mojo::Map<mojo::String, mojo::Array<uint8_t>> client_properties;
     client_properties.mark_non_null();
     parent->frame_tree_server()->OnCreatedFrame(
         child_frame_view->parent()->id(), child_frame_view->id(),
         client_properties.Pass());
     Frame* frame = frame_tree_delegate()->WaitForCreateFrame();
     return HasFatalFailure() ? nullptr : frame;
   }
 
@@ skipping 37 matching lines @@
   void OnEmbed(View* root) override {
     most_recent_connection_ = root->connection();
     QuitRunLoop();
   }
   void OnConnectionLost(ViewTreeConnection* connection) override {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     ApplicationTestBase::SetUp();
 
-    mus::CreateSingleViewTreeHost(application_impl(), this, &host_);
+    mojo::CreateSingleViewTreeHost(application_impl(), this, &host_);
 
     ASSERT_TRUE(DoRunLoopWithTimeout());
     std::swap(window_manager_, most_recent_connection_);
 
     // Creates a FrameTree, which creates a single frame. Wait for the
     // FrameTreeClient to be connected to.
     frame_tree_delegate_.reset(new TestFrameTreeDelegate(application_impl()));
     scoped_ptr<FrameConnection> frame_connection =
         CreateFrameConnection(application_impl());
     FrameTreeClient* frame_tree_client = frame_connection->frame_tree_client();
     mojo::ViewTreeClientPtr view_tree_client =
         frame_connection->GetViewTreeClient();
-    mus::View* frame_root_view = window_manager()->CreateView();
+    mojo::View* frame_root_view = window_manager()->CreateView();
     window_manager()->GetRoot()->AddChild(frame_root_view);
     frame_tree_.reset(
         new FrameTree(0u, frame_root_view, view_tree_client.Pass(),
                       frame_tree_delegate_.get(), frame_tree_client,
                       frame_connection.Pass(), Frame::ClientPropertyMap()));
     root_view_and_frame_ = WaitForViewAndFrame();
   }
 
   // Overridden from testing::Test:
   void TearDown() override {
     root_view_and_frame_.reset();
     frame_tree_.reset();
     frame_tree_delegate_.reset();
     ApplicationTestBase::TearDown();
   }
 
   // Overridden from mojo::InterfaceFactory<mojo::ViewTreeClient>:
   void Create(
       mojo::ApplicationConnection* connection,
       mojo::InterfaceRequest<mojo::ViewTreeClient> request) override {
     if (view_and_frame_) {
-      mus::ViewTreeConnection::Create(view_and_frame_.get(), request.Pass());
+      mojo::ViewTreeConnection::Create(view_and_frame_.get(), request.Pass());
     } else {
-      mus::ViewTreeConnection::Create(this, request.Pass());
+      mojo::ViewTreeConnection::Create(this, request.Pass());
     }
   }
 
   // Overridden from mojo::InterfaceFactory<FrameTreeClient>:
   void Create(mojo::ApplicationConnection* connection,
               mojo::InterfaceRequest<FrameTreeClient> request) override {
     ASSERT_TRUE(view_and_frame_);
     view_and_frame_->Bind(request.Pass());
   }
 
@@ skipping 63 matching lines @@
 
   // Send LoadingStarted() from the root targetting a frame from another
   // connection. It should be ignored (not update the loading status).
   root_view_and_frame()->frame_tree_server()->LoadingStarted(
       shared_frame->id());
   frame_tree_server_binding(frame_tree()->root())->WaitForIncomingMethodCall();
   EXPECT_FALSE(frame_tree()->root()->IsLoading());
 }
 
 }  // namespace web_view