components/mus/public/interfaces View => Window

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"
@@ skipping 267 matching lines @@
   base::RunLoop run_loop_;
   TestFrameClient test_frame_tree_client_;
   mojo::Binding<mojom::FrameClient> frame_client_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewAndFrame);
 };
 
 class FrameTest : public mojo::test::ApplicationTestBase,
                   public mojo::ApplicationDelegate,
                   public mus::WindowTreeDelegate,
-                  public mojo::InterfaceFactory<mojo::ViewTreeClient>,
+                  public mojo::InterfaceFactory<mus::mojom::WindowTreeClient>,
                   public mojo::InterfaceFactory<mojom::FrameClient> {
  public:
   FrameTest() : most_recent_connection_(nullptr), window_manager_(nullptr) {}
 
   WindowTreeConnection* most_recent_connection() {
     return most_recent_connection_;
   }
 
  protected:
   WindowTreeConnection* window_manager() { return window_manager_; }
@@ skipping 47 matching lines @@
     return view_and_frame_.Pass();
   }
 
  private:
   // ApplicationTestBase:
   ApplicationDelegate* GetApplicationDelegate() override { return this; }
 
   // ApplicationDelegate implementation.
   bool ConfigureIncomingConnection(
       mojo::ApplicationConnection* connection) override {
-    connection->AddService<mojo::ViewTreeClient>(this);
+    connection->AddService<mus::mojom::WindowTreeClient>(this);
     connection->AddService<mojom::FrameClient>(this);
     return true;
   }
 
   // Overridden from WindowTreeDelegate:
   void OnEmbed(Window* root) override {
     most_recent_connection_ = root->connection();
     QuitRunLoop();
   }
   void OnConnectionLost(WindowTreeConnection* connection) override {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     ApplicationTestBase::SetUp();
 
     mus::CreateSingleWindowTreeHost(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
     // FrameClient to be connected to.
     frame_tree_delegate_.reset(new TestFrameTreeDelegate(application_impl()));
     scoped_ptr<FrameConnection> frame_connection =
         CreateFrameConnection(application_impl());
     mojom::FrameClient* frame_client = frame_connection->frame_client();
-    mojo::ViewTreeClientPtr view_tree_client =
-        frame_connection->GetViewTreeClient();
+    mus::mojom::WindowTreeClientPtr view_tree_client =
+        frame_connection->GetWindowTreeClient();
     mus::Window* frame_root_view = window_manager()->CreateWindow();
     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_client, frame_connection.Pass(),
         Frame::ClientPropertyMap(), base::TimeTicks::Now()));
     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>:
+  // Overridden from mojo::InterfaceFactory<mus::mojom::WindowTreeClient>:
   void Create(
       mojo::ApplicationConnection* connection,
-      mojo::InterfaceRequest<mojo::ViewTreeClient> request) override {
+      mojo::InterfaceRequest<mus::mojom::WindowTreeClient> request) override {
     if (view_and_frame_) {
       mus::WindowTreeConnection::Create(
           view_and_frame_.get(), request.Pass(),
           mus::WindowTreeConnection::CreateType::DONT_WAIT_FOR_EMBED);
     } else {
       mus::WindowTreeConnection::Create(
           this, request.Pass(),
           mus::WindowTreeConnection::CreateType::DONT_WAIT_FOR_EMBED);
     }
   }
 
   // Overridden from mojo::InterfaceFactory<mojom::FrameClient>:
   void Create(mojo::ApplicationConnection* connection,
               mojo::InterfaceRequest<mojom::FrameClient> request) override {
     ASSERT_TRUE(view_and_frame_);
     view_and_frame_->Bind(request.Pass());
   }
 
   scoped_ptr<TestFrameTreeDelegate> frame_tree_delegate_;
   scoped_ptr<FrameTree> frame_tree_;
   scoped_ptr<ViewAndFrame> root_view_and_frame_;
 
-  mojo::ViewTreeHostPtr host_;
+  mus::mojom::WindowTreeHostPtr host_;
 
   // Used to receive the most recent view manager loaded by an embed action.
   WindowTreeConnection* most_recent_connection_;
   // The View Manager connection held by the window manager (app running at the
   // root view).
   WindowTreeConnection* window_manager_;
 
   scoped_ptr<ViewAndFrame> view_and_frame_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(FrameTest);
@@ skipping 124 matching lines @@
   scoped_ptr<ViewAndFrame> navigated_child_view_and_frame =
       NavigateFrameWithStartTime(child_view_and_frame.get(),
                                  navigation_start_time)
           .Pass();
   EXPECT_EQ(navigation_start_time,
             navigated_child_view_and_frame->test_frame_client()
                 ->last_navigation_start_time());
 }
 
 }  // namespace web_view