Renames some WindowManager classes

components/mus/ws/window_tree_unittest.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 <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 45 matching lines @@
 }
 
 ClientWindowId ClientWindowIdForWindow(WindowTreeImpl* tree,
                                        const ServerWindow* window) {
   ClientWindowId client_window_id;
   // If window isn't known we'll return 0, which should then error out.
   tree->IsWindowKnown(window, &client_window_id);
   return client_window_id;
 }
 
-class TestWindowManagerInternal : public mojom::WindowManagerInternal {
+class TestWindowManager : public mojom::WindowManager {
  public:
-  TestWindowManagerInternal()
-      : got_create_top_level_window_(false), change_id_(0u) {}
-  ~TestWindowManagerInternal() override {}
+  TestWindowManager() : got_create_top_level_window_(false), change_id_(0u) {}
+  ~TestWindowManager() override {}
 
   bool did_call_create_top_level_window(uint32_t* change_id) {
     if (!got_create_top_level_window_)
       return false;
 
     got_create_top_level_window_ = false;
     *change_id = change_id_;
     return true;
   }
 
  private:
-  // WindowManagerInternal:
+  // WindowManager:
   void WmSetBounds(uint32_t change_id,
                    uint32_t window_id,
                    mojo::RectPtr bounds) override {}
   void WmSetProperty(uint32_t change_id,
                      uint32_t window_id,
                      const mojo::String& name,
                      mojo::Array<uint8_t> value) override {}
   void WmCreateTopLevelWindow(
       uint32_t change_id,
       mojo::Map<mojo::String, mojo::Array<uint8_t>> properties) override {
     got_create_top_level_window_ = true;
     change_id_ = change_id;
   }
 
   bool got_create_top_level_window_;
   uint32_t change_id_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestWindowManagerInternal);
+  DISALLOW_COPY_AND_ASSIGN(TestWindowManager);
 };
 
 // -----------------------------------------------------------------------------
 
 // WindowTreeClient implementation that logs all calls to a TestChangeTracker.
 // TODO(sky): refactor so both this and WindowTreeAppTest share code.
 class TestWindowTreeClient : public mus::mojom::WindowTreeClient {
  public:
   TestWindowTreeClient() : binding_(this), record_on_change_completed_(false) {}
   ~TestWindowTreeClient() override {}
@@ skipping 83 matching lines @@
   }
   void OnWindowPredefinedCursorChanged(uint32_t window_id,
                                        mojom::Cursor cursor_id) override {
     tracker_.OnWindowPredefinedCursorChanged(window_id, cursor_id);
   }
   void OnChangeCompleted(uint32_t change_id, bool success) override {
     if (record_on_change_completed_)
       tracker_.OnChangeCompleted(change_id, success);
   }
   void RequestClose(uint32_t window_id) override {}
-  void GetWindowManagerInternal(
-      mojo::AssociatedInterfaceRequest<mojom::WindowManagerInternal> internal)
-      override {}
+  void GetWindowManager(mojo::AssociatedInterfaceRequest<mojom::WindowManager>
+                            internal) override {}
 
   TestChangeTracker tracker_;
 
   mojo::Binding<mojom::WindowTreeClient> binding_;
   bool record_on_change_completed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWindowTreeClient);
 };
 
 // -----------------------------------------------------------------------------
 
 // ClientConnection implementation that vends TestWindowTreeClient.
 class TestClientConnection : public ClientConnection {
  public:
   explicit TestClientConnection(scoped_ptr<WindowTreeImpl> service_impl)
       : ClientConnection(std::move(service_impl), &client_),
         is_paused_(false) {}
 
   TestWindowTreeClient* client() { return &client_; }
 
   bool is_paused() const { return is_paused_; }
 
   // ClientConnection:
-  mojom::WindowManagerInternal* GetWindowManagerInternal() override {
+  mojom::WindowManager* GetWindowManager() override {
     NOTREACHED();
     return nullptr;
   }
   void SetIncomingMethodCallProcessingPaused(bool paused) override {
     is_paused_ = paused;
   }
 
  private:
   ~TestClientConnection() override {}
 
@@ skipping 194 matching lines @@
     return static_cast<mus::mojom::Cursor>(cursor_id_);
   }
 
   TestWindowTreeHostConnection* host_connection() { return host_connection_; }
 
   void DispatchEventWithoutAck(const ui::Event& event) {
     host_connection()->window_tree_host()->OnEvent(event);
   }
 
   void set_window_manager_internal(WindowTreeImpl* connection,
-                                   mojom::WindowManagerInternal* wm_internal) {
+                                   mojom::WindowManager* wm_internal) {
     connection->window_manager_internal_ = wm_internal;
   }
 
   void AckPreviousEvent() {
     while (host_connection()->window_tree_host()->tree_awaiting_input_ack_) {
       host_connection()
           ->window_tree_host()
           ->tree_awaiting_input_ack_->OnWindowInputEventAck(0);
     }
   }
@@ skipping 371 matching lines @@
   // Ack the first event. That should trigger the dispatch of the second event.
   AckPreviousEvent();
   ASSERT_EQ(1u, wm_client()->tracker()->changes()->size());
   EXPECT_EQ("InputEvent window=0,2 event_action=5",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
 }
 
 // Establish connection, call NewTopLevelWindow(), make sure get id, and make
 // sure client paused.
 TEST_F(WindowTreeTest, NewTopLevelWindow) {
-  TestWindowManagerInternal wm_internal;
+  TestWindowManager wm_internal;
   set_window_manager_internal(wm_connection(), &wm_internal);
   TestWindowTreeClient* embed_connection = nullptr;
   WindowTreeImpl* window_tree_connection = nullptr;
   ServerWindow* window = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       SetupEventTargeting(&embed_connection, &window_tree_connection, &window));
   embed_connection->tracker()->changes()->clear();
   embed_connection->set_record_on_change_completed(true);
 
   // Create a new top level window.
@@ skipping 13 matching lines @@
 
   // Create the window for |embed_window_id2_in_child|.
   const ClientWindowId embed_window_id2 =
       BuildClientWindowId(wm_connection(), 2);
   EXPECT_TRUE(
       wm_connection()->NewWindow(embed_window_id2, ServerWindow::Properties()));
   EXPECT_TRUE(wm_connection()->AddWindow(FirstRootId(wm_connection()),
                                          embed_window_id2));
 
   // Ack the change, which should resume the binding.
-  static_cast<mojom::WindowManagerInternalClient*>(wm_connection())
+  static_cast<mojom::WindowManagerClient*>(wm_connection())
       ->OnWmCreatedTopLevelWindow(wm_change_id, embed_window_id2.id);
   EXPECT_FALSE(last_client_connection()->is_paused());
   EXPECT_EQ("TopLevelCreated id=17 window_id=" +
                 WindowIdToString(
                     WindowIdFromTransportId(embed_window_id2_in_child.id)),
             SingleChangeToDescription(*embed_connection->tracker()->changes()));
   embed_connection->tracker()->changes()->clear();
 
   // Change the visibility of the window from the owner and make sure the
   // client sees the right id.
@@ skipping 11 matching lines @@
             SingleChangeToDescription(*embed_connection->tracker()->changes()));
 
   // Set the visibility from the child using the client assigned id.
   ASSERT_TRUE(window_tree_connection->SetWindowVisibility(
       embed_window_id2_in_child, false));
   EXPECT_FALSE(embed_window->visible());
 }
 
 }  // namespace ws
 }  // namespace mus