Improving the appearance of overlay scrollbars

ui/views/controls/scroll_view_unittest.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/views/controls/scroll_view.h"
 
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 149 matching lines @@
  private:
   // Disable overlay scrollers by default. This needs to be set before
   // |scroll_view_| is initialized, otherwise scrollers will try to animate to
   // change modes, which requires a MessageLoop to exist. Tests should only
   // modify this via SetOverlayScrollersEnabled().
   std::unique_ptr<ui::test::ScopedPreferredScrollerStyle> scroller_style_ =
       base::MakeUnique<ui::test::ScopedPreferredScrollerStyle>(false);
 
  protected:
 #endif
+  int VerticalScrollBarWidth() {
+    return scroll_view_.vertical_scroll_bar()->GetThickness();
+  }
+
+  int HorizontalScrollBarHeight() {
+    return scroll_view_.horizontal_scroll_bar()->GetThickness();
+  }
+
   ScrollView scroll_view_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScrollViewTest);
 };
 
 // Test harness that includes a Widget to help test ui::Event handling.
 class WidgetScrollViewTest : public test::WidgetTest,
                              public ui::CompositorObserver {
  public:
@@ skipping 122 matching lines @@
 }
 
 // Verifies the scrollbars are added as necessary.
 // If on Mac, test the non-overlay scrollbars.
 TEST_F(ScrollViewTest, ScrollBars) {
   View* contents = InstallContents();
 
   // Size the contents such that vertical scrollbar is needed.
   contents->SetBounds(0, 0, 50, 400);
   scroll_view_.Layout();
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(),
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutWidth(),
             contents->parent()->width());
   EXPECT_EQ(100, contents->parent()->height());
   CheckScrollbarVisibility(scroll_view_, VERTICAL, true);
   CheckScrollbarVisibility(scroll_view_, HORIZONTAL, false);
   EXPECT_TRUE(!scroll_view_.horizontal_scroll_bar() ||
               !scroll_view_.horizontal_scroll_bar()->visible());
   ASSERT_TRUE(scroll_view_.vertical_scroll_bar() != NULL);
   EXPECT_TRUE(scroll_view_.vertical_scroll_bar()->visible());
 
   // Size the contents such that horizontal scrollbar is needed.
   contents->SetBounds(0, 0, 400, 50);
   scroll_view_.Layout();
   EXPECT_EQ(100, contents->parent()->width());
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarHeight(),
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutHeight(),
             contents->parent()->height());
   CheckScrollbarVisibility(scroll_view_, VERTICAL, false);
   CheckScrollbarVisibility(scroll_view_, HORIZONTAL, true);
 
   // Both horizontal and vertical.
   contents->SetBounds(0, 0, 300, 400);
   scroll_view_.Layout();
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(),
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutWidth(),
             contents->parent()->width());
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarHeight(),
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutHeight(),
             contents->parent()->height());
   CheckScrollbarVisibility(scroll_view_, VERTICAL, true);
   CheckScrollbarVisibility(scroll_view_, HORIZONTAL, true);
 
   // Add a border, test vertical scrollbar.
   const int kTopPadding = 1;
   const int kLeftPadding = 2;
   const int kBottomPadding = 3;
   const int kRightPadding = 4;
   scroll_view_.SetBorder(CreateEmptyBorder(kTopPadding, kLeftPadding,
                                            kBottomPadding, kRightPadding));
   contents->SetBounds(0, 0, 50, 400);
   scroll_view_.Layout();
-  EXPECT_EQ(
-      100 - scroll_view_.GetScrollBarWidth() - kLeftPadding - kRightPadding,
-      contents->parent()->width());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutWidth() - kLeftPadding -
+                kRightPadding,
+            contents->parent()->width());
   EXPECT_EQ(100 - kTopPadding - kBottomPadding, contents->parent()->height());
   EXPECT_TRUE(!scroll_view_.horizontal_scroll_bar() ||
               !scroll_view_.horizontal_scroll_bar()->visible());
   ASSERT_TRUE(scroll_view_.vertical_scroll_bar() != NULL);
   EXPECT_TRUE(scroll_view_.vertical_scroll_bar()->visible());
   gfx::Rect bounds = scroll_view_.vertical_scroll_bar()->bounds();
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth() - kRightPadding, bounds.x());
+  EXPECT_EQ(100 - VerticalScrollBarWidth() - kRightPadding, bounds.x());
   EXPECT_EQ(100 - kRightPadding, bounds.right());
   EXPECT_EQ(kTopPadding, bounds.y());
   EXPECT_EQ(100 - kBottomPadding, bounds.bottom());
 
   // Horizontal with border.
   contents->SetBounds(0, 0, 400, 50);
   scroll_view_.Layout();
   EXPECT_EQ(100 - kLeftPadding - kRightPadding, contents->parent()->width());
