Fixes to 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 13 matching lines @@
 #include "ui/aura/mus/surface_id_handler.h"
 #include "ui/aura/mus/window_manager_delegate.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_tracker.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
 
 #if defined(HiWord)
 #undef HiWord
 #endif
 #if defined(LoWord)
 #undef LoWord
 #endif
@@ skipping 64 matching lines @@
     }
   }
 
  private:
   std::unique_ptr<EventResultCallback> ack_callback_;
   bool handled_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(EventAckHandler);
 };
 
+WindowTreeHostMus* GetWindowTreeHostMus(Window* window) {
+  return static_cast<WindowTreeHostMus*>(window->GetRootWindow()->GetHost());
+}
+
+WindowTreeHostMus* GetWindowTreeHostMus(WindowMus* window) {
+  return GetWindowTreeHostMus(window->GetWindow());
+}
+
 }  // namespace
 
 struct WindowTreeClient::CurrentDragState {
   // The current change id of the current drag an drop ipc.
   uint32_t change_id;
 
   // The effect to return when we send our finish signal.
   uint32_t completed_action;
 
   // Callback executed when a drag initiated by PerformDragDrop() is completed.
@@ skipping 291 matching lines @@
     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(
-    WindowTreeHostType type,
+    RootWindowType type,
     const ui::mojom::WindowDataPtr& window_data,
+    int64_t display_id,
     Window* content_window) {
   Window* user_window = nullptr;
   switch (type) {
-    case WindowTreeHostType::DISPLAY: {
+    case RootWindowType::DISPLAY: {
       DCHECK(!content_window);
-      WindowTreeHost* window_tree_host =
-          new WindowTreeHostMus(CreateWindowPortMus(window_data));
+      // 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 WindowTreeHostType::EMBED: {
+    case RootWindowType::EMBED: {
       DCHECK(!content_window);
       user_window = new Window(nullptr, CreateWindowPortMus(window_data));
       user_window->Init(ui::LAYER_TEXTURED);
-      new WindowTreeHostMus(nullptr, user_window);
+      // See WindowTreeHostMus for details on ownership.
+      new WindowTreeHostMus(nullptr, this, type, display_id, user_window);
       break;
     }
-    case WindowTreeHostType::TOP_LEVEL: {
+    case RootWindowType::TOP_LEVEL: {
       DCHECK(content_window);
       user_window = content_window;
-      new WindowTreeHostMus(nullptr, user_window);
+      // See WindowTreeHostMus for details on ownership.
+      new WindowTreeHostMus(nullptr, this, type, display_id, user_window);
       break;
     }
   }
   WindowMus* user_window_mus = WindowMus::Get(user_window);
   roots_.insert(user_window_mus);
   if (!window_data.is_null())
     SetLocalPropertiesFromServerProperties(user_window_mus, window_data);
   return user_window;
 }
 
@@ skipping 41 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.
   tree_ = window_tree;
   client_id_ = client_id;
 
   DCHECK(roots_.empty());
-  Window* root =
-      CreateWindowTreeHost(WindowTreeHostType::EMBED, root_data, nullptr);
+  Window* root = CreateWindowTreeHost(RootWindowType::EMBED, root_data,
+                                      display_id, nullptr);
   // TODO: needs to deal with drawn and display_id.
 
   SetFocusFromServer(GetWindowByServerId(focused_window_id));
 
   delegate_->OnEmbed(root);
 }
 
 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(WindowTreeHostType::DISPLAY, root_data, nullptr);
+  Window* root = CreateWindowTreeHost(RootWindowType::DISPLAY, root_data,
+                                      display.id(), nullptr);
   // WindowPrivate(root).LocalSetDisplay(display.id());
   // WindowPrivate(root).LocalSetParentDrawn(parent_drawn);
 
   window_manager_delegate_->OnWmNewDisplay(root, display);
   return root->GetHost();
 }
 
 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);
+    return;
+  }
+
+  const gfx::Rect window_tree_host_bounds(gfx::Rect(revert_bounds.size()));
+  std::unique_ptr<WindowMusChangeData> data =
+      window->PrepareForServerBoundsChange(window_tree_host_bounds);

[sadrul, 2016/10/27 20:26:17]

This is really complex!

[sky, 2016/10/27 22:15:04]

Indeed. If you have better ideas I'm all for it.

+  // 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);
+}
+
+void WindowTreeClient::SetWindowVisibleFromServer(WindowMus* window,
+                                                  bool visible) {
+  if (!IsRoot(window)) {
+    window->SetVisibleFromServer(visible);
+    return;
+  }
+
+  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) {
     // This window was created by us and has an associated server window.
     return nullptr;
   }
 
   window->set_server_id(MakeTransportId(client_id_, next_window_id_++));
   RegisterWindowMus(window);
 
@@ skipping 38 matching lines @@
 
 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.
-  CreateWindowTreeHost(WindowTreeHostType::TOP_LEVEL, nullptr,
+  //
+  // 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 =
@@ skipping 23 matching lines @@
 
   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>(window, old_bounds));
-  tree_->SetWindowBounds(change_id, window->server_id(), new_bounds);
+      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()));
 }
 
 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 25 matching lines @@
     direction = ui::mojom::OrderDirection::ABOVE;
   }
   tree_->ReorderWindow(change_id, window->server_id(),
                        relative_window->server_id(), direction);
 }
 
 void WindowTreeClient::OnWindowMusSetVisible(WindowMus* window, bool visible) {
   // TODO: add checks to ensure this can work.
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
-      base::MakeUnique<InFlightVisibleChange>(window, !visible));
+      base::MakeUnique<InFlightVisibleChange>(this, window, !visible));
   tree_->SetWindowVisibility(change_id, window->server_id(), visible);
 }
 
 std::unique_ptr<WindowPortPropertyData>
 WindowTreeClient::OnWindowMusWillChangeProperty(WindowMus* window,
                                                 const void* key) {
   std::unique_ptr<WindowPortPropertyDataMus> data(
       base::MakeUnique<WindowPortPropertyDataMus>());
   if (!delegate_->GetPropertyConverter()->ConvertPropertyForTransport(
           window->GetWindow(), key, &data->transport_name,
@@ skipping 233 matching lines @@
     // 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();
 
-  // TODO: parent drawn and display_id need to route to WindowTreeHost.
   // Drawn state and display-id always come from the server (they can't be
   // modified locally).
+  GetWindowTreeHostMus(window)->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(window, data->visible);
+    InFlightVisibleChange visible_change(this, window, data->visible);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(visible_change);
     if (current_change)
       current_change->SetRevertValueFrom(visible_change);
     else
-      window->SetVisibleFromServer(true);
+      SetWindowVisibleFromServer(window, true);
   }
 
   const gfx::Rect bounds(data->bounds);
   {
-    InFlightBoundsChange bounds_change(window, bounds);
+    InFlightBoundsChange bounds_change(this, window, bounds);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(bounds_change);
     if (current_change)
       current_change->SetRevertValueFrom(bounds_change);
     else if (window->GetWindow()->bounds() != bounds)
-      window->SetBoundsFromServer(bounds);
+      SetWindowBoundsFromServer(window, bounds);
   }
 
   // There is currently no API to bulk set properties, so we iterate over each
   // property individually.
   std::map<std::string, std::vector<uint8_t>> properties =
       data->properties.To<std::map<std::string, std::vector<uint8_t>>>();
   for (const auto& pair : properties) {
     std::unique_ptr<std::vector<uint8_t>> revert_value(
         base::MakeUnique<std::vector<uint8_t>>(pair.second));
     InFlightPropertyChange property_change(window, pair.first,
@@ skipping 11 matching lines @@
   DCHECK_EQ(0u, data->parent_id);
 }
 
 void WindowTreeClient::OnWindowBoundsChanged(Id window_id,
                                              const gfx::Rect& old_bounds,
                                              const gfx::Rect& new_bounds) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
-  InFlightBoundsChange new_change(window, new_bounds);
+  InFlightBoundsChange new_change(this, window, new_bounds);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
-  window->SetBoundsFromServer(new_bounds);
+  SetWindowBoundsFromServer(window, new_bounds);
 }
 
 void WindowTreeClient::OnClientAreaChanged(
     uint32_t window_id,
     const gfx::Insets& new_client_area,
     mojo::Array<gfx::Rect> new_additional_client_areas) {
   // TODO: client area.
   /*
   Window* window = GetWindowByServerId(window_id);
   if (window) {
@@ skipping 74 matching lines @@
 
 Window* WindowTreeClient::GetCaptureWindow() {
   return capture_window_ ? capture_window_->GetWindow() : nullptr;
 }
 
 void WindowTreeClient::OnWindowVisibilityChanged(Id window_id, bool visible) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
-  InFlightVisibleChange new_change(window, visible);
+  InFlightVisibleChange new_change(this, window, visible);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
-  window->SetVisibleFromServer(visible);
+  SetWindowVisibleFromServer(window, visible);
 }
 
 void WindowTreeClient::OnWindowOpacityChanged(Id window_id,
                                               float old_opacity,
                                               float new_opacity) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
   InFlightOpacityChange new_change(window, new_opacity);
@@ skipping 44 matching lines @@
   DCHECK(event);
 
   WindowMus* window = GetWindowByServerId(window_id);  // May be null.
 
   if (event->IsKeyEvent()) {
     DCHECK(!matches_pointer_watcher);  // PointerWatcher isn't for key events.
     if (!window || !window->GetWindow()->GetHost()) {
       tree_->OnWindowInputEventAck(event_id, ui::mojom::EventResult::UNHANDLED);
       return;
     }
-    InputMethodMus* input_method =
-        static_cast<WindowTreeHostMus*>(window->GetWindow()->GetHost())
-            ->input_method();
+    InputMethodMus* input_method = GetWindowTreeHostMus(window)->input_method();
     input_method->DispatchKeyEvent(event->AsKeyEvent(),
                                    CreateEventResultCallback(event_id));
     return;
   }
 
   if (matches_pointer_watcher && has_pointer_watcher_) {
     DCHECK(event->IsPointerEvent());
     delegate_->OnPointerEventObserved(*event->AsPointerEvent(),
                                       window ? window->GetWindow() : nullptr);
   }
 
   // TODO: deal with no window or host here. This could happen if during
   // dispatch a window is deleted or moved. In either case we still need to
   // dispatch. Most likely need the display id.
   if (!window || !window->GetWindow()->GetHost()) {
     tree_->OnWindowInputEventAck(event_id, ui::mojom::EventResult::UNHANDLED);
     return;
   }
 
   EventAckHandler ack_handler(CreateEventResultCallback(event_id));
-  WindowTreeHostMus* host =
-      static_cast<WindowTreeHostMus*>(window->GetWindow()->GetHost());
+  WindowTreeHostMus* host = GetWindowTreeHostMus(window);
   // TODO(moshayedi): crbug.com/617222. No need to convert to ui::MouseEvent or
   // ui::TouchEvent once we have proper support for pointer events.
   if (event->IsMousePointerEvent()) {
     if (event->type() == ui::ET_POINTER_WHEEL_CHANGED) {
       ui::MouseWheelEvent mapped_event(*event->AsPointerEvent());
       host->SendEventToProcessor(&mapped_event);
     } else {
       ui::MouseEvent mapped_event(*event->AsPointerEvent());
       host->SendEventToProcessor(&mapped_event);
     }
@@ skipping 437 matching lines @@
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<InFlightCaptureChange>(this, capture_window_));
   WindowMus* old_capture_window = capture_window_;
   capture_window_ = gained_capture_mus;
   if (capture_window_)
     tree_->SetCapture(change_id, capture_window_->server_id());
   else
     tree_->ReleaseCapture(change_id, old_capture_window->server_id());
 }
 
+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());
+}
+
 }  // namespace aura