[ash-md] Adds support for Z-order iteration in views::View

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 51 matching lines @@
   }
   ~ScrollContentsView() override {}
 
  protected:
   // views::View:
   void OnBoundsChanged(const gfx::Rect& previous_bounds) override {
     PositionHeaderRows();
   }
 
   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);
-    }
+    views::View::PaintChildren(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);
+    // Paint header row separators.
+    for (auto& header : headers_)
       did_draw_shadow = PaintDelineation(header, context) || did_draw_shadow;
-    }
 
     // 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();
   }
 
+  View::Views GetChildrenOrderedByVisualOrder() override {
+    // TODO(varkha): Not sure if this is worth it but the array could be a class
+    // member |children_in_visual_order_| and only updated in an override of
+    // ReorderChildLayers() before calling base View::ReorderChildLayers(). Then
+    // this method could simply return |children_in_visual_order_|.
+    View::Views children;
+    // Iterate over regular children and later over the sticky headers to keep
+    // the sticky headers above in Z-order.
+    for (int i = 0; i < child_count(); ++i) {
+      if (child_at(i)->id() != VIEW_ID_STICKY_HEADER)
+        children.push_back(child_at(i));
+    }
+    for (int i = 0; i < child_count(); ++i) {
+      if (child_at(i)->id() == VIEW_ID_STICKY_HEADER)
+        children.push_back(child_at(i));
+    }
+    DCHECK_EQ(child_count(), static_cast<int>(children.size()));
+    return children;
+  }
+
   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)) {
       // We always want padding on the bottom of the scroll contents.
       // We only want padding on the top of the scroll contents if the first
       // child is not a header (in that case, the padding is built into the
       // header).
       DCHECK_EQ(box_layout_, GetLayoutManager());
       box_layout_->set_inside_border_insets(
           gfx::Insets(details.child->id() == VIEW_ID_STICKY_HEADER
                           ? 0
                           : kMenuSeparatorVerticalPadding,
                       0, kMenuSeparatorVerticalPadding, 0));
     }
   }
 
-  // views::ViewTargeterDelegate:
-  View* TargetForRect(View* root, const gfx::Rect& rect) override {
-    // Give header rows first dibs on events.
-    for (auto& header : headers_) {
-      views::View* view = header.view;
-      gfx::Rect local_to_header = rect;
-      local_to_header.Offset(-view->x(), -view->y());
-      if (ViewTargeterDelegate::DoesIntersectRect(view, local_to_header))
-        return ViewTargeterDelegate::TargetForRect(view, local_to_header);
-    }
-    return ViewTargeterDelegate::TargetForRect(root, rect);
-  }
-
  private:
   const SkColor kSeparatorColor = SkColorSetA(SK_ColorBLACK, 0x1F);
   const int kShadowOffsetY = 2;
   const int kShadowBlur = 2;
   // TODO(fukino): Remove this constant once we stop maintaining pre-MD design.
   // crbug.com/614453.
   const int kContentsBetweenChildSpacingNonMd = 1;
 
   // A structure that keeps the original offset of each header between the
   // calls to Layout() to allow keeping track of which view should be sticky.
@@ skipping 13 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());
@@ skipping 340 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