Makes it possible for clients to directly create WindowTreeHostMus

ui/aura/mus/window_port_mus.cc

 // Copyright 2016 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 "ui/aura/mus/window_port_mus.h"
 
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/surface_id_handler.h"
 #include "ui/aura/mus/window_tree_client.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_property.h"
 
 namespace aura {
 
 WindowPortMus::WindowMusChangeDataImpl::WindowMusChangeDataImpl() = default;
 
 WindowPortMus::WindowMusChangeDataImpl::~WindowMusChangeDataImpl() = default;
 
 // static
 WindowMus* WindowMus::Get(Window* window) {
   return WindowPortMus::Get(window);
 }
 
 WindowPortMus::WindowPortMus(WindowTreeClient* client,
-                             bool create_remote_window)
-    : WindowMus(create_remote_window), window_tree_client_(client) {}
+                             WindowMusType window_mus_type)
+    : WindowMus(window_mus_type), window_tree_client_(client) {}
 
 WindowPortMus::~WindowPortMus() {
   if (surface_info_)
     SetSurfaceIdFromServer(nullptr);
 
   window_tree_client_->OnWindowMusDestroyed(this);
 }
 
 // static
 WindowPortMus* WindowPortMus::Get(Window* window) {
@@ skipping 72 matching lines @@
 
 PropertyConverter* WindowPortMus::GetPropertyConverter() {
   return window_tree_client_->delegate_->GetPropertyConverter();
 }
 
 Window* WindowPortMus::GetWindow() {
   return window_;
 }
 
 void WindowPortMus::AddChildFromServer(WindowMus* window) {
-  DCHECK(has_server_window());

[sadrul, 2016/11/02 16:03:04]

Some of these DCHECK()s should still be OK?

[sky, 2016/11/02 16:53:23]

The DCHECKs were intended to catch the case of windows with no associated server
window. Previously this was only possible for the roots of WindowTreeHostMus (in
some cases). As this change make it so these windows now have associated server
windows too the DCHECK didn't seem useful. It's true the DCHECK would catch not
assigning a server id, but that is really separate from what the DCHECKs were
intended for originally. WDYT?

   ServerChangeData data;
   data.child_id = window->server_id();
   ScopedServerChange change(this, ServerChangeType::ADD, data);
   window_->AddChild(window->GetWindow());
 }
 
 void WindowPortMus::RemoveChildFromServer(WindowMus* child) {
-  DCHECK(has_server_window());
   ServerChangeData data;
   data.child_id = child->server_id();
   ScopedServerChange change(this, ServerChangeType::REMOVE, data);
   window_->RemoveChild(child->GetWindow());
 }
 
 void WindowPortMus::ReorderFromServer(WindowMus* child,
                                       WindowMus* relative,
                                       ui::mojom::OrderDirection direction) {
-  DCHECK(has_server_window());
   // Keying off solely the id isn't entirely accurate, in so far as if Window
   // does some other reordering then the server and client are out of sync.
   // But we assume only one client can make changes to a particular window at
   // a time, so this should be ok.
   ServerChangeData data;
   data.child_id = child->server_id();
   ScopedServerChange change(this, ServerChangeType::REORDER, data);
   if (direction == ui::mojom::OrderDirection::BELOW)
     window_->StackChildBelow(child->GetWindow(), relative->GetWindow());
   else
     window_->StackChildAbove(child->GetWindow(), relative->GetWindow());
 }
 
 void WindowPortMus::SetBoundsFromServer(const gfx::Rect& bounds) {
-  DCHECK(has_server_window());
   ServerChangeData data;
   data.bounds = bounds;
   ScopedServerChange change(this, ServerChangeType::BOUNDS, data);
   window_->SetBounds(bounds);
 }
 
 void WindowPortMus::SetVisibleFromServer(bool visible) {
-  DCHECK(has_server_window());
   ServerChangeData data;
   data.visible = visible;
   ScopedServerChange change(this, ServerChangeType::VISIBLE, data);
   if (visible)
     window_->Show();
   else
     window_->Hide();
 }
 
 void WindowPortMus::SetOpacityFromServer(float opacity) {
-  // TODO(sky): this may not be necessary anymore.
-  DCHECK(has_server_window());
+  // TODO(sky): route to server.
   // Changes to opacity don't make it back to the server.
   window_->layer()->SetOpacity(opacity);
 }
 
 void WindowPortMus::SetPredefinedCursorFromServer(ui::mojom::Cursor cursor) {
   // As this does nothing more than set the cursor we don't need to use
   // ServerChange.
   predefined_cursor_ = cursor;
 }
 
@@ skipping 22 matching lines @@
   }
   WindowPortMus* parent = Get(window_->parent());
   if (parent && parent->surface_id_handler_) {
     parent->surface_id_handler_->OnChildWindowSurfaceChanged(window_,
                                                              &surface_info);
   }
   surface_info_ = std::move(surface_info);
 }
 
 void WindowPortMus::AddTransientChildFromServer(WindowMus* child) {
-  DCHECK(has_server_window());
   ServerChangeData data;
   data.child_id = child->server_id();
   ScopedServerChange change(this, ServerChangeType::ADD_TRANSIENT, data);
   client::GetTransientWindowClient()->AddTransientChild(window_,
                                                         child->GetWindow());
 }
 
 void WindowPortMus::RemoveTransientChildFromServer(WindowMus* child) {
-  DCHECK(has_server_window());
   ServerChangeData data;
   data.child_id = child->server_id();
   ScopedServerChange change(this, ServerChangeType::REMOVE_TRANSIENT, data);
   client::GetTransientWindowClient()->RemoveTransientChild(window_,
                                                            child->GetWindow());
 }
 
 WindowPortMus::ChangeSource WindowPortMus::OnTransientChildAdded(
     WindowMus* child) {
-  DCHECK(has_server_window());
   ServerChangeData change_data;
   change_data.child_id = child->server_id();
   // If there was a change it means we scheduled the change by way of
   // AddTransientChildFromServer(), which came from the server.
   return RemoveChangeByTypeAndData(ServerChangeType::ADD_TRANSIENT, change_data)
              ? ChangeSource::SERVER
              : ChangeSource::LOCAL;
 }
 
 WindowPortMus::ChangeSource WindowPortMus::OnTransientChildRemoved(
     WindowMus* child) {
-  DCHECK(has_server_window());
   ServerChangeData change_data;
   change_data.child_id = child->server_id();
   // If there was a change it means we scheduled the change by way of
   // RemoveTransientChildFromServer(), which came from the server.
   return RemoveChangeByTypeAndData(ServerChangeType::REMOVE_TRANSIENT,
                                    change_data)
              ? ChangeSource::SERVER
              : ChangeSource::LOCAL;
 }
 
@@ skipping 17 matching lines @@
   data->change = base::MakeUnique<ScopedServerChange>(
       this, ServerChangeType::VISIBLE, change_data);
   return std::move(data);
 }
 
 void WindowPortMus::NotifyEmbeddedAppDisconnected() {
   for (WindowObserver& observer : *GetObservers(window_))
     observer.OnEmbeddedAppDisconnected(window_);
 }
 
-std::unique_ptr<WindowPortInitData> WindowPortMus::OnPreInit(Window* window) {
+void WindowPortMus::OnPreInit(Window* window) {
   window_ = window;
-  return window_tree_client_->OnWindowMusCreated(this);
-}
-
-void WindowPortMus::OnPostInit(std::unique_ptr<WindowPortInitData> init_data) {
-  window_tree_client_->OnWindowMusInitDone(this, std::move(init_data));
+  window_tree_client_->OnWindowMusCreated(this);
 }
 
 void WindowPortMus::OnDeviceScaleFactorChanged(float device_scale_factor) {}
 
 void WindowPortMus::OnWillAddChild(Window* child) {
-  if (!has_server_window())
-    return;
-
   ServerChangeData change_data;
   change_data.child_id = Get(child)->server_id();
   if (!RemoveChangeByTypeAndData(ServerChangeType::ADD, change_data))
     window_tree_client_->OnWindowMusAddChild(this, Get(child));
 }
 
 void WindowPortMus::OnWillRemoveChild(Window* child) {
-  if (!has_server_window())
-    return;
-
   ServerChangeData change_data;
   change_data.child_id = Get(child)->server_id();
   if (!RemoveChangeByTypeAndData(ServerChangeType::REMOVE, change_data))
     window_tree_client_->OnWindowMusRemoveChild(this, Get(child));
 }
 
 void WindowPortMus::OnWillMoveChild(size_t current_index, size_t dest_index) {
-  if (!has_server_window())
-    return;
-
   ServerChangeData change_data;
   change_data.child_id = Get(window_->children()[current_index])->server_id();
   if (!RemoveChangeByTypeAndData(ServerChangeType::REORDER, change_data))
     window_tree_client_->OnWindowMusMoveChild(this, current_index, dest_index);
 }
 
 void WindowPortMus::OnVisibilityChanged(bool visible) {
-  if (!has_server_window())
-    return;
-
   ServerChangeData change_data;
   change_data.visible = visible;
   if (!RemoveChangeByTypeAndData(ServerChangeType::VISIBLE, change_data))
     window_tree_client_->OnWindowMusSetVisible(this, visible);
 }
 
 void WindowPortMus::OnDidChangeBounds(const gfx::Rect& old_bounds,
                                       const gfx::Rect& new_bounds) {
-  if (!has_server_window())
-    return;
-
   ServerChangeData change_data;
   change_data.bounds = new_bounds;
   if (!RemoveChangeByTypeAndData(ServerChangeType::BOUNDS, change_data))
     window_tree_client_->OnWindowMusBoundsChanged(this, old_bounds, new_bounds);
 }
 
 std::unique_ptr<WindowPortPropertyData> WindowPortMus::OnWillChangeProperty(
     const void* key) {
-  if (!has_server_window())
-    return nullptr;
-
   return window_tree_client_->OnWindowMusWillChangeProperty(this, key);
 }
 
 void WindowPortMus::OnPropertyChanged(
     const void* key,
     std::unique_ptr<WindowPortPropertyData> data) {
-  if (!has_server_window())
-    return;
-
   ServerChangeData change_data;
   change_data.property_name =
       GetPropertyConverter()->GetTransportNameForPropertyKey(key);
   // TODO(sky): investigate to see if we need to compare data. In particular do
   // we ever have a case where changing a property cascades into changing the
   // same property?
   if (!RemoveChangeByTypeAndData(ServerChangeType::PROPERTY, change_data))
     window_tree_client_->OnWindowMusPropertyChanged(this, key, std::move(data));
 }
 
 }  // namespace aura