-  EXPECT_EQ(
-      100 - scroll_view_.GetScrollBarHeight() - kTopPadding - kBottomPadding,
-      contents->parent()->height());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutHeight() - kTopPadding -
+                kBottomPadding,
+            contents->parent()->height());
   ASSERT_TRUE(scroll_view_.horizontal_scroll_bar() != NULL);
   EXPECT_TRUE(scroll_view_.horizontal_scroll_bar()->visible());
   EXPECT_TRUE(!scroll_view_.vertical_scroll_bar() ||
               !scroll_view_.vertical_scroll_bar()->visible());
   bounds = scroll_view_.horizontal_scroll_bar()->bounds();
   EXPECT_EQ(kLeftPadding, bounds.x());
   EXPECT_EQ(100 - kRightPadding, bounds.right());
-  EXPECT_EQ(100 - kBottomPadding - scroll_view_.GetScrollBarHeight(),
-            bounds.y());
+  EXPECT_EQ(100 - kBottomPadding - HorizontalScrollBarHeight(), bounds.y());
   EXPECT_EQ(100 - kBottomPadding, bounds.bottom());
 
   // Both horizontal and vertical with border.
   contents->SetBounds(0, 0, 300, 400);
   scroll_view_.Layout();
-  EXPECT_EQ(
-      100 - scroll_view_.GetScrollBarWidth() - kLeftPadding - kRightPadding,
-      contents->parent()->width());
-  EXPECT_EQ(
-      100 - scroll_view_.GetScrollBarHeight() - kTopPadding - kBottomPadding,
-      contents->parent()->height());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutWidth() - kLeftPadding -
+                kRightPadding,
+            contents->parent()->width());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutHeight() - kTopPadding -
+                kBottomPadding,
+            contents->parent()->height());
   bounds = scroll_view_.horizontal_scroll_bar()->bounds();
   // Check horiz.
   ASSERT_TRUE(scroll_view_.horizontal_scroll_bar() != NULL);
   EXPECT_TRUE(scroll_view_.horizontal_scroll_bar()->visible());
   bounds = scroll_view_.horizontal_scroll_bar()->bounds();
   EXPECT_EQ(kLeftPadding, bounds.x());
-  EXPECT_EQ(100 - kRightPadding - scroll_view_.GetScrollBarWidth(),
-            bounds.right());
-  EXPECT_EQ(100 - kBottomPadding - scroll_view_.GetScrollBarHeight(),
-            bounds.y());
+  EXPECT_EQ(100 - kRightPadding - VerticalScrollBarWidth(), bounds.right());
+  EXPECT_EQ(100 - kBottomPadding - HorizontalScrollBarHeight(), bounds.y());
   EXPECT_EQ(100 - kBottomPadding, bounds.bottom());
   // Check vert.
   ASSERT_TRUE(scroll_view_.vertical_scroll_bar() != NULL);
   EXPECT_TRUE(scroll_view_.vertical_scroll_bar()->visible());
   bounds = scroll_view_.vertical_scroll_bar()->bounds();
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth() - kRightPadding, bounds.x());
+  EXPECT_EQ(100 - VerticalScrollBarWidth() - kRightPadding, bounds.x());
   EXPECT_EQ(100 - kRightPadding, bounds.right());
   EXPECT_EQ(kTopPadding, bounds.y());
-  EXPECT_EQ(100 - kBottomPadding - scroll_view_.GetScrollBarHeight(),
+  EXPECT_EQ(100 - kBottomPadding - HorizontalScrollBarHeight(),
             bounds.bottom());
 }
 
 // Assertions around adding a header.
 TEST_F(ScrollViewTest, Header) {
   CustomView* header = new CustomView;
   scroll_view_.SetHeader(header);
   View* header_parent = header->parent();
   View* contents = InstallContents();
 
@@ skipping 37 matching lines @@
   scroll_view_.SetHeader(header);
   View* contents = InstallContents();
 
   header->SetPreferredSize(gfx::Size(10, 20));
 
   // Size the contents such that vertical scrollbar is needed.
   contents->SetBounds(0, 0, 50, 400);
   scroll_view_.Layout();
   EXPECT_EQ(0, contents->parent()->x());
   EXPECT_EQ(20, contents->parent()->y());
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(),
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutWidth(),
             contents->parent()->width());
   EXPECT_EQ(80, contents->parent()->height());
   EXPECT_EQ(0, header->parent()->x());
   EXPECT_EQ(0, header->parent()->y());
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(), header->parent()->width());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutWidth(),
+            header->parent()->width());
   EXPECT_EQ(20, header->parent()->height());
   EXPECT_TRUE(!scroll_view_.horizontal_scroll_bar() ||
               !scroll_view_.horizontal_scroll_bar()->visible());
   ASSERT_TRUE(scroll_view_.vertical_scroll_bar() != NULL);
   EXPECT_TRUE(scroll_view_.vertical_scroll_bar()->visible());
