Eliminate WindowTreeConnection

components/mus/public/cpp/window.h

 // 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.
 
 #ifndef COMPONENTS_MUS_PUBLIC_CPP_WINDOW_H_
 #define COMPONENTS_MUS_PUBLIC_CPP_WINDOW_H_
 
 #include <stdint.h>
 #include <vector>
 
@@ skipping 12 matching lines @@
 class Size;
 }
 
 namespace mus {
 
 class InputEventHandler;
 class ServiceProviderImpl;
 class WindowObserver;
 class WindowSurface;
 class WindowSurfaceBinding;
-class WindowTreeClientImpl;
-class WindowTreeClientImplPrivate;
-class WindowTreeConnection;
+class WindowTreeClient;
+class WindowTreeClientPrivate;
 
 namespace {
 class OrderChangedNotifier;
 }
 
 // Defined in window_property.h (which we do not include)
 template <typename T>
 struct WindowProperty;
 
-// Windows are owned by the WindowTreeConnection. See WindowTreeDelegate for
+// Windows are owned by the WindowTreeClient. See WindowTreeClientDelegate for
 // details on ownership.
 //
 // TODO(beng): Right now, you'll have to implement a WindowObserver to track
 //             destruction and NULL any pointers you have.
 //             Investigate some kind of smart pointer or weak pointer for these.
 class Window {
  public:
   using Children = std::vector<Window*>;
   using EmbedCallback = base::Callback<void(bool)>;
   using PropertyDeallocator = void (*)(int64_t value);
   using SharedProperties = std::map<std::string, std::vector<uint8_t>>;
 
   // Destroys this window and all its children. Destruction is allowed for
   // windows that were created by this connection, or the roots. For windows
   // from other connections (except the roots), Destroy() does nothing. If the
   // destruction is allowed observers are notified and the Window is
   // immediately deleted.
   void Destroy();
 
-  WindowTreeConnection* connection() { return connection_; }
+  WindowTreeClient* window_tree() { return client_; }
 
   // The local_id is provided for client code. The local_id is not set or
   // manipulated by mus. The default value is -1.
   void set_local_id(int id) { local_id_ = id; }
   int local_id() const { return local_id_; }
 
   int64_t display_id() const { return display_id_; }
 
   // Geometric disposition relative to parent window.
   const gfx::Rect& bounds() const { return bounds_; }
@@ skipping 122 matching lines @@
 
   Window* GetChildByLocalId(int id);
 
   void SetTextInputState(mojo::TextInputStatePtr state);
   void SetImeVisibility(bool visible, mojo::TextInputStatePtr state);
 
   bool HasCapture() const;
   void SetCapture();
   void ReleaseCapture();
 
-  // Focus. See WindowTreeConnection::ClearFocus() to reset focus.
+  // Focus. See WindowTreeClient::ClearFocus() to reset focus.
   void SetFocus();
   bool HasFocus() const;
   void SetCanFocus(bool can_focus);
 
   // Embedding. See window_tree.mojom for details.
   void Embed(mus::mojom::WindowTreeClientPtr client);
 
   // NOTE: callback is run synchronously if Embed() is not allowed on this
   // Window.
   void Embed(mus::mojom::WindowTreeClientPtr client,
              const EmbedCallback& callback);
 
   // TODO(sky): this API is only applicable to the WindowManager. Move it
   // to a better place.
   void RequestClose();
 
   // Returns an internal name, set by a client app when it creates a window.
   std::string GetName() const;
 
  protected:
   // This class is subclassed only by test classes that provide a public ctor.
   Window();
   ~Window();
 
  private:
   friend class WindowPrivate;
-  friend class WindowTreeClientImpl;
-  friend class WindowTreeClientImplPrivate;
+  friend class WindowTreeClient;
+  friend class WindowTreeClientPrivate;
 
-  Window(WindowTreeConnection* connection, Id id);
+  Window(WindowTreeClient* client, Id id);
 
   // Used to identify this Window on the server. Clients can not change this
   // value.
   Id server_id() const { return server_id_; }
 
-  WindowTreeClientImpl* tree_client();
-
   // Applies a shared property change locally and forwards to the server. If
   // |data| is null, this property is deleted.
   void SetSharedPropertyInternal(const std::string& name,
                                  const std::vector<uint8_t>* data);
   // Called by the public {Set,Get,Clear}Property functions.
   int64_t SetLocalPropertyInternal(const void* key,
                                    const char* name,
                                    PropertyDeallocator deallocator,
                                    int64_t value,
                                    int64_t default_value);
@@ skipping 44 matching lines @@
                                          mojom::OrderDirection direction);
   static bool ReorderImpl(Window* window,
                           Window* relative,
                           mojom::OrderDirection direction,
                           OrderChangedNotifier* notifier);
 
   // Returns a pointer to the stacking target that can be used by
   // RestackTransientDescendants.
   static Window** GetStackingTarget(Window* window);
 
-  WindowTreeConnection* connection_;
+  WindowTreeClient* client_;
   Id server_id_;
   int local_id_ = -1;
   Window* parent_;
   Children children_;
 
   Window* stacking_target_;
   Window* transient_parent_;
   Children transient_children_;
 
   bool is_modal_;
@@ skipping 28 matching lines @@
   };
 
   std::map<const void*, Value> prop_map_;
 
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_PUBLIC_CPP_WINDOW_H_