Wires up painting of layerless children

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 14 matching lines @@
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.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/events/event_target_iterator.h"
 #include "ui/gfx/animation/multi_animation.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 {
 
 WindowLayerType UILayerTypeToWindowLayerType(ui::LayerType layer_type) {
   switch (layer_type) {
     case ui::LAYER_NOT_DRAWN:
       return WINDOW_LAYER_NOT_DRAWN;
@@ skipping 777 matching lines @@
   }
 
   // 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)
     OnWindowBoundsChanged(old_bounds, ContainsMouse());
 }
 
 void Window::SetVisible(bool visible) {
-  if (visible == layer_->GetTargetVisibility())
+  if ((layer_ && visible == layer_->GetTargetVisibility()) ||
+      (!layer_ && visible == visible_))
     return;  // No change.
 
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowVisibilityChanging(this, visible));
 
   WindowEventDispatcher* dispatcher = GetDispatcher();
   if (dispatcher)
     dispatcher->DispatchMouseExitToHidingWindow(this);
 
   client::VisibilityClient* visibility_client =
       client::GetVisibilityClient(this);
   if (visibility_client)
     visibility_client->UpdateLayerVisibility(this, visible);
-  else
+  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 (dispatcher)
     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_) {
+      gfx::ScopedCanvas scoped_canvas(canvas);
+      if (canvas->ClipRect(child->bounds())) {
+        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)))
     return NULL;
 
@@ skipping 410 matching lines @@
     delegate_->OnBoundsChanged(old_bounds, bounds());
   FOR_EACH_OBSERVER(WindowObserver,
                     observers_,
                     OnWindowBoundsChanged(this, old_bounds, bounds()));
   WindowEventDispatcher* dispatcher = GetDispatcher();
   if (dispatcher)
     dispatcher->OnWindowBoundsChanged(this, contained_mouse);
 }
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
-  if (delegate_)
-    delegate_->OnPaint(canvas);
+  Paint(canvas);
 }
 
 base::Closure Window::PrepareForLayerBoundsChange() {
   return base::Bind(&Window::OnWindowBoundsChanged, base::Unretained(this),
                     bounds(), ContainsMouse());
 }
 
 bool Window::CanAcceptEvent(const ui::Event& event) {
   // The client may forbid certain windows from receiving events at a given
   // point in time.
@@ skipping 75 matching lines @@
   for (const aura::Window* window = this; window; window = window->parent()) {
     if (window->layer_)
       return window;
     *offset += window->bounds().OffsetFromOrigin();
   }
   *offset = gfx::Vector2d();
   return NULL;
 }
 
 }  // namespace aura