Remove Views dependency from window_animations.cc

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 199 matching lines @@
       user_data_(NULL),
       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_(ObserverList<WindowObserver>::NOTIFY_EXISTING_ONLY) {
   set_target_handler(delegate_);
 }
 
 Window::~Window() {
-  // |layer_| can be NULL during tests, or if this Window is layerless.
-  if (layer_)
-    layer_->SuppressPaint();
+  // |layer()| can be NULL during tests, or if this Window is layerless.
+  if (layer())
+    layer()->SuppressPaint();
 
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
     delegate_->OnWindowDestroying(this);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroying(this));
 
   // Let the root know so that it can remove any references to us.
   WindowTreeHost* host = GetHost();
   if (host)
     host->dispatcher()->OnWindowDestroying(this);
@@ skipping 20 matching lines @@
        iter != prop_map_.end();
        ++iter) {
     if (iter->second.deallocator)
       (*iter->second.deallocator)(iter->second.value);
   }
   prop_map_.clear();
 
   // If we have layer it will either be destroyed by |layer_owner_|'s dtor, or
   // by whoever acquired it. We don't have a layer if Init() wasn't invoked or
   // we are layerless.
-  if (layer_) {
-    layer_->set_delegate(NULL);
-    layer_ = NULL;
-  }
+  if (layer())
+    layer()->set_delegate(NULL);
+  DestroyLayer();
 }
 
 void Window::Init(WindowLayerType window_layer_type) {
   if (window_layer_type != WINDOW_LAYER_NONE) {
-    layer_ = new ui::Layer(WindowLayerTypeToUILayerType(window_layer_type));
-    layer_owner_.reset(layer_);
-    layer_->SetVisible(false);
-    layer_->set_delegate(this);
+    SetLayer(new ui::Layer(WindowLayerTypeToUILayerType(window_layer_type)));
+    layer()->SetVisible(false);
+    layer()->set_delegate(this);
     UpdateLayerName(name_);
-    layer_->SetFillsBoundsOpaquely(!transparent_);
+    layer()->SetFillsBoundsOpaquely(!transparent_);
   }
 
   Env::GetInstance()->NotifyWindowInitialized(this);
 }
 
 ui::Layer* Window::RecreateLayer() {
   // Disconnect the old layer, but don't delete it.
   ui::Layer* old_layer = AcquireLayer();
   if (!old_layer)
     return NULL;
 
   bounds_.SetRect(0, 0, 0, 0);
 
   old_layer->set_delegate(NULL);
 
-  layer_ = new ui::Layer(old_layer->type());
-  layer_owner_.reset(layer_);
-  layer_->SetVisible(old_layer->visible());
-  layer_->set_scale_content(old_layer->scale_content());
-  layer_->set_delegate(this);
-  layer_->SetMasksToBounds(old_layer->GetMasksToBounds());
+  SetLayer(new ui::Layer(old_layer->type()));
+  layer()->SetVisible(old_layer->visible());
+  layer()->set_scale_content(old_layer->scale_content());
+  layer()->set_delegate(this);
+  layer()->SetMasksToBounds(old_layer->GetMasksToBounds());
 
   if (delegate_)
-    delegate_->DidRecreateLayer(old_layer, layer_);
+    delegate_->DidRecreateLayer(old_layer, layer());
 
   UpdateLayerName(name_);
-  layer_->SetFillsBoundsOpaquely(!transparent_);
+  layer()->SetFillsBoundsOpaquely(!transparent_);
   // Install new layer as a sibling of the old layer, stacked below it.
   if (old_layer->parent()) {
-    old_layer->parent()->Add(layer_);
-    old_layer->parent()->StackBelow(layer_, old_layer);
+    old_layer->parent()->Add(layer());
+    old_layer->parent()->StackBelow(layer(), old_layer);
   }
   // Migrate all the child layers over to the new layer. Copy the list because
   // the items are removed during iteration.
   std::vector<ui::Layer*> children_copy = old_layer->children();
   for (std::vector<ui::Layer*>::const_iterator it = children_copy.begin();
        it != children_copy.end();
        ++it) {
     ui::Layer* child = *it;
-    layer_->Add(child);
+    layer()->Add(child);
   }
   return old_layer;
 }
 
 void Window::SetType(ui::wm::WindowType type) {
   // Cannot change type after the window is initialized.
-  DCHECK(!layer_);
+  DCHECK(!layer());
   type_ = type;
 }
 
 void Window::SetName(const std::string& name) {
   name_ = name;
 
-  if (layer_)
+  if (layer())
     UpdateLayerName(name_);
 }
 
 void Window::SetTransparent(bool transparent) {
   transparent_ = transparent;
-  if (layer_)
-    layer_->SetFillsBoundsOpaquely(!transparent_);
+  if (layer())
+    layer()->SetFillsBoundsOpaquely(!transparent_);
 }
 
 Window* Window::GetRootWindow() {
   return const_cast<Window*>(
       static_cast<const Window*>(this)->GetRootWindow());
 }
 
 const Window* Window::GetRootWindow() const {
   return IsRootWindow() ? this : parent_ ? parent_->GetRootWindow() : NULL;
 }
@@ skipping 18 matching lines @@
 }
 
 bool Window::IsVisible() const {
   // Layer visibility can be inconsistent with window visibility, for example
   // when a Window is hidden, we want this function to return false immediately
   // after, even though the client may decide to animate the hide effect (and
   // so the layer will be visible for some time after Hide() is called).
   for (const Window* window = this; window; window = window->parent()) {
     if (!window->visible_)
       return false;
-    if (window->layer_)
-      return window->layer_->IsDrawn();
+    if (window->layer())
+      return window->layer()->IsDrawn();
   }
   return false;
 }
 
 gfx::Rect Window::GetBoundsInRootWindow() const {
   // TODO(beng): There may be a better way to handle this, and the existing code
   //             is likely wrong anyway in a multi-display world, but this will
   //             do for now.
   if (!GetRootWindow())
     return bounds();
@@ skipping 11 matching lines @@
     if (screen_position_client) {
       gfx::Point origin = bounds.origin();
       screen_position_client->ConvertPointToScreen(root, &origin);
       bounds.set_origin(origin);
     }
   }
   return bounds;
 }
 
 void Window::SetTransform(const gfx::Transform& transform) {
-  if (!layer_) {
+  if (!layer()) {
     // Transforms aren't supported on layerless windows.
     NOTREACHED();
     return;
   }
   WindowEventDispatcher* dispatcher = GetHost()->dispatcher();
   bool contained_mouse = IsVisible() && dispatcher &&
       ContainsPointInRoot(dispatcher->GetLastMouseLocationInRoot());
-  layer_->SetTransform(transform);
+  layer()->SetTransform(transform);
   if (dispatcher)
     dispatcher->OnWindowTransformed(this, contained_mouse);
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   if (layout_manager == layout_manager_)
     return;
   layout_manager_.reset(layout_manager);
   if (!layout_manager)
     return;
@@ skipping 26 matching lines @@
     gfx::Point origin = new_bounds_in_screen.origin();
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(root);
     screen_position_client->SetBounds(this, new_bounds_in_screen, dst_display);
     return;
   }
   SetBounds(new_bounds_in_screen);
 }
 
 gfx::Rect Window::GetTargetBounds() const {
-  if (!layer_)
+  if (!layer())
     return bounds();
 
-  if (!parent_ || parent_->layer_)
-    return layer_->GetTargetBounds();
+  if (!parent_ || parent_->layer())
+    return layer()->GetTargetBounds();
 
   // We have a layer but our parent (who is valid) doesn't. This means the
   // coordinates of the layer are relative to the first ancestor with a layer;
   // convert to be relative to parent.
   gfx::Vector2d offset;
   const aura::Window* ancestor_with_layer =
       parent_->GetAncestorWithLayer(&offset);
   if (!ancestor_with_layer)
-    return layer_->GetTargetBounds();
+    return layer()->GetTargetBounds();
 
-  gfx::Rect layer_target_bounds = layer_->GetTargetBounds();
+  gfx::Rect layer_target_bounds = layer()->GetTargetBounds();
   layer_target_bounds -= offset;
   return layer_target_bounds;
 }
 
 void Window::SchedulePaintInRect(const gfx::Rect& rect) {
-  if (!layer_ && parent_) {
+  if (!layer() && parent_) {
     // Notification of paint scheduled happens for the window with a layer.
     gfx::Rect parent_rect(bounds().size());
     parent_rect.Intersect(rect);
     if (!parent_rect.IsEmpty()) {
       parent_rect.Offset(bounds().origin().OffsetFromOrigin());
       parent_->SchedulePaintInRect(parent_rect);
     }
-  } else if (layer_ && layer_->SchedulePaint(rect)) {
+  } else if (layer() && layer()->SchedulePaint(rect)) {
     FOR_EACH_OBSERVER(
         WindowObserver, observers_, OnWindowPaintScheduled(this, rect));
   }
 }
 
 void Window::StackChildAtTop(Window* child) {
   if (children_.size() <= 1 || child == children_.back())
     return;  // In the front already.
   StackChildAbove(child, children_.back());
 }
@@ skipping 97 matching lines @@
   if (!source)
     return;
   if (source->GetRootWindow() != target->GetRootWindow()) {
     client::ScreenPositionClient* source_client =
         client::GetScreenPositionClient(source->GetRootWindow());
     source_client->ConvertPointToScreen(source, point);
 
     client::ScreenPositionClient* target_client =
         client::GetScreenPositionClient(target->GetRootWindow());
     target_client->ConvertPointFromScreen(target, point);
-  } else if ((source != target) && (!source->layer_ || !target->layer_)) {
-    if (!source->layer_) {
+  } else if ((source != target) && (!source->layer() || !target->layer())) {
+    if (!source->layer()) {
       gfx::Vector2d offset_to_layer;
       source = source->GetAncestorWithLayer(&offset_to_layer);
       *point += offset_to_layer;
     }
-    if (!target->layer_) {
+    if (!target->layer()) {
       gfx::Vector2d offset_to_layer;
       target = target->GetAncestorWithLayer(&offset_to_layer);
       *point -= offset_to_layer;
     }
-    ui::Layer::ConvertPointToLayer(source->layer_, target->layer_, point);
+    ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
   } else {
-    ui::Layer::ConvertPointToLayer(source->layer_, target->layer_, point);
+    ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
   }
 }
 
 void Window::MoveCursorTo(const gfx::Point& point_in_window) {
   Window* root_window = GetRootWindow();
   DCHECK(root_window);
   gfx::Point point_in_root(point_in_window);
   ConvertPointToTarget(this, root_window, &point_in_root);
   root_window->GetHost()->MoveCursorTo(point_in_root);
 }
@@ skipping 120 matching lines @@
 
 bool Window::HasCapture() {
   Window* root_window = GetRootWindow();
   if (!root_window)
     return false;
   client::CaptureClient* capture_client = client::GetCaptureClient(root_window);
   return capture_client && capture_client->GetCaptureWindow() == this;
 }
 
 void Window::SuppressPaint() {
-  if (layer_)
-    layer_->SuppressPaint();
+  if (layer())
+    layer()->SuppressPaint();
 }
 
 // {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>(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 (IsRootWindow())
     host_->OnDeviceScaleFactorChanged(device_scale_factor);
   if (delegate_)
     delegate_->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_ ?
-          (layer_->GetTargetVisibility() ? "LayerVisible" : "LayerHidden") :
+      layer() ?
+          (layer()->GetTargetVisibility() ? "LayerVisible" : "LayerHidden") :
           "NoLayer",
-      layer_ ? layer_->opacity() : 1.0f);
+      layer() ? layer()->opacity() : 1.0f);
 }
 
 void Window::PrintWindowHierarchy(int depth) const {
   VLOG(0) << base::StringPrintf(
       "%*s%s", depth * 2, "", GetDebugInfo().c_str());
   for (Windows::const_iterator it = children_.begin();
        it != children_.end(); ++it) {
     Window* child = *it;
     child->PrintWindowHierarchy(depth + 1);
   }
@@ skipping 73 matching lines @@
     actual_new_bounds.set_width(
         std::max(min_size.width(), actual_new_bounds.width()));
     actual_new_bounds.set_height(
         std::max(min_size.height(), actual_new_bounds.height()));
   }
 
   gfx::Rect old_bounds = GetTargetBounds();
 
   // Always need to set the layer's bounds -- even if it is to the same thing.
   // This may cause important side effects such as stopping animation.
-  if (!layer_) {
+  if (!layer()) {
     const gfx::Vector2d origin_delta = new_bounds.OffsetFromOrigin() -
         bounds_.OffsetFromOrigin();
     bounds_ = new_bounds;
     OffsetLayerBounds(origin_delta);
   } else {
-    if (parent_ && !parent_->layer_) {
+    if (parent_ && !parent_->layer()) {
       gfx::Vector2d offset;
       const aura::Window* ancestor_with_layer =
           parent_->GetAncestorWithLayer(&offset);
       if (ancestor_with_layer)
         actual_new_bounds.Offset(offset);
     }
-    layer_->SetBounds(actual_new_bounds);
+    layer()->SetBounds(actual_new_bounds);
   }
 
   // If we are currently not the layer's delegate, we will not get bounds
   // changed notification from the layer (this typically happens after animating
   // hidden). We must notify ourselves.
-  if (!layer_ || layer_->delegate() != this)
+  if (!layer() || layer()->delegate() != this)
     OnWindowBoundsChanged(old_bounds, ContainsMouse());
 }
 
 void Window::SetVisible(bool visible) {
-  if ((layer_ && visible == layer_->GetTargetVisibility()) ||
-      (!layer_ && visible == visible_))
+  if ((layer() && visible == layer()->GetTargetVisibility()) ||
+      (!layer() && visible == visible_))
     return;  // No change.
 
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowVisibilityChanging(this, visible));
 
   WindowTreeHost* host = GetHost();
   if (host)
     host->dispatcher()->DispatchMouseExitToHidingWindow(this);
 
   client::VisibilityClient* visibility_client =
       client::GetVisibilityClient(this);
   if (visibility_client)
     visibility_client->UpdateLayerVisibility(this, visible);
-  else if (layer_)
-    layer_->SetVisible(visible);
+  else if (layer())
+    layer()->SetVisible(visible);
   visible_ = visible;
   SchedulePaint();
   if (parent_ && parent_->layout_manager_)
     parent_->layout_manager_->OnChildWindowVisibilityChanged(this, visible);
 
   if (delegate_)
     delegate_->OnWindowTargetVisibilityChanged(visible);
 
   NotifyWindowVisibilityChanged(this, visible);
 
   if (host)
     host->dispatcher()->OnWindowVisibilityChanged(this, visible);
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
 void Window::Paint(gfx::Canvas* canvas) {
   if (delegate_)
     delegate_->OnPaint(canvas);
   PaintLayerlessChildren(canvas);
 }
 
 void Window::PaintLayerlessChildren(gfx::Canvas* canvas) {
   for (size_t i = 0, count = children_.size(); i < count; ++i) {
     Window* child = children_[i];
-    if (!child->layer_ && child->visible_) {
+    if (!child->layer() && child->visible_) {
       gfx::ScopedCanvas scoped_canvas(canvas);
       canvas->ClipRect(child->bounds());
       if (!canvas->IsClipEmpty()) {
         canvas->Translate(child->bounds().OffsetFromOrigin());
         child->Paint(canvas);
       }
     }
   }
 }
 
@@ skipping 59 matching lines @@
   Window* root_window = child->GetRootWindow();
   Window* new_root_window = new_parent ? new_parent->GetRootWindow() : NULL;
   if (root_window && root_window != new_root_window) {
     root_window->GetHost()->dispatcher()->OnWindowRemovedFromRootWindow(
         child, new_root_window);
     child->NotifyRemovingFromRootWindow();
   }
 
   gfx::Vector2d offset;
   GetAncestorWithLayer(&offset);
-  child->UnparentLayers(!layer_, offset);
+  child->UnparentLayers(!layer(), offset);
   child->parent_ = NULL;
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   children_.erase(i);
   child->OnParentChanged();
   if (layout_manager_)
     layout_manager_->OnWindowRemovedFromLayout(child);
 }
 
 void Window::UnparentLayers(bool has_layerless_ancestor,
                             const gfx::Vector2d& offset) {
-  if (!layer_) {
+  if (!layer()) {
     const gfx::Vector2d new_offset = offset + bounds().OffsetFromOrigin();
     for (size_t i = 0; i < children_.size(); ++i) {
       children_[i]->UnparentLayers(true, new_offset);
     }
   } else {
     // Only remove the layer if we still own it.  Someone else may have acquired
     // ownership of it via AcquireLayer() and may expect the hierarchy to go
     // unchanged as the Window is destroyed.
-    if (layer_owner_) {
-      if (layer_->parent())
-        layer_->parent()->Remove(layer_);
+    if (OwnsLayer()) {
+      if (layer()->parent())
+        layer()->parent()->Remove(layer());
       if (has_layerless_ancestor) {
         const gfx::Rect real_bounds(bounds_);
-        gfx::Rect layer_bounds(layer_->bounds());
+        gfx::Rect layer_bounds(layer()->bounds());
         layer_bounds.Offset(-offset);
-        layer_->SetBounds(layer_bounds);
+        layer()->SetBounds(layer_bounds);
         bounds_ = real_bounds;
       }
     }
   }
 }
 
 void Window::ReparentLayers(ui::Layer* parent_layer,
                             const gfx::Vector2d& offset) {
-  if (!layer_) {
+  if (!layer()) {
     for (size_t i = 0; i < children_.size(); ++i) {
       children_[i]->ReparentLayers(
           parent_layer,
           offset + children_[i]->bounds().OffsetFromOrigin());
     }
   } else {
     const gfx::Rect real_bounds(bounds());
-    parent_layer->Add(layer_);
-    gfx::Rect layer_bounds(layer_->bounds().size());
+    parent_layer->Add(layer());
+    gfx::Rect layer_bounds(layer()->bounds().size());
     layer_bounds += offset;
-    layer_->SetBounds(layer_bounds);
+    layer()->SetBounds(layer_bounds);
     bounds_ = real_bounds;
   }
 }
 
 void Window::OffsetLayerBounds(const gfx::Vector2d& offset) {
-  if (!layer_) {
+  if (!layer()) {
     for (size_t i = 0; i < children_.size(); ++i)
       children_[i]->OffsetLayerBounds(offset);
   } else {
-    gfx::Rect layer_bounds(layer_->bounds());
+    gfx::Rect layer_bounds(layer()->bounds());
     layer_bounds += offset;
-    layer_->SetBounds(layer_bounds);
+    layer()->SetBounds(layer_bounds);
   }
 }
 
 void Window::OnParentChanged() {
   FOR_EACH_OBSERVER(
       WindowObserver, observers_, OnWindowParentChanged(this, parent_));
 }
 
 void Window::StackChildRelativeTo(Window* child,
                                   Window* target,
@@ skipping 34 matching lines @@
 
 void Window::StackChildLayerRelativeTo(Window* child,
                                        Window* target,
                                        StackDirection direction) {
   Window* ancestor_with_layer = GetAncestorWithLayer(NULL);
   ui::Layer* ancestor_layer =
       ancestor_with_layer ? ancestor_with_layer->layer() : NULL;
   if (!ancestor_layer)
     return;
 
-  if (child->layer_ && target->layer_) {
+  if (child->layer() && target->layer()) {
     if (direction == STACK_ABOVE)
-      ancestor_layer->StackAbove(child->layer_, target->layer_);
+      ancestor_layer->StackAbove(child->layer(), target->layer());
     else
-      ancestor_layer->StackBelow(child->layer_, target->layer_);
+      ancestor_layer->StackBelow(child->layer(), target->layer());
     return;
   }
   typedef std::vector<ui::Layer*> Layers;
   Layers layers;
   GetLayersToStack(child, &layers);
   if (layers.empty())
     return;
 
   ui::Layer* target_layer;
   if (direction == STACK_ABOVE) {
@@ skipping 149 matching lines @@
 void Window::NotifyWindowVisibilityChangedUp(aura::Window* target,
                                              bool visible) {
   for (Window* window = this; window; window = window->parent()) {
     bool ret = window->NotifyWindowVisibilityChangedAtReceiver(target, visible);
     DCHECK(ret);
   }
 }
 
 void Window::OnWindowBoundsChanged(const gfx::Rect& old_bounds,
                                    bool contained_mouse) {
-  if (layer_) {
-    bounds_ = layer_->bounds();
-    if (parent_ && !parent_->layer_) {
+  if (layer()) {
+    bounds_ = layer()->bounds();
+    if (parent_ && !parent_->layer()) {
       gfx::Vector2d offset;
       aura::Window* ancestor_with_layer =
           parent_->GetAncestorWithLayer(&offset);
       if (ancestor_with_layer)
         bounds_.Offset(-offset);
     }
   }
 
   if (layout_manager_)
     layout_manager_->OnWindowResized();
@@ skipping 61 matching lines @@
 }
 
 void Window::ConvertEventToTarget(ui::EventTarget* target,
                                   ui::LocatedEvent* event) {
   event->ConvertLocationToTarget(this,
                                  static_cast<Window*>(target));
 }
 
 void Window::UpdateLayerName(const std::string& name) {
 #if !defined(NDEBUG)
-  DCHECK(layer_);
+  DCHECK(layer());
 
   std::string layer_name(name_);
   if (layer_name.empty())
     layer_name = "Unnamed Window";
 
   if (id_ != -1)
     layer_name += " " + base::IntToString(id_);
 
-  layer_->set_name(layer_name);
+  layer()->set_name(layer_name);
 #endif
 }
 
 bool Window::ContainsMouse() {
   bool contains_mouse = false;
   if (IsVisible()) {
     WindowTreeHost* host = GetHost();
     contains_mouse = host &&
         ContainsPointInRoot(host->dispatcher()->GetLastMouseLocationInRoot());
   }
   return contains_mouse;
 }
 
 const Window* Window::GetAncestorWithLayer(gfx::Vector2d* offset) const {
   for (const aura::Window* window = this; window; window = window->parent()) {
-    if (window->layer_)
+    if (window->layer())
       return window;
     if (offset)
       *offset += window->bounds().OffsetFromOrigin();
   }
   if (offset)
     *offset = gfx::Vector2d();
   return NULL;
 }
 
 }  // namespace aura