[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 31 matching lines @@
 }
 
 // The index of the horizontal rule below the title row.
 const int kTitleRowSeparatorIndex = 1;
 
 // A view that is used as ScrollView contents. It supports designating some of
 // the children as sticky header rows. The sticky header rows are not scrolled
 // above the top of the visible viewport until the next one "pushes" it up and
 // are painted above other children. To indicate that a child is a sticky header
 // row use set_id(VIEW_ID_STICKY_HEADER).
-class ScrollContentsView : public views::View,
-                           public views::ViewTargeterDelegate {
+class ScrollContentsView : public views::View {
  public:
   ScrollContentsView()
       : box_layout_(new views::BoxLayout(
             views::BoxLayout::kVertical,
             0,
             0,
             UseMd() ? 0 : kContentsBetweenChildSpacingNonMd)) {
-    SetEventTargeter(base::MakeUnique<views::ViewTargeter>(this));
     SetLayoutManager(box_layout_);
   }
   ~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();
   }
 
-  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 &&
-          child->layer() != topmost_layer) {
-        parent_layer->StackAbove(child->layer(), topmost_layer);
-      }
+  View::Views GetChildrenInZOrder() override {
+    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 74 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, SkClipOp::kDifference);
     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