aura: Remove layerless windows.

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 22 matching lines @@
 #include "ui/events/event_target_iterator.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
 namespace {
 
-ui::LayerType WindowLayerTypeToUILayerType(WindowLayerType window_layer_type) {
-  switch (window_layer_type) {
-    case WINDOW_LAYER_NONE:
-      break;
-    case WINDOW_LAYER_NOT_DRAWN:
-      return ui::LAYER_NOT_DRAWN;
-    case WINDOW_LAYER_TEXTURED:
-      return ui::LAYER_TEXTURED;
-    case WINDOW_LAYER_SOLID_COLOR:
-      return ui::LAYER_SOLID_COLOR;
-  }
-  NOTREACHED();
-  return ui::LAYER_NOT_DRAWN;
-}
-
 // Used when searching for a Window to stack relative to.
 template <class T>
 T IteratorForDirectionBegin(aura::Window* window);
 
 template <>
 Window::Windows::const_iterator IteratorForDirectionBegin(
     aura::Window* window) {
   return window->children().begin();
 }
 
@@ skipping 142 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()) {
-    if (layer()->owner() == this)
-      layer()->CompleteAllAnimations();
-    layer()->SuppressPaint();
-  }
+  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_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroying(this));
 
   // While we are being destroyed, our target handler may also be in the
   // process of destruction or already destroyed, so do not forward any
   // input events at the ui::EP_TARGET phase.
   set_target_handler(nullptr);
@@ skipping 35 matching lines @@
 
   // Clear properties.
   for (std::map<const void*, Value>::const_iterator iter = prop_map_.begin();
        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);
+  // The layer will either be destroyed by |layer_owner_|'s dtor, or by whoever
+  // acquired it.
+  layer()->set_delegate(NULL);
   DestroyLayer();
 }
 
-void Window::Init(WindowLayerType window_layer_type) {
-  if (window_layer_type != WINDOW_LAYER_NONE) {
-    SetLayer(new ui::Layer(WindowLayerTypeToUILayerType(window_layer_type)));
-    layer()->SetVisible(false);
-    layer()->set_delegate(this);
-    UpdateLayerName();
-    layer()->SetFillsBoundsOpaquely(!transparent_);
-  }
-
+void Window::Init(ui::LayerType layer_type) {
+  SetLayer(new ui::Layer(layer_type));
+  layer()->SetVisible(false);
+  layer()->set_delegate(this);
+  UpdateLayerName();
+  layer()->SetFillsBoundsOpaquely(!transparent_);
   Env::GetInstance()->NotifyWindowInitialized(this);
 }
 
 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;
-
   if (layer())
     UpdateLayerName();
 }
 
 void Window::SetTitle(const base::string16& title) {
   title_ = title;
   FOR_EACH_OBSERVER(WindowObserver,
                     observers_,
                     OnWindowTitleChanged(this));
 }
 
 void Window::SetTransparent(bool transparent) {
   transparent_ = transparent;
   if (layer())
     layer()->SetFillsBoundsOpaquely(!transparent_);
 }
 
 void Window::SetFillsBoundsCompletely(bool fills_bounds) {
-  if (layer())
-    layer()->SetFillsBoundsCompletely(fills_bounds);
+  layer()->SetFillsBoundsCompletely(fills_bounds);
 }
 
 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;
 }
 
 WindowTreeHost* Window::GetHost() {
   return const_cast<WindowTreeHost*>(const_cast<const Window*>(this)->
       GetHost());
 }
 
 const WindowTreeHost* Window::GetHost() const {
   const Window* root_window = GetRootWindow();
   return root_window ? root_window->host_ : NULL;
 }
 
 void Window::Show() {
-  if (layer()) {
-    DCHECK_EQ(visible_, layer()->GetTargetVisibility());
-    // It is not allowed that a window is visible but the layers alpha is fully
-    // transparent since the window would still be considered to be active but
-    // could not be seen.
-    DCHECK(!(visible_ && layer()->GetTargetOpacity() == 0.0f));
-  }
+  DCHECK_EQ(visible_, layer()->GetTargetVisibility());
+  // It is not allowed that a window is visible but the layers alpha is fully
+  // transparent since the window would still be considered to be active but
+  // could not be seen.
+  DCHECK_IMPLIES(visible_, layer()->GetTargetOpacity() > 0.0f);
   SetVisible(true);
 }
 
 void Window::Hide() {
   // RootWindow::OnVisibilityChanged will call ReleaseCapture.
   SetVisible(false);
 }
 
 bool Window::IsVisible() const {
   // Layer visibility can be inconsistent with window visibility, for example
@@ skipping 114 matching lines @@
       parent_->GetAncestorWithLayer(&offset);
   if (!ancestor_with_layer)
     return 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_) {
-    // 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);
-  }
+  layer()->SchedulePaint(rect);
 }
 
 void Window::StackChildAtTop(Window* child) {
   if (children_.size() <= 1 || child == children_.back())
     return;  // In the front already.
   StackChildAbove(child, children_.back());
 }
 
 void Window::StackChildAbove(Window* child, Window* target) {
   StackChildRelativeTo(child, target, STACK_ABOVE);
@@ skipping 267 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();
+  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 {
@@ skipping 132 matching lines @@
       (!layer() && visible == visible_))
     return;  // No change.
 
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowVisibilityChanging(this, visible));
 
   client::VisibilityClient* visibility_client =
       client::GetVisibilityClient(this);
   if (visibility_client)
     visibility_client->UpdateLayerVisibility(this, visible);
-  else if (layer())
+  else
     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);
 }
 
 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_) {
-      gfx::ScopedCanvas scoped_canvas(canvas);
-      canvas->ClipRect(child->bounds());
-      if (!canvas->IsClipEmpty()) {
-        canvas->Translate(child->bounds().OffsetFromOrigin());
-        child->Paint(canvas);
-      }
-    }
-  }
 }
 
 Window* Window::GetWindowForPoint(const gfx::Point& local_point,
                                   bool return_tightest,
                                   bool for_event_handling) {
   if (!IsVisible())
     return NULL;
 
   if ((for_event_handling && !HitTest(local_point)) ||
       (!for_event_handling && !ContainsPoint(local_point)))
@@ skipping 347 matching lines @@
 void Window::NotifyAncestorWindowTransformed(Window* source) {
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnAncestorWindowTransformed(source, this));
   for (Window::Windows::const_iterator it = children_.begin();
        it != children_.end(); ++it) {
     (*it)->NotifyAncestorWindowTransformed(source);
   }
 }
 
 void Window::OnWindowBoundsChanged(const gfx::Rect& old_bounds) {
-  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);
-    }
+  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();
   if (delegate_)
     delegate_->OnBoundsChanged(old_bounds, bounds());
   FOR_EACH_OBSERVER(WindowObserver,
                     observers_,
                     OnWindowBoundsChanged(this, old_bounds, bounds()));
 }
@@ skipping 98 matching lines @@
       return window;
     if (offset)
       *offset += window->bounds().OffsetFromOrigin();
   }
   if (offset)
     *offset = gfx::Vector2d();
   return NULL;
 }
 
 }  // namespace aura