Makes it possible for clients to directly create WindowTreeHostMus

ui/aura/mus/window_tree_client.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 "ui/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 37 matching lines @@
 #undef LoWord
 #endif
 
 namespace aura {
 namespace {
 
 Id MakeTransportId(ClientSpecificId client_id, ClientSpecificId local_id) {
   return (client_id << 16) | local_id;
 }
 
-bool ShouldCreateTopLevel(ui::wm::WindowType type) {
-  switch (type) {
-    case ui::wm::WINDOW_TYPE_CONTROL:
-    case ui::wm::WINDOW_TYPE_UNKNOWN:
-      return false;
-
-    case ui::wm::WINDOW_TYPE_NORMAL:
-    case ui::wm::WINDOW_TYPE_POPUP:
-    case ui::wm::WINDOW_TYPE_PANEL:
-    case ui::wm::WINDOW_TYPE_MENU:
-    case ui::wm::WINDOW_TYPE_TOOLTIP:
-      break;
-  }
-  return true;
-}
-
 inline uint16_t HiWord(uint32_t id) {
   return static_cast<uint16_t>((id >> 16) & 0xFFFF);
 }
 
 inline uint16_t LoWord(uint32_t id) {
   return static_cast<uint16_t>(id & 0xFFFF);
 }
 
 struct WindowPortPropertyDataMus : public WindowPortPropertyData {
   std::string transport_name;
@@ skipping 126 matching lines @@
   DCHECK(window_manager_delegate_);
 
   ui::mojom::WindowManagerWindowTreeFactoryPtr factory;
   connector->ConnectToInterface("service:ui", &factory);
   ui::mojom::WindowTreePtr window_tree;
   factory->CreateWindowTree(GetProxy(&window_tree),
                             binding_.CreateInterfacePtrAndBind());
   SetWindowTree(std::move(window_tree));
 }
 
-void WindowTreeClient::WaitForEmbed() {
-  DCHECK(roots_.empty());
-  // OnEmbed() is the first function called.
-  binding_.WaitForIncomingMethodCall();
-  // TODO(sky): deal with pipe being closed before we get OnEmbed().
-}
-
 void WindowTreeClient::SetClientArea(
     Window* window,
     const gfx::Insets& client_area,
     const std::vector<gfx::Rect>& additional_client_areas) {
   DCHECK(tree_);
   tree_->SetClientArea(WindowMus::Get(window)->server_id(), client_area,
                        additional_client_areas);
 }
 
 void WindowTreeClient::SetHitTestMask(Window* window, const gfx::Rect& mask) {
@@ skipping 155 matching lines @@
         parents.pop_back();
     }
     // This code is only called in a context where there is a parent.
     DCHECK(!parents.empty());
     last_window = NewWindowFromWindowData(
         !parents.empty() ? parents.back() : nullptr, window_data);
   }
 }
 
 std::unique_ptr<WindowPortMus> WindowTreeClient::CreateWindowPortMus(
-    const ui::mojom::WindowDataPtr& window_data) {
+    const ui::mojom::WindowDataPtr& window_data,
+    WindowMusType window_mus_type) {
   std::unique_ptr<WindowPortMus> window_port_mus(
-      base::MakeUnique<WindowPortMus>(this));
+      base::MakeUnique<WindowPortMus>(this, window_mus_type));
   window_port_mus->set_server_id(window_data->window_id);
   RegisterWindowMus(window_port_mus.get());
   return window_port_mus;
 }
 
 void WindowTreeClient::SetLocalPropertiesFromServerProperties(
     WindowMus* window,
     const ui::mojom::WindowDataPtr& window_data) {
   for (auto& pair : window_data->properties) {
     if (pair.second.is_null()) {
       window->SetPropertyFromServer(pair.first, nullptr);
     } else {
       std::vector<uint8_t> stl_value = pair.second.To<std::vector<uint8_t>>();
       window->SetPropertyFromServer(pair.first, &stl_value);
     }
   }
 }
 
-Window* WindowTreeClient::CreateWindowTreeHost(
-    RootWindowType type,
+std::unique_ptr<WindowTreeHostMus> WindowTreeClient::CreateWindowTreeHost(
+    WindowMusType window_mus_type,
     const ui::mojom::WindowDataPtr& window_data,
-    int64_t display_id,
-    Window* content_window) {
-  Window* user_window = nullptr;
-  switch (type) {
-    case RootWindowType::DISPLAY: {
-      DCHECK(!content_window);
-      // See WindowTreeHostMus for details on ownership.
-      WindowTreeHost* window_tree_host = new WindowTreeHostMus(
-          CreateWindowPortMus(window_data), this, type, display_id);
-      user_window = window_tree_host->window();
-      break;
-    }
-    case RootWindowType::EMBED: {
-      DCHECK(!content_window);
-      user_window = new Window(nullptr, CreateWindowPortMus(window_data));
-      user_window->Init(ui::LAYER_TEXTURED);
-      // See WindowTreeHostMus for details on ownership.
-      new WindowTreeHostMus(base::MakeUnique<WindowPortMus>(this, false), this,
-                            type, display_id, user_window);
-      break;
-    }
-    case RootWindowType::TOP_LEVEL: {
-      DCHECK(content_window);
-      user_window = content_window;
-      // See WindowTreeHostMus for details on ownership.
-      new WindowTreeHostMus(base::MakeUnique<WindowPortMus>(this, false), this,
-                            type, display_id, user_window);
-      break;
-    }
+    int64_t display_id) {
+  std::unique_ptr<WindowPortMus> window_port =
+      CreateWindowPortMus(window_data, window_mus_type);
+  roots_.insert(window_port.get());
+  std::unique_ptr<WindowTreeHostMus> window_tree_host =
+      base::MakeUnique<WindowTreeHostMus>(std::move(window_port), this,
+                                          display_id);
+  if (!window_data.is_null()) {
+    SetLocalPropertiesFromServerProperties(
+        WindowMus::Get(window_tree_host->window()), window_data);
   }
-  WindowMus* user_window_mus = WindowMus::Get(user_window);
-  roots_.insert(user_window_mus);
-  if (!window_data.is_null())
-    SetLocalPropertiesFromServerProperties(user_window_mus, window_data);
-  // All WindowTreeHosts are destroyed before this, so we don't need to unset
-  // the DragDropClient.
-  client::SetDragDropClient(user_window->GetRootWindow(),
-                            drag_drop_controller_.get());
-  return user_window;
+  return window_tree_host;
 }
 
 WindowMus* WindowTreeClient::NewWindowFromWindowData(
     WindowMus* parent,
     const ui::mojom::WindowDataPtr& window_data) {
+  // This function is only called for windows coming from other clients.
   std::unique_ptr<WindowPortMus> window_port_mus(
-      CreateWindowPortMus(window_data));
+      CreateWindowPortMus(window_data, WindowMusType::OTHER));
   WindowPortMus* window_port_mus_ptr = window_port_mus.get();
   Window* window = new Window(nullptr, std::move(window_port_mus));
   WindowMus* window_mus = window_port_mus_ptr;
   window->Init(ui::LAYER_NOT_DRAWN);
   SetLocalPropertiesFromServerProperties(window_mus, window_data);
   window_mus->SetBoundsFromServer(window_data->bounds);
   if (parent)
     parent->AddChildFromServer(window_port_mus_ptr);
   if (window_data->visible)
     window_mus->SetVisibleFromServer(true);
@@ skipping 54 matching lines @@
                                    ui::mojom::WindowDataPtr root_data,
                                    int64_t display_id,
                                    Id focused_window_id,
                                    bool drawn) {
   // WARNING: this is only called if WindowTreeClient was created as the
   // result of an embedding.
   client_id_ = client_id;
   WindowTreeConnectionEstablished(window_tree);
 
   DCHECK(roots_.empty());
-  Window* root = CreateWindowTreeHost(RootWindowType::EMBED, root_data,
-                                      display_id, nullptr);
-  // TODO: needs to deal with drawn and display_id.
+  std::unique_ptr<WindowTreeHostMus> window_tree_host =
+      CreateWindowTreeHost(WindowMusType::EMBED, root_data, display_id);
 
   SetFocusFromServer(GetWindowByServerId(focused_window_id));
 
-  delegate_->OnEmbed(root);
+  delegate_->OnEmbed(std::move(window_tree_host));
 }
 
 WindowTreeHost* WindowTreeClient::WmNewDisplayAddedImpl(
     const display::Display& display,
     ui::mojom::WindowDataPtr root_data,
     bool parent_drawn) {
   DCHECK(window_manager_delegate_);
 
-  // TODO: need to deal with display_id and drawn.
-  Window* root = CreateWindowTreeHost(RootWindowType::DISPLAY, root_data,
-                                      display.id(), nullptr);
-  // WindowPrivate(root).LocalSetDisplay(display.id());
-  // WindowPrivate(root).LocalSetParentDrawn(parent_drawn);
+  std::unique_ptr<WindowTreeHostMus> window_tree_host =
+      CreateWindowTreeHost(WindowMusType::DISPLAY, root_data, display.id());
 
-  window_manager_delegate_->OnWmNewDisplay(root, display);
-  return root->GetHost();
+  WindowTreeHost* window_tree_host_ptr = window_tree_host.get();
+  window_manager_delegate_->OnWmNewDisplay(std::move(window_tree_host),
+                                           display);
+  return window_tree_host_ptr;
 }
 
 std::unique_ptr<EventResultCallback>
 WindowTreeClient::CreateEventResultCallback(int32_t event_id) {
   return base::MakeUnique<EventResultCallback>(
       base::Bind(&ui::mojom::WindowTree::OnWindowInputEventAck,
                  base::Unretained(tree_), event_id));
 }
 
 void WindowTreeClient::OnReceivedCursorLocationMemory(
     mojo::ScopedSharedBufferHandle handle) {
   cursor_location_mapping_ = handle->Map(sizeof(base::subtle::Atomic32));
   DCHECK(cursor_location_mapping_);
 }
 
 void WindowTreeClient::SetWindowBoundsFromServer(
     WindowMus* window,
     const gfx::Rect& revert_bounds) {
-  if (!IsRoot(window)) {
-    window->SetBoundsFromServer(revert_bounds);
+  if (IsRoot(window)) {
+    GetWindowTreeHostMus(window)->SetBoundsFromServer(revert_bounds);
     return;
   }
 
-  const gfx::Rect window_tree_host_bounds(gfx::Rect(revert_bounds.size()));
-  std::unique_ptr<WindowMusChangeData> data =
-      window->PrepareForServerBoundsChange(window_tree_host_bounds);
-  // We need the root window to always have an origin of 0x0 locally.
-  WindowTreeHostMus* window_tree_host = GetWindowTreeHostMus(window);
-  window_tree_host->set_origin_offset(revert_bounds.OffsetFromOrigin());
-  window_tree_host->SetBoundsFromServer(window_tree_host_bounds);
+  window->SetBoundsFromServer(revert_bounds);
 }
 
 void WindowTreeClient::SetWindowVisibleFromServer(WindowMus* window,
                                                   bool visible) {
   if (!IsRoot(window)) {
     window->SetVisibleFromServer(visible);
     return;
   }
 
-  std::unique_ptr<WindowMusChangeData> data1 =
+  std::unique_ptr<WindowMusChangeData> data =
       window->PrepareForServerVisibilityChange(visible);
   WindowTreeHostMus* window_tree_host = GetWindowTreeHostMus(window);
   if (visible)
     window_tree_host->Show();
   else
     window_tree_host->Hide();
 }
 
-std::unique_ptr<WindowPortInitData> WindowTreeClient::OnWindowMusCreated(
-    WindowMus* window) {
-  if (window->server_id() != 0 || !window->create_remote_window()) {
-    // This window was created by us, or should not have a window created on
-    // the server.
-    return nullptr;
-  }
+void WindowTreeClient::ScheduleInFlightBoundsChange(
+    WindowMus* window,
+    const gfx::Rect& old_bounds,
+    const gfx::Rect& new_bounds) {
+  const uint32_t change_id = ScheduleInFlightChange(
+      base::MakeUnique<InFlightBoundsChange>(this, window, old_bounds));
+  tree_->SetWindowBounds(change_id, window->server_id(), new_bounds);
+}
+
+void WindowTreeClient::OnWindowMusCreated(WindowMus* window) {
+  if (window->server_id() != kInvalidServerId)
+    return;
 
   window->set_server_id(MakeTransportId(client_id_, next_window_id_++));
   RegisterWindowMus(window);
 
-  const bool create_top_level =
-      !window_manager_delegate_ &&
-      ShouldCreateTopLevel(window->GetWindow()->type());
+  const bool create_top_level = !window_manager_delegate_ && IsRoot(window);
 
   mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties;
   std::set<const void*> property_keys =
       window->GetWindow()->GetAllPropertKeys();
   PropertyConverter* property_converter = delegate_->GetPropertyConverter();
   for (const void* key : property_keys) {
     std::string transport_name;
     std::unique_ptr<std::vector<uint8_t>> transport_value;
     if (!property_converter->ConvertPropertyForTransport(
             window->GetWindow(), key, &transport_name, &transport_value)) {
       continue;
     }
     if (!transport_value) {
       transport_properties[transport_name] = mojo::Array<uint8_t>(nullptr);
     } else {
       transport_properties[transport_name] =
           mojo::Array<uint8_t>::From(*transport_value);
     }
   }
 
   const uint32_t change_id =
       ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
           window, create_top_level ? ChangeType::NEW_TOP_LEVEL_WINDOW
                                    : ChangeType::NEW_WINDOW));
   if (create_top_level) {
-    std::unique_ptr<WindowPortInitData> data(
-        base::MakeUnique<WindowPortInitData>());
     tree_->NewTopLevelWindow(change_id, window->server_id(),
                              std::move(transport_properties));
-    return data;
+  } else {
+    tree_->NewWindow(change_id, window->server_id(),
+                     std::move(transport_properties));
   }
-  tree_->NewWindow(change_id, window->server_id(),
-                   std::move(transport_properties));
-  return nullptr;
-}
-
-void WindowTreeClient::OnWindowMusInitDone(
-    WindowMus* window,
-    std::unique_ptr<WindowPortInitData> init_data) {
-  if (!init_data)
-    return;
-
-  // Delay creating the WindowTreeHost until after Init(), otherwise we trigger
-  // crashes in code that expects window parenting to happen after
-  // Env::NotifyWindowInitialized() is called.
-  //
-  // Use the primary display. We'll get the real display when created.
-  CreateWindowTreeHost(RootWindowType::TOP_LEVEL, nullptr,
-                       display::Screen::GetScreen()->GetPrimaryDisplay().id(),
-                       window->GetWindow());
 }
 
 void WindowTreeClient::OnWindowMusDestroyed(WindowMus* window) {
   if (focused_window_ == window)
     focused_window_ = nullptr;
 
   // TODO: decide how to deal with windows not owned by this client.
   if (WasCreatedByThisClient(window) || IsRoot(window)) {
     const uint32_t change_id =
         ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
@@ skipping 21 matching lines @@
     in_flight_map_.erase(change_id);
 
   const bool was_root = roots_.erase(window) > 0;
   if (!in_destructor_ && was_root && roots_.empty() && is_from_embed_)
     delegate_->OnEmbedRootDestroyed(window->GetWindow());
 }
 
 void WindowTreeClient::OnWindowMusBoundsChanged(WindowMus* window,
                                                 const gfx::Rect& old_bounds,
                                                 const gfx::Rect& new_bounds) {
-  const uint32_t change_id = ScheduleInFlightChange(
-      base::MakeUnique<InFlightBoundsChange>(this, window, old_bounds));
-  gfx::Point origin(new_bounds.origin());
-  if (IsRoot(window)) {
-    // WindowTreeHostMus stores the true origin of root windows.
-    WindowTreeHostMus* window_tree_host = GetWindowTreeHostMus(window);
-    origin += window_tree_host->origin_offset();
-  }
-  tree_->SetWindowBounds(change_id, window->server_id(),
-                         gfx::Rect(origin, new_bounds.size()));
+  // Changes to bounds of root windows are routed through
+  // OnWindowTreeHostBoundsWillChange(). Any bounds that happen here are a side
+  // effect of those and can be ignored.
+  if (IsRoot(window))
+    return;
+
+  ScheduleInFlightBoundsChange(window, old_bounds, new_bounds);
 }
 
 void WindowTreeClient::OnWindowMusAddChild(WindowMus* parent,
                                            WindowMus* child) {
   // TODO: add checks to ensure this can work.
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<CrashInFlightChange>(parent, ChangeType::ADD_CHILD));
   tree_->AddWindow(change_id, parent->server_id(), child->server_id());
 }
 
@@ skipping 245 matching lines @@
   if (!in_flight_map_.count(change_id)) {
     // The window may have been destroyed locally before the server could finish
     // creating the window, and before the server received the notification that
     // the window has been destroyed.
     return;
   }
   std::unique_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
   in_flight_map_.erase(change_id);
 
   WindowMus* window = change->window();
+  WindowTreeHostMus* window_tree_host = GetWindowTreeHostMus(window);
 
   // Drawn state and display-id always come from the server (they can't be
   // modified locally).
-  GetWindowTreeHostMus(window)->set_display_id(display_id);
+  window_tree_host->set_display_id(display_id);
 
   // The default visibilty is false, we only need update visibility if it
   // differs from that.
   if (data->visible) {
     InFlightVisibleChange visible_change(this, window, data->visible);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(visible_change);
     if (current_change)
       current_change->SetRevertValueFrom(visible_change);
     else
@@ skipping 114 matching lines @@
   WindowMus* window = GetWindowByServerId(window_id);
   WindowMus* relative_window = GetWindowByServerId(relative_window_id);
   WindowMus* parent = WindowMus::Get(window->GetWindow()->parent());
   if (window && relative_window && parent &&
       parent == WindowMus::Get(relative_window->GetWindow()->parent())) {
     parent->ReorderFromServer(window, relative_window, direction);
   }
 }
 
 void WindowTreeClient::OnWindowDeleted(Id window_id) {
+  // TODO(sky): decide how best to deal with this. It seems we should let the
+  // delegate do the actualy deletion.
   delete GetWindowByServerId(window_id)->GetWindow();
 }
 
 void WindowTreeClient::OnWindowVisibilityChanged(Id window_id, bool visible) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
   InFlightVisibleChange new_change(this, window, visible);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
@@ skipping 455 matching lines @@
     return;
   }
 
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<InFlightFocusChange>(this, focused_window_));
   focused_window_ = gained_focus_mus;
   tree_->SetFocus(change_id, focused_window_ ? focused_window_->server_id()
                                              : kInvalidServerId);
 }
 
-void WindowTreeClient::SetRootWindowBounds(Window* window, gfx::Rect* bounds) {
-  WindowTreeHostMus* window_tree_host = GetWindowTreeHostMus(window);
-  switch (window_tree_host->root_window_type()) {
-    case RootWindowType::EMBED:
-      NOTREACHED();
-      return;
-    case RootWindowType::TOP_LEVEL:
-      // Top level requests are always in display coordinates.
-      break;
-    case RootWindowType::DISPLAY: {
-      gfx::Point display_relative_origin(bounds->origin());
-      display_relative_origin -=
-          window_tree_host->GetDisplay().bounds().OffsetFromOrigin();
-      bounds->set_origin(display_relative_origin);
-      break;
-    }
-  }
-  // We need the root window to always have an origin of 0x0 locally.
-  window_tree_host->set_origin_offset(bounds->OffsetFromOrigin());
-  bounds->set_origin(gfx::Point());
+void WindowTreeClient::OnWindowTreeHostBoundsWillChange(
+    WindowTreeHostMus* window_tree_host,
+    const gfx::Rect& bounds) {
+  ScheduleInFlightBoundsChange(WindowMus::Get(window_tree_host->window()),
+                               window_tree_host->GetBounds(), bounds);
+}
+
+std::unique_ptr<WindowPortMus> WindowTreeClient::CreateWindowPortForTopLevel() {
+  std::unique_ptr<WindowPortMus> window_port =
+      base::MakeUnique<WindowPortMus>(this, WindowMusType::TOP_LEVEL);
+  roots_.insert(window_port.get());
+  return window_port;
+}
+
+void WindowTreeClient::OnWindowTreeHostCreated(
+    WindowTreeHostMus* window_tree_host) {
+  // All WindowTreeHosts are destroyed before this, so we don't need to unset
+  // the DragDropClient.
+  client::SetDragDropClient(window_tree_host->window(),
+                            drag_drop_controller_.get());
 }
 
 void WindowTreeClient::OnTransientChildWindowAdded(Window* parent,
                                                    Window* transient_child) {
   if (WindowMus::Get(parent)->OnTransientChildAdded(
           WindowMus::Get(transient_child)) == WindowMus::ChangeSource::SERVER) {
     return;
   }
   // The change originated from client code and needs to be sent to the server.
   DCHECK(tree_);
@@ skipping 24 matching lines @@
   return ScheduleInFlightChange(
       base::MakeUnique<InFlightDragChange>(window, ChangeType::DRAG_LOOP));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForCapture(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 }  // namespace aura