Adds a porting layer so aura can be made to work with mus

ui/aura/window.cc

 // Copyright (c) 2012 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/window.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 12 matching lines @@
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/visibility_client.h"
 #include "ui/aura/client/window_stacking_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
+#include "ui/aura/window_port.h"
+#include "ui/aura/window_port_aura.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/scoped_canvas.h"
 
 namespace aura {
 
-class ScopedCursorHider {
- public:
-  explicit ScopedCursorHider(Window* window)
-      : window_(window),
-        hid_cursor_(false) {
-    if (!window_->IsRootWindow())
-      return;
-    const bool cursor_is_in_bounds = window_->GetBoundsInScreen().Contains(
-        Env::GetInstance()->last_mouse_location());
-    client::CursorClient* cursor_client = client::GetCursorClient(window_);
-    if (cursor_is_in_bounds && cursor_client &&
-        cursor_client->IsCursorVisible()) {
-      cursor_client->HideCursor();
-      hid_cursor_ = true;
-    }
-  }
-  ~ScopedCursorHider() {
-    if (!window_->IsRootWindow())
-      return;
+Window::Window(WindowDelegate* delegate) : Window(delegate, nullptr) {}
 
-    // Update the device scale factor of the cursor client only when the last
-    // mouse location is on this root window.
-    if (hid_cursor_) {
-      client::CursorClient* cursor_client = client::GetCursorClient(window_);
-      if (cursor_client) {
-        const display::Display& display =
-            display::Screen::GetScreen()->GetDisplayNearestWindow(window_);
-        cursor_client->SetDisplay(display);
-        cursor_client->ShowCursor();
-      }
-    }
-  }
-
- private:
-  Window* window_;
-  bool hid_cursor_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedCursorHider);
-};
-
-Window::Window(WindowDelegate* delegate)
-    : host_(NULL),
+Window::Window(WindowDelegate* delegate, std::unique_ptr<WindowPort> port)
+    : port_(port.release()),
+      host_(nullptr),
       type_(ui::wm::WINDOW_TYPE_UNKNOWN),
       owned_by_parent_(true),
       delegate_(delegate),
-      parent_(NULL),
+      parent_(nullptr),
       visible_(false),
       id_(kInitialId),
       transparent_(false),
-      user_data_(NULL),
+      user_data_(nullptr),
       ignore_events_(false),
       // Don't notify newly added observers during notification. This causes
       // problems for code that adds an observer as part of an observer
       // notification (such as the workspace code).
       observers_(base::ObserverList<WindowObserver>::NOTIFY_EXISTING_ONLY) {
   SetTargetHandler(delegate_);
 }
 
 Window::~Window() {
+  // See comemnt in header as to why this is done.

[sadrul, 2016/10/26 04:25:55]

*comment

[sky, 2016/10/26 16:25:21]

Done.

+  std::unique_ptr<WindowPort> port(port_);
+
   if (layer()->owner() == this)
     layer()->CompleteAllAnimations();
   layer()->SuppressPaint();
 
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
     delegate_->OnWindowDestroying(this);
   for (WindowObserver& observer : observers_)
     observer.OnWindowDestroying(this);
 
@@ skipping 48 matching lines @@
   }
   prop_map_.clear();
 
   // The layer will either be destroyed by |layer_owner_|'s dtor, or by whoever
   // acquired it.
   layer()->set_delegate(NULL);
   DestroyLayer();
 }
 
 void Window::Init(ui::LayerType layer_type) {
+  if (!port_)
+    port_ = Env::GetInstance()->CreateWindowPort(this).release();
   SetLayer(new ui::Layer(layer_type));
+  std::unique_ptr<WindowPortInitData> init_data = port_->Init(this);
   layer()->SetVisible(false);
   layer()->set_delegate(this);
   UpdateLayerName();
   layer()->SetFillsBoundsOpaquely(!transparent_);
   Env::GetInstance()->NotifyWindowInitialized(this);
+  port_->OnInitDone(std::move(init_data));
 }
 
 void Window::SetType(ui::wm::WindowType type) {
   // Cannot change type after the window is initialized.
   DCHECK(!layer());
   type_ = type;
 }
 
 void Window::SetName(const std::string& name) {
   name_ = name;
@@ skipping 177 matching lines @@
   DCHECK(child->layer()) << "Child has not been Init()ed yt.";
   WindowObserver::HierarchyChangeParams params;
   params.target = child;
   params.new_parent = this;
   params.old_parent = child->parent();
   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING;
   NotifyWindowHierarchyChange(params);
 
   Window* old_root = child->GetRootWindow();
 
+  port_->OnWillAddChild(child);
+
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
       children_.end());
   if (child->parent())
     child->parent()->RemoveChildImpl(child, this);
 
   child->parent_ = this;
   layer()->Add(child->layer());
 
   children_.push_back(child);
   if (layout_manager_)
@@ skipping 13 matching lines @@
 }
 
 void Window::RemoveChild(Window* child) {
   WindowObserver::HierarchyChangeParams params;
   params.target = child;
   params.new_parent = NULL;
   params.old_parent = this;
   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING;
   NotifyWindowHierarchyChange(params);
 
+  port_->OnWillRemoveChild(child);
   RemoveChildImpl(child, NULL);
 
   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED;
   NotifyWindowHierarchyChange(params);
 }
 
 bool Window::Contains(const Window* other) const {
   for (const Window* parent = other; parent; parent = parent->parent_) {
     if (parent == this)
       return true;
@@ skipping 91 matching lines @@
 
 Window* Window::GetEventHandlerForPoint(const gfx::Point& local_point) {
   return GetWindowForPoint(local_point, true, true);
 }
 
 Window* Window::GetTopWindowContainingPoint(const gfx::Point& local_point) {
   return GetWindowForPoint(local_point, false, false);
 }
 
 Window* Window::GetToplevelWindow() {
+  // TODO: this may need to call to the WindowPort. For mus this may need to
+  // return for any top level.
   Window* topmost_window_with_delegate = NULL;
   for (aura::Window* window = this; window != NULL; window = window->parent()) {
     if (window->delegate())
       topmost_window_with_delegate = window;
   }
   return topmost_window_with_delegate;
 }
 
 void Window::Focus() {
   client::FocusClient* client = client::GetFocusClient(this);
@@ skipping 19 matching lines @@
   // The client may forbid certain windows from receiving focus at a given point
   // in time.
   client::EventClient* client = client::GetEventClient(GetRootWindow());
   if (client && !client->CanProcessEventsWithinSubtree(this))
     return false;
 
   return parent_->CanFocus();
 }
 
 bool Window::CanReceiveEvents() const {
+  // TODO(sky): this may want to delegate to the WindowPort as for mus there
+  // isn't a point in descending into windows owned by the client.
   if (IsRootWindow())
     return IsVisible();
 
   // The client may forbid certain windows from receiving events at a given
   // point in time.
   client::EventClient* client = client::GetEventClient(GetRootWindow());
   if (client && !client->CanProcessEventsWithinSubtree(this))
     return false;
 
   return parent_ && IsVisible() && parent_->CanReceiveEvents();
@@ skipping 27 matching lines @@
   if (!root_window)
     return false;
   client::CaptureClient* capture_client = client::GetCaptureClient(root_window);
   return capture_client && capture_client->GetCaptureWindow() == this;
 }
 
 void Window::SuppressPaint() {
   layer()->SuppressPaint();
 }
 
+std::set<const void*> Window::GetAllPropertKeys() const {
+  std::set<const void*> keys;
+  for (auto& pair : prop_map_)
+    keys.insert(pair.first);
+  return keys;
+}
+
 // {Set,Get,Clear}Property are implemented in window_property.h.
 
 void Window::SetNativeWindowProperty(const char* key, void* value) {
   SetPropertyInternal(key, key, NULL, reinterpret_cast<int64_t>(value), 0);
 }
 
 void* Window::GetNativeWindowProperty(const char* key) const {
   return reinterpret_cast<void*>(GetPropertyInternal(key, 0));
 }
 
 void Window::OnDeviceScaleFactorChanged(float device_scale_factor) {
-  ScopedCursorHider hider(this);
-  if (delegate_)
-    delegate_->OnDeviceScaleFactorChanged(device_scale_factor);
+  port_->OnDeviceScaleFactorChanged(device_scale_factor);
 }
 
 #if !defined(NDEBUG)
 std::string Window::GetDebugInfo() const {
   return base::StringPrintf(
       "%s<%d> bounds(%d, %d, %d, %d) %s %s opacity=%.1f",
       name().empty() ? "Unknown" : name().c_str(), id(),
       bounds().x(), bounds().y(), bounds().width(), bounds().height(),
       visible_ ? "WindowVisible" : "WindowHidden",
       layer() ?
@@ skipping 31 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Window, private:
 
 int64_t Window::SetPropertyInternal(const void* key,
                                     const char* name,
                                     PropertyDeallocator deallocator,
                                     int64_t value,
                                     int64_t default_value) {
+  // This code may be called before |port_| has been created.
+  std::unique_ptr<WindowPortPropertyData> data =
+      port_ ? port_->OnWillChangeProperty(key) : nullptr;
   int64_t old = GetPropertyInternal(key, default_value);
   if (value == default_value) {
     prop_map_.erase(key);
   } else {
     Value prop_value;
     prop_value.name = name;
     prop_value.value = value;
     prop_value.deallocator = deallocator;
     prop_map_[key] = prop_value;
   }
+  if (port_)
+    port_->OnPropertyChanged(key, std::move(data));
   for (WindowObserver& observer : observers_)
     observer.OnWindowPropertyChanged(this, key, old);
   return old;
 }
 
 int64_t Window::GetPropertyInternal(const void* key,
                                     int64_t default_value) const {
   std::map<const void*, Value>::const_iterator iter = prop_map_.find(key);
   if (iter == prop_map_.end())
     return default_value;
@@ skipping 37 matching lines @@
   for (WindowObserver& observer : observers_)
     observer.OnWindowVisibilityChanging(this, visible);
 
   client::VisibilityClient* visibility_client =
       client::GetVisibilityClient(this);
   if (visibility_client)
     visibility_client->UpdateLayerVisibility(this, visible);
   else
     layer()->SetVisible(visible);
   visible_ = visible;
+  port_->OnVisibilityChanged(visible);
   SchedulePaint();
   if (parent_ && parent_->layout_manager_)
     parent_->layout_manager_->OnChildWindowVisibilityChanged(this, visible);
 
   if (delegate_)
     delegate_->OnWindowTargetVisibilityChanged(visible);
 
   NotifyWindowVisibilityChanged(this, visible);
 }
 
@@ skipping 109 matching lines @@
 
   // Don't move the child if it is already in the right place.
   if ((direction == STACK_ABOVE && child_i == target_i + 1) ||
       (direction == STACK_BELOW && child_i + 1 == target_i))
     return;
 
   const size_t dest_i =
       direction == STACK_ABOVE ?
       (child_i < target_i ? target_i : target_i + 1) :
       (child_i < target_i ? target_i - 1 : target_i);
+  port_->OnWillMoveChild(child_i, dest_i);
   children_.erase(children_.begin() + child_i);
   children_.insert(children_.begin() + dest_i, child);
 
   StackChildLayerRelativeTo(child, target, direction);
 
   child->OnStackingChanged();
 }
 
 void Window::StackChildLayerRelativeTo(Window* child,
                                        Window* target,
@@ skipping 154 matching lines @@
 }
 
 void Window::OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) {
   DCHECK(layer());
   for (WindowObserver& observer : observers_)
     observer.OnDelegatedFrameDamage(this, damage_rect_in_dip);
 }
 
 void Window::OnLayerBoundsChanged(const gfx::Rect& old_bounds) {
   bounds_ = layer()->bounds();
+
+  // Use |bounds_| as that is the bounds before any animations, which is what
+  // mus wants.
+  port_->OnDidChangeBounds(old_bounds, bounds_);
+
   if (layout_manager_)
     layout_manager_->OnWindowResized();
   if (delegate_)
     delegate_->OnBoundsChanged(old_bounds, bounds_);
   for (auto& observer : observers_)
     observer.OnWindowBoundsChanged(this, old_bounds, bounds_);
 }
 
 bool Window::CanAcceptEvent(const ui::Event& event) {
   // The client may forbid certain windows from receiving events at a given
@@ skipping 54 matching lines @@
     layer_name = "Unnamed Window";
 
   if (id_ != -1)
     layer_name += " " + base::IntToString(id_);
 
   layer()->set_name(layer_name);
 #endif
 }
 
 }  // namespace aura