-  // Make sure the vertical scrollbar overlaps the header.
-  EXPECT_EQ(header->y(), scroll_view_.vertical_scroll_bar()->y());
+  // Make sure the vertical scrollbar overlaps the header for traditional
+  // scrollbars and doesn't overlap the header for overlay scrollbars.
+  const int expected_scrollbar_y =
+      scroll_view_.vertical_scroll_bar()->OverlapsContent()
+          ? header->bounds().bottom()
+          : header->y();
+  EXPECT_EQ(expected_scrollbar_y, scroll_view_.vertical_scroll_bar()->y());
   EXPECT_EQ(header->y(), contents->y());
 
   // Size the contents such that horizontal scrollbar is needed.
   contents->SetBounds(0, 0, 400, 50);
   scroll_view_.Layout();
   EXPECT_EQ(0, contents->parent()->x());
   EXPECT_EQ(20, contents->parent()->y());
   EXPECT_EQ(100, contents->parent()->width());
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarHeight() - 20,
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutHeight() - 20,
             contents->parent()->height());
   EXPECT_EQ(0, header->parent()->x());
   EXPECT_EQ(0, header->parent()->y());
   EXPECT_EQ(100, header->parent()->width());
   EXPECT_EQ(20, header->parent()->height());
   ASSERT_TRUE(scroll_view_.horizontal_scroll_bar() != NULL);
   EXPECT_TRUE(scroll_view_.horizontal_scroll_bar()->visible());
   EXPECT_TRUE(!scroll_view_.vertical_scroll_bar() ||
               !scroll_view_.vertical_scroll_bar()->visible());
 
   // Both horizontal and vertical.
   contents->SetBounds(0, 0, 300, 400);
   scroll_view_.Layout();
   EXPECT_EQ(0, contents->parent()->x());
   EXPECT_EQ(20, contents->parent()->y());
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(),
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutWidth(),
             contents->parent()->width());
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarHeight() - 20,
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutHeight() - 20,
             contents->parent()->height());
   EXPECT_EQ(0, header->parent()->x());
   EXPECT_EQ(0, header->parent()->y());
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(), header->parent()->width());
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutWidth(),
+            header->parent()->width());
   EXPECT_EQ(20, header->parent()->height());
   ASSERT_TRUE(scroll_view_.horizontal_scroll_bar() != NULL);
   EXPECT_TRUE(scroll_view_.horizontal_scroll_bar()->visible());
   ASSERT_TRUE(scroll_view_.vertical_scroll_bar() != NULL);
   EXPECT_TRUE(scroll_view_.vertical_scroll_bar()->visible());
 }
 
 // Verifies the header scrolls horizontally with the content.
 TEST_F(ScrollViewTest, HeaderScrollsWithContent) {
   ScrollViewTestApi test_api(&scroll_view_);
@@ skipping 32 matching lines @@
   scroll_view_.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
   scroll_view_.Layout();
   EXPECT_EQ("0,0", test_api.IntegralViewOffset().ToString());
 
   // Scroll to y=405 height=10, this should make the y position of the content
   // at (405 + 10) - viewport_height (scroll region bottom aligned).
   contents->ScrollRectToVisible(gfx::Rect(0, 405, 10, 10));
   const int viewport_height = test_api.contents_viewport()->height();
 
   // Expect there to be a horizontal scrollbar, making the viewport shorter.
-  EXPECT_LT(viewport_height, 100);
+  EXPECT_EQ(100 - scroll_view_.GetScrollBarLayoutHeight(), viewport_height);
 
   gfx::ScrollOffset offset = test_api.CurrentOffset();
   EXPECT_EQ(415 - viewport_height, offset.y());
 
   // Scroll to the current y-location and 10x10; should do nothing.
   contents->ScrollRectToVisible(gfx::Rect(0, offset.y(), 10, 10));
   EXPECT_EQ(415 - viewport_height, test_api.CurrentOffset().y());
 }
 
 // Verifies ClipHeightTo() uses the height of the content when it is between the
@@ skipping 37 matching lines @@
   } else {
     EXPECT_EQ(gfx::Size(kWidth, kShortContentHeight),
               scroll_view_.contents()->size());
   }
   EXPECT_EQ(gfx::Size(kWidth, kMinHeight), scroll_view_.size());
 }
 
 // Verifies ClipHeightTo() uses the maximum height when the content is longer
 // thamn the maximum height value.
 TEST_F(ScrollViewTest, ClipHeightToTallContentHeight) {
-  // Use a scrollbar that is disabled by default, so the width of the content is
-  // not affected.
-  scroll_view_.SetVerticalScrollBar(new views::OverlayScrollBar(false));
-
   scroll_view_.ClipHeightTo(kMinHeight, kMaxHeight);
 
   const int kTallContentHeight = 1000;
   scroll_view_.SetContents(
       new views::StaticSizedView(gfx::Size(kWidth, kTallContentHeight)));
 
   EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view_.GetPreferredSize());
 
   scroll_view_.SizeToPreferredSize();
   scroll_view_.Layout();
 
-  EXPECT_EQ(gfx::Size(kWidth, kTallContentHeight),
-            scroll_view_.contents()->size());
+  // The width may be less than kWidth if the scroll bar takes up some width.
+  EXPECT_GE(kWidth, scroll_view_.contents()->width());
+  EXPECT_EQ(kTallContentHeight, scroll_view_.contents()->height());
   EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view_.size());
 }
 
 // Verifies that when ClipHeightTo() produces a scrollbar, it reduces the width
 // of the inner content of the ScrollView.
 TEST_F(ScrollViewTest, ClipHeightToScrollbarUsesWidth) {
   scroll_view_.ClipHeightTo(kMinHeight, kMaxHeight);
 
   // Create a view that will be much taller than it is wide.
   scroll_view_.SetContents(new views::ProportionallySizedView(1000));
 
   // Without any width, it will default to 0,0 but be overridden by min height.
   scroll_view_.SizeToPreferredSize();
   EXPECT_EQ(gfx::Size(0, kMinHeight), scroll_view_.GetPreferredSize());
 
   gfx::Size new_size(kWidth, scroll_view_.GetHeightForWidth(kWidth));
   scroll_view_.SetSize(new_size);
   scroll_view_.Layout();
 
-  int scroll_bar_width = scroll_view_.GetScrollBarWidth();
-  int expected_width = kWidth - scroll_bar_width;
+  int expected_width = kWidth - scroll_view_.GetScrollBarLayoutWidth();
   EXPECT_EQ(scroll_view_.contents()->size().width(), expected_width);
   EXPECT_EQ(scroll_view_.contents()->size().height(), 1000 * expected_width);
   EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view_.size());
 }
 
 TEST_F(ScrollViewTest, CornerViewVisibility) {
   View* contents = InstallContents();
   View* corner_view = ScrollViewTestApi(&scroll_view_).corner_view();
 
-  // Corner view should be visible when both scrollbars are visible.
   contents->SetBounds(0, 0, 200, 200);
   scroll_view_.Layout();
+
+  // Corner view should not exist if using overlay scrollbars.
+  if (scroll_view_.vertical_scroll_bar()->OverlapsContent()) {
+    EXPECT_FALSE(corner_view->parent());
+    return;
+  }
+
+  // Corner view should be visible when both scrollbars are visible.
   EXPECT_EQ(&scroll_view_, corner_view->parent());
   EXPECT_TRUE(corner_view->visible());
 
   // Corner view should be aligned to the scrollbars.
   EXPECT_EQ(scroll_view_.vertical_scroll_bar()->x(), corner_view->x());
   EXPECT_EQ(scroll_view_.horizontal_scroll_bar()->y(), corner_view->y());
-  EXPECT_EQ(scroll_view_.GetScrollBarWidth(), corner_view->width());
-  EXPECT_EQ(scroll_view_.GetScrollBarHeight(), corner_view->height());
+  EXPECT_EQ(scroll_view_.GetScrollBarLayoutWidth(), corner_view->width());
+  EXPECT_EQ(scroll_view_.GetScrollBarLayoutHeight(), corner_view->height());
 
   // Corner view should be removed when only the vertical scrollbar is visible.
   contents->SetBounds(0, 0, 50, 200);
   scroll_view_.Layout();
   EXPECT_FALSE(corner_view->parent());
 
   // ... or when only the horizontal scrollbar is visible.
   contents->SetBounds(0, 0, 200, 50);
   scroll_view_.Layout();
   EXPECT_FALSE(corner_view->parent());
@@ skipping 16 matching lines @@
 TEST_F(ScrollViewTest, CocoaOverlayScrollBars) {
   SetOverlayScrollersEnabled(true);
   View* contents = InstallContents();
 
   // Size the contents such that vertical scrollbar is needed.
   // Since it is overlaid, the ViewPort size should match the ScrollView.
   contents->SetBounds(0, 0, 50, 400);
   scroll_view_.Layout();
   EXPECT_EQ(100, contents->parent()->width());
   EXPECT_EQ(100, contents->parent()->height());
-  EXPECT_EQ(0, scroll_view_.GetScrollBarWidth());
+  EXPECT_EQ(0, scroll_view_.GetScrollBarLayoutWidth());
   CheckScrollbarVisibility(scroll_view_, VERTICAL, true);
   CheckScrollbarVisibility(scroll_view_, HORIZONTAL, false);
 
   // Size the contents such that horizontal scrollbar is needed.
   contents->SetBounds(0, 0, 400, 50);
   scroll_view_.Layout();
   EXPECT_EQ(100, contents->parent()->width());
   EXPECT_EQ(100, contents->parent()->height());
-  EXPECT_EQ(0, scroll_view_.GetScrollBarHeight());
+  EXPECT_EQ(0, scroll_view_.GetScrollBarLayoutHeight());
   CheckScrollbarVisibility(scroll_view_, VERTICAL, false);
   CheckScrollbarVisibility(scroll_view_, HORIZONTAL, true);
 
   // Both horizontal and vertical scrollbars.
   contents->SetBounds(0, 0, 300, 400);
   scroll_view_.Layout();
   EXPECT_EQ(100, contents->parent()->width());
   EXPECT_EQ(100, contents->parent()->height());
-  EXPECT_EQ(0, scroll_view_.GetScrollBarWidth());
-  EXPECT_EQ(0, scroll_view_.GetScrollBarHeight());
+  EXPECT_EQ(0, scroll_view_.GetScrollBarLayoutWidth());
+  EXPECT_EQ(0, scroll_view_.GetScrollBarLayoutHeight());
   CheckScrollbarVisibility(scroll_view_, VERTICAL, true);
   CheckScrollbarVisibility(scroll_view_, HORIZONTAL, true);
 
   // Make sure the horizontal and vertical scrollbars don't overlap each other.
   gfx::Rect vert_bounds = scroll_view_.vertical_scroll_bar()->bounds();
   gfx::Rect horiz_bounds = scroll_view_.horizontal_scroll_bar()->bounds();
   EXPECT_EQ(vert_bounds.x(), horiz_bounds.right());
   EXPECT_EQ(horiz_bounds.y(), vert_bounds.bottom());
 
   // Switch to the non-overlay style and check that the ViewPort is now sized
   // to be smaller, and ScrollbarWidth and ScrollbarHeight are non-zero.
   SetOverlayScrollersEnabled(false);
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarWidth(),
-            contents->parent()->width());
-  EXPECT_EQ(100 - scroll_view_.GetScrollBarHeight(),
-            contents->parent()->height());
-  EXPECT_NE(0, scroll_view_.GetScrollBarWidth());
-  EXPECT_NE(0, scroll_view_.GetScrollBarHeight());
+  EXPECT_EQ(100 - VerticalScrollBarWidth(), contents->parent()->width());
+  EXPECT_EQ(100 - HorizontalScrollBarHeight(), contents->parent()->height());
+  EXPECT_NE(0, VerticalScrollBarWidth());
+  EXPECT_NE(0, HorizontalScrollBarHeight());
 }
 
 // Test overlay scrollbar behavior when just resting fingers on the trackpad.
 TEST_F(WidgetScrollViewTest, ScrollersOnRest) {
   // Allow expectations to distinguish between fade outs and immediate changes.
   ui::ScopedAnimationDurationScaleMode really_animate(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
   const float kMaxOpacity = 0.8f;  // Constant from cocoa_scroll_bar.mm.
 
@@ skipping 255 matching lines @@
   // Scroll via ScrollView API. Should be reflected on the impl side.
   offset.set_y(kDefaultHeight * 4);
   scroll_view->contents()->ScrollRectToVisible(offset);
   EXPECT_EQ(gfx::ScrollOffset(0, offset.y()), test_api.CurrentOffset());
 
   EXPECT_TRUE(compositor->GetScrollOffsetForLayer(layer_id, &impl_offset));
   EXPECT_EQ(gfx::ScrollOffset(0, offset.y()), impl_offset);
 }
 
 }  // namespace views