[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 82 matching lines @@
     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);
+      }
+    }

[sadrul, 2016/12/14 00:48:29]

This is really subtle. Can you look at having a test for this?

[varkha, 2016/12/14 17:46:42]

I will.

+  }
+
   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 49 matching lines @@
     bool draw_separator_below;
   };
 
   // Adjusts y-position of header rows allowing one or two rows to stick to the
   // top of the visible viewport.
   void PositionHeaderRows() {
     const int scroll_offset = -y();
     Header* previous_header = nullptr;
     for (auto& header : base::Reversed(headers_)) {
       views::View* header_view = header.view;
-      header.draw_separator_below = false;
+      bool draw_separator_below = false;
       if (header.natural_offset >= scroll_offset) {
         previous_header = &header;
         header_view->SetY(header.natural_offset);
-        continue;
+      } else {
+        if (previous_header &&
+            previous_header->view->y() <=
+                scroll_offset + header_view->height()) {
+          // Lower header displacing the header above.
+          draw_separator_below = true;
+          header_view->SetY(previous_header->view->y() - header_view->height());
+        } else {
+          // A header becomes sticky.
+          header_view->SetY(scroll_offset);
+          header_view->Layout();
+          header_view->SchedulePaint();
+        }
       }
-      if (previous_header &&
-          previous_header->view->y() <= scroll_offset + header_view->height()) {
-        // Lower header displacing the header above.
-        header.draw_separator_below = true;
-        header_view->SetY(previous_header->view->y() - header_view->height());
-      } else {
-        // A header becomes sticky.
-        header_view->SetY(scroll_offset);
-        header_view->Layout();
-        header_view->SchedulePaint();
+      if (header.draw_separator_below != draw_separator_below) {
+        header.draw_separator_below = draw_separator_below;
+        TrayPopupUtils::ShowStickyHeaderSeparator(header_view,
+                                                  draw_separator_below);
       }
-      break;
+      if (header.natural_offset < scroll_offset)
+        break;
     }
   }
 
   // Paints a separator for a header view. The separator can be a horizontal
   // rule or a horizontal shadow, depending on whether the header is sticking to
   // the top of the scroll viewport. The return value indicates whether a shadow
   // was drawn.
   bool PaintDelineation(const Header& header, const ui::PaintContext& context) {
     const View* view = header.view;
 
-    // If the header is where it normally belongs, draw nothing.
-    if (view->y() == header.natural_offset)
+    // If the header is where it normally belongs or If the header is pushed by
+    // a header directly below it, draw nothing.
+    if (view->y() == header.natural_offset || header.draw_separator_below)
       return false;
 
-    // If the header is pushed by a header directly below it, draw a separator.
-    if (header.draw_separator_below) {
-      // TODO(estade): look better at 1.5x scale.
-      ui::PaintRecorder recorder(context, size());
-      gfx::Canvas* canvas = recorder.canvas();
-      gfx::Rect separator = view->bounds();
-      separator.set_y(separator.bottom() - kSeparatorWidth);
-      separator.set_height(kSeparatorWidth);
-      canvas->FillRect(separator, kSeparatorColor);
-      return false;
-    }
-
     // Otherwise, draw a shadow below.
     DrawShadow(context,
                gfx::Rect(0, 0, view->width(), view->bounds().bottom()));
     return true;
   }
 
   // Draws a drop shadow below |shadowed_area|.
   void DrawShadow(const ui::PaintContext& context,
                   const gfx::Rect& shadowed_area) {
     ui::PaintRecorder recorder(context, size());
     gfx::Canvas* canvas = recorder.canvas();
     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