components/mus/public/interfaces View => Window

components/mus/ws/view_manager_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/window_server_test_base.h"
 #include "components/mus/public/cpp/util.h"
 #include "components/mus/public/cpp/window_observer.h"
@@ skipping 113 matching lines @@
  public:
   OrderChangeObserver(Window* window) : window_(window) {
     window_->AddObserver(this);
   }
   ~OrderChangeObserver() override { window_->RemoveObserver(this); }
 
  private:
   // Overridden from WindowObserver:
   void OnWindowReordered(Window* window,
                          Window* relative_window,
-                         mojo::OrderDirection direction) override {
+                         mojom::OrderDirection direction) override {
     DCHECK_EQ(window, window_);
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   Window* window_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver);
 };
 
 // Wait until |window|'s tree size matches |tree_size|; returns false on
@@ skipping 51 matching lines @@
 // service, that are given access to some root window.
 
 class WindowServerTest : public WindowServerTestBase {
  public:
   WindowServerTest() {}
 
   // Embeds another version of the test app @ window. This runs a run loop until
   // a response is received, or a timeout. On success the new WindowServer is
   // returned.
   EmbedResult Embed(Window* window) {
-    return Embed(window, mojo::ViewTree::ACCESS_POLICY_DEFAULT);
+    return Embed(window, mus::mojom::WindowTree::ACCESS_POLICY_DEFAULT);
   }
 
   EmbedResult Embed(Window* window, uint32_t access_policy_bitmask) {
     DCHECK(!embed_details_);
     embed_details_.reset(new EmbedDetails);
     window->Embed(ConnectToApplicationAndGetWindowServerClient(),
                   access_policy_bitmask,
                   base::Bind(&WindowServerTest::EmbedCallbackImpl,
                              base::Unretained(this)));
     embed_details_->waiting = true;
     if (!WindowServerTestBase::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 ConnectToApplicationAndGetWindowServerClient() {
+  // WindowTreeClient.
+  mus::mojom::WindowTreeClientPtr
+  ConnectToApplicationAndGetWindowServerClient() {
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From(application_impl()->url());
     scoped_ptr<mojo::ApplicationConnection> connection =
         application_impl()->ConnectToApplication(request.Pass());
-    mojo::ViewTreeClientPtr client;
+    mus::mojom::WindowTreeClientPtr client;
     connection->ConnectToService(&client);
     return client.Pass();
   }
 
   // WindowServerTestBase:
   void OnEmbed(Window* root) override {
     if (!embed_details_) {
       WindowServerTestBase::OnEmbed(root);
       return;
     }
@@ skipping 572 matching lines @@
   EXPECT_TRUE(got_destroy);
 }
 
 // Verifies an embed root sees windows created beneath it from another
 // connection.
 TEST_F(WindowServerTest, EmbedRootSeesHierarchyChanged) {
   Window* embed_window = window_manager()->CreateWindow();
   window_manager()->GetRoot()->AddChild(embed_window);
 
   WindowTreeConnection* vm2 =
-      Embed(embed_window, mojo::ViewTree::ACCESS_POLICY_EMBED_ROOT).connection;
+      Embed(embed_window, mus::mojom::WindowTree::ACCESS_POLICY_EMBED_ROOT)
+          .connection;
   Window* vm2_v1 = vm2->CreateWindow();
   vm2->GetRoot()->AddChild(vm2_v1);
 
   WindowTreeConnection* vm3 = Embed(vm2_v1).connection;
   Window* vm3_v1 = vm3->CreateWindow();
   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(WindowServerTest, EmbedFromEmbedRoot) {
   Window* embed_window = window_manager()->CreateWindow();
   window_manager()->GetRoot()->AddChild(embed_window);
 
   // Give the connection embedded at |embed_window| embed root powers.
   const EmbedResult result1 =
-      Embed(embed_window, mojo::ViewTree::ACCESS_POLICY_EMBED_ROOT);
+      Embed(embed_window, mus::mojom::WindowTree::ACCESS_POLICY_EMBED_ROOT);
   WindowTreeConnection* vm2 = result1.connection;
   EXPECT_EQ(result1.connection_id, vm2->GetConnectionId());
   Window* vm2_v1 = vm2->CreateWindow();
   vm2->GetRoot()->AddChild(vm2_v1);
 
   const EmbedResult result2 = Embed(vm2_v1);
   WindowTreeConnection* vm3 = result2.connection;
   EXPECT_EQ(result2.connection_id, vm3->GetConnectionId());
   Window* vm3_v1 = vm3->CreateWindow();
   vm3->GetRoot()->AddChild(vm3_v1);
@@ skipping 32 matching lines @@
   // Verify bounds change results in resetting client area in embedded.
   embed_window->SetBounds(*mojo::Rect::From(gfx::Rect(21, 22, 23, 24)));
   WaitForBoundsToChange(embedded_connection->GetRoot());
   EXPECT_TRUE(gfx::Rect(21, 22, 23, 24) ==
               embedded_connection->GetRoot()->bounds().To<gfx::Rect>());
   EXPECT_TRUE(gfx::Rect(0, 0, 23, 24) ==
               embedded_connection->GetRoot()->client_area().To<gfx::Rect>());
 }
 
 }  // namespace mus