Eliminate WindowTreeConnection

components/mus/public/cpp/lib/in_flight_change.h

 // 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.
 
 #ifndef COMPONENTS_MUS_PUBLIC_CPP_LIB_IN_FLIGHT_CHANGE_H_
 #define COMPONENTS_MUS_PUBLIC_CPP_LIB_IN_FLIGHT_CHANGE_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace mus {
 
 namespace mojom {
 enum class Cursor : int32_t;
 }
 
 class Window;
-class WindowTreeClientImpl;
+class WindowTreeClient;
 
 enum class ChangeType {
   ADD_CHILD,
   ADD_TRANSIENT_WINDOW,
   BOUNDS,
   CAPTURE,
   DELETE_WINDOW,
   FOCUS,
   NEW_WINDOW,
   NEW_TOP_LEVEL_WINDOW,
@@ skipping 30 matching lines @@
 //   invoked followed by Revert(). The expectation is Revert() sets the
 //   appropriate value back on the Window.
 //
 // In general there are two classes of changes:
 // 1. We are the only side allowed to make the change.
 // 2. The change can also be applied by another client. For example, the
 //    window manager may change the bounds as well as the local client.
 //
 // For (1) use CrashInFlightChange. As the name implies this change CHECKs that
 // the change succeeded. Use the following pattern for this. This code goes
-// where the change is sent to the server (in WindowTreeClientImpl):
+// where the change is sent to the server (in WindowTreeClient):
 //   const uint32_t change_id =
 //   ScheduleInFlightChange(base::WrapUnique(new CrashInFlightChange(
 //       window, ChangeType::REORDER)));
 //
 // For (2) use the same pattern as (1), but in the on change callback from the
 // server (e.g. OnWindowBoundsChanged()) add the following:
 //   // value_from_server is the value supplied from the server. It corresponds
 //   // to the value of the property at the time the server processed the
 //   // change. If the local change fails, this is the value reverted to.
 //   InFlightBoundsChange new_change(window, value_from_server);
@@ skipping 63 matching lines @@
 
   // InFlightChange:
   void SetRevertValueFrom(const InFlightChange& change) override;
   void ChangeFailed() override;
   void Revert() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CrashInFlightChange);
 };
 
-// Use this class for properties that are specific to the connection, and not a
+// Use this class for properties that are specific to the client, and not a
 // particular window. For example, only a single window can have focus, so focus
-// is specific to the connection.
+// is specific to the client.
 //
 // This does not implement InFlightChange::Revert, subclasses must implement
-// that to update the WindowTreeConnection.
+// that to update the WindowTreeClient.
 class InFlightWindowTreeClientChange : public InFlightChange,
                                        public WindowObserver {
  public:
-  InFlightWindowTreeClientChange(WindowTreeClientImpl* client_connection,
+  InFlightWindowTreeClientChange(WindowTreeClient* client,
                                  Window* revert_value,
                                  ChangeType type);
   ~InFlightWindowTreeClientChange() override;
 
   // InFlightChange:
   void SetRevertValueFrom(const InFlightChange& change) override;
 
  protected:
-  WindowTreeClientImpl* connection() { return connection_; }
+  WindowTreeClient* client() { return client_; }
   Window* revert_window() { return revert_window_; }
 
  private:
   void SetRevertWindow(Window* window);
 
   // WindowObserver:
   void OnWindowDestroying(Window* window) override;
 
-  WindowTreeClientImpl* connection_;
+  WindowTreeClient* client_;
   Window* revert_window_;
 
   DISALLOW_COPY_AND_ASSIGN(InFlightWindowTreeClientChange);
 };
 
 class InFlightCaptureChange : public InFlightWindowTreeClientChange {
  public:
-  InFlightCaptureChange(WindowTreeClientImpl* client_connection,
-                        Window* revert_value);
+  InFlightCaptureChange(WindowTreeClient* client, Window* revert_value);
   ~InFlightCaptureChange() override;
 
   // InFlightChange:
   void Revert() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InFlightCaptureChange);
 };
 
 class InFlightFocusChange : public InFlightWindowTreeClientChange {
  public:
-  InFlightFocusChange(WindowTreeClientImpl* client_connection,
-                      Window* revert_value);
+  InFlightFocusChange(WindowTreeClient* client, Window* revert_value);
   ~InFlightFocusChange() override;
 
   // InFlightChange:
   void Revert() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InFlightFocusChange);
 };
 
 class InFlightPropertyChange : public InFlightChange {
@@ skipping 69 matching lines @@
   void SetRevertValueFrom(const InFlightChange& change) override;
   void Revert() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InFlightSetModalChange);
 };
 
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_PUBLIC_CPP_LIB_IN_FLIGHT_CHANGE_H_