Converts test_wm to use aura

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"
@@ skipping 16 matching lines @@
 }
 
 WindowPortMus::WindowPortMus(WindowTreeClient* 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);
+  const WindowTreeClient::Origin origin =

[msw, 2016/11/17 21:26:15]

nit: maybe comment here since this is slightly sublte? Something like "Check for
a scheduled DESTROY change from the server, so the client can avoid cyclically
scheduling a DELETE_WINDOW change on the server."?

[sky, 2016/11/17 22:25:54]

I added a comment indicating why DESTROY means it originated from the server.

+      RemoveChangeByTypeAndData(ServerChangeType::DELETE, ServerChangeData())
+          ? WindowTreeClient::Origin::SERVER
+          : WindowTreeClient::Origin::CLIENT;
+  window_tree_client_->OnWindowMusDestroyed(this, origin);
 }
 
 // static
 WindowPortMus* WindowPortMus::Get(Window* window) {
   return static_cast<WindowPortMus*>(WindowPort::Get(window));
 }
 
 void WindowPortMus::SetTextInputState(mojo::TextInputStatePtr state) {
   window_tree_client_->SetWindowTextInputState(this, std::move(state));
 }
@@ skipping 68 matching lines @@
       case ServerChangeType::REMOVE:
       case ServerChangeType::REMOVE_TRANSIENT:
       case ServerChangeType::REORDER:
         if (iter->data.child_id == data.child_id)
           break;
         continue;
       case ServerChangeType::BOUNDS:
         if (iter->data.bounds == data.bounds)
           break;
         continue;
+      case ServerChangeType::DELETE:
+        // No extra data for delete.
+        break;
       case ServerChangeType::PROPERTY:
         if (iter->data.property_name == data.property_name)
           break;
         continue;
       case ServerChangeType::VISIBLE:
         if (iter->data.visible == data.visible)
           break;
         continue;
     }
     server_changes_.erase(iter);
@@ skipping 91 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::DestroyFromServer() {
+  std::unique_ptr<ScopedServerChange> remove_from_parent_change;
+  if (window_->parent()) {
+    ServerChangeData data;
+    data.child_id = server_id();
+    WindowPortMus* parent = Get(window_->parent());
+    remove_from_parent_change = base::MakeUnique<ScopedServerChange>(
+        parent, ServerChangeType::REMOVE, data);
+  }
+  // NOTE: this can't use ScopedServerChange as |this| is destroyed before the
+  // function returns (ScopedServerChange would attempt to access |this| after
+  // destruction).
+  ScheduleChange(ServerChangeType::DELETE, ServerChangeData());
+  delete window_;
+}
+
 void WindowPortMus::AddTransientChildFromServer(WindowMus* child) {
   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) {
   ServerChangeData data;
@@ skipping 111 matching lines @@
   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