[ash-md] Stacks child layers properly for sticky header rows

ash/common/system/tray/tray_details_view.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 "ash/common/system/tray/tray_details_view.h"
 
 #include "ash/common/ash_view_ids.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/system/tray/fixed_sized_scroll_view.h"
 #include "ash/common/system/tray/system_menu_button.h"
@@ skipping 60 matching lines @@
   void PaintChildren(const ui::PaintContext& context) override {
     for (int i = 0; i < child_count(); ++i) {
       if (child_at(i)->id() != VIEW_ID_STICKY_HEADER && !child_at(i)->layer())
         child_at(i)->Paint(context);
     }
     bool did_draw_shadow = false;
     // Paint header rows above other children in Z-order.
     for (auto& header : headers_) {
       if (!header.view->layer())
         header.view->Paint(context);
       did_draw_shadow = PaintDelineation(header, context) || did_draw_shadow;

[varkha, 2016/12/09 18:59:32]

Self review: This is broken now that the headers have their own layers since the
separator is not painted by the headers themselves. The shadows seem fine.

[varkha, 2016/12/12 18:24:05]

Should be fixed now that a separator is painted by the row view's border as
other separators rather than by the parent view in this file.

     }
 
     // Draw a shadow at the top of the viewport when scrolled, but only if a
     // header didn't already draw one. Overlap the shadow with the separator
     // that's below the header view so we don't get both a separator and a full
     // shadow.
     if (y() != 0 && !did_draw_shadow)
       DrawShadow(context, gfx::Rect(0, 0, width(), -y() - kSeparatorWidth));
   }
 
   void Layout() override {
     views::View::Layout();
     headers_.clear();
     for (int i = 0; i < child_count(); ++i) {
       views::View* view = child_at(i);
       if (view->id() == VIEW_ID_STICKY_HEADER)
         headers_.emplace_back(view);
     }
     PositionHeaderRows();
   }
 
+  void ReorderChildLayers(ui::Layer* parent_layer) override {
+    views::View::ReorderChildLayers(parent_layer);
+    ui::Layer* topmost_layer = TopmostLayer(this, parent_layer);
+    if (!topmost_layer)
+      return;
+
+    // Keep the sticky headers with layers above the rest of the children's
+    // layers. Make sure to avoid changing the stacking order of the layers that
+    // are children of |parent_layer| but do not belong to the same parent view.
+    // Note: this assumes that all views that have id=VIEW_ID_STICKY_HEADER have
+    // a layer.
+    for (int i = child_count() - 1; i >= 0; --i) {
+      View* child = child_at(i);
+      if (child->id() == VIEW_ID_STICKY_HEADER) {
+        if (child->layer() != topmost_layer)
+          parent_layer->StackAbove(child->layer(), topmost_layer);
+      }
+    }
+  }
+
   void ViewHierarchyChanged(
       const ViewHierarchyChangedDetails& details) override {
     if (!details.is_add && details.parent == this) {
       headers_.erase(std::remove_if(headers_.begin(), headers_.end(),
                                     [details](const Header& header) {
                                       return header.view == details.child;
                                     }),
                      headers_.end());
     } else if (details.is_add && details.parent == this &&
                details.child == child_at(0)) {
@@ skipping 114 matching lines @@
     SkPaint paint;
     gfx::ShadowValues shadow;
     shadow.emplace_back(gfx::Vector2d(0, kShadowOffsetY), kShadowBlur,
                         kSeparatorColor);
     paint.setLooper(gfx::CreateShadowDrawLooperCorrectBlur(shadow));
     paint.setAntiAlias(true);
     canvas->ClipRect(shadowed_area, kDifference_SkClipOp);
     canvas->DrawRect(shadowed_area, paint);
   }
 
+  // Recursively iterates through children to return the child layer that is
+  // stacked at the top. Only considers layers that are direct |parent_layer|'s
+  // children.
+  ui::Layer* TopmostLayer(views::View* view, ui::Layer* parent_layer) {
+    DCHECK(parent_layer);
+    // Iterate backwards through the children to find the topmost layer.
+    for (int i = view->child_count() - 1; i >= 0; --i) {
+      views::View* child = view->child_at(i);
+      ui::Layer* layer = TopmostLayer(child, parent_layer);
+      if (layer)
+        return layer;
+    }
+    if (view->layer() && view->layer() != parent_layer &&
+        view->layer()->parent() == parent_layer) {
+      return view->layer();
+    }
+    return nullptr;
+  }
+
   views::BoxLayout* box_layout_;
 
   // Header child views that stick to the top of visible viewport when scrolled.
   std::vector<Header> headers_;
 
   DISALLOW_COPY_AND_ASSIGN(ScrollContentsView);
 };
 
 // Constants for the title row in material design.
 const int kTitleRowVerticalPadding = 4;
@@ skipping 319 matching lines @@
     if (index < child_count() - 1 && child_at(index + 1) != title_row_)
       scroll_border_->set_visible(true);
     else
       scroll_border_->set_visible(false);
   }
 
   views::View::OnPaintBorder(canvas);
 }
 
 }  // namespace ash