views: support vertical-drag-to-end on textfields

ui/views/controls/textfield/textfield_unittest.cc

 // Copyright 2014 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/textfield/textfield.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 21 matching lines @@
 #include "ui/events/event_processor.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/render_text.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/controls/textfield/textfield_controller.h"
 #include "ui/views/controls/textfield/textfield_model.h"
 #include "ui/views/controls/textfield/textfield_test_api.h"
 #include "ui/views/focus/focus_manager.h"
+#include "ui/views/style/platform_style.h"
 #include "ui/views/test/test_views_delegate.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/test/widget_test.h"
 #include "ui/views/widget/widget.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
@@ skipping 575 matching lines @@
     EXPECT_TRUE(menu->IsEnabledAt(1 /* Separator */));
     EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(2 /* CUT */));
     EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(3 /* COPY */));
     EXPECT_NE(GetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE).empty(),
               menu->IsEnabledAt(4 /* PASTE */));
     EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(5 /* DELETE */));
     EXPECT_TRUE(menu->IsEnabledAt(6 /* Separator */));
     EXPECT_TRUE(menu->IsEnabledAt(7 /* SELECT ALL */));
   }
 
+  void PressLeftMouseButton(int extra_flags) {
+    ui::MouseEvent click(ui::ET_MOUSE_PRESSED, mouse_position_, mouse_position_,
+                         ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
+                         ui::EF_LEFT_MOUSE_BUTTON | extra_flags);
+    textfield_->OnMousePressed(click);
+  }
+
+  void PressLeftMouseButton() {

[tapted, 2016/04/18 01:12:51]

(note style guide now allows default arguments if you prefer that. Although I'm
somewhat dubious of default arguments for things like `int` which don't carry a
lot of intrinsic meaning - e.g. it's easy to add a second `int` arg and get
lost. So overloading is fine. I'd also be fine with no overload and passing `0`
to everything explicitly.)

+    PressLeftMouseButton(0);
+  }
+
+  void ReleaseLeftMouseButton() {
+    ui::MouseEvent release(ui::ET_MOUSE_RELEASED, mouse_position_,
+                           mouse_position_, ui::EventTimeForNow(),
+                           ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+    textfield_->OnMouseReleased(release);
+  }
+
+  void ClickLeftMouseButton(int extra_flags) {
+    PressLeftMouseButton(extra_flags);
+    ReleaseLeftMouseButton();
+  }
+
+  void ClickLeftMouseButton() {
+    ClickLeftMouseButton(0);
+  }
+
+  void DragMouseTo(const gfx::Point& where) {
+    mouse_position_ = where;
+    ui::MouseEvent drag(ui::ET_MOUSE_DRAGGED, where, where,
+                        ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, 0);
+    textfield_->OnMouseDragged(drag);
+  }
+
+  // Textfield does not listen to OnMouseMoved, so this function does not send
+  // an event when it updates the cursor position.
+  void MoveMouseTo(const gfx::Point& where) { mouse_position_ = where; }
+
   // We need widget to populate wrapper class.
   Widget* widget_;
 
   TestTextfield* textfield_;
   std::unique_ptr<TextfieldTestApi> test_api_;
   TextfieldModel* model_;
 
   // The string from Controller::ContentsChanged callback.
   base::string16 last_contents_;
 
   // For testing input method related behaviors.
   MockInputMethod* input_method_;
 
   // Indicates how many times OnBeforeUserAction() is called.
   int on_before_user_action_;
 
   // Indicates how many times OnAfterUserAction() is called.
   int on_after_user_action_;
 
  private:
+  // Position of the mouse for synthetic mouse events.
+  gfx::Point mouse_position_;
   ui::ClipboardType copied_to_clipboard_;
   std::unique_ptr<ui::test::EventGenerator> event_generator_;
   DISALLOW_COPY_AND_ASSIGN(TextfieldTest);
 };
 
 TEST_F(TextfieldTest, ModelChangesTest) {
   InitTextfield();
 
   // TextfieldController::ContentsChanged() shouldn't be called when changing
   // text programmatically.
@@ skipping 399 matching lines @@
   widget_->GetFocusManager()->AdvanceFocus(true);
   EXPECT_EQ(3, GetFocusedView()->id());
 
   // Request focus should still work.
   textfield_->RequestFocus();
   EXPECT_EQ(1, GetFocusedView()->id());
 
   // Test if clicking on textfield view sets the focus.
   widget_->GetFocusManager()->AdvanceFocus(true);
   EXPECT_EQ(3, GetFocusedView()->id());
-  ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
-                       ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                       ui::EF_LEFT_MOUSE_BUTTON);
-  textfield_->OnMousePressed(click);
+  MoveMouseTo(gfx::Point());
+  ClickLeftMouseButton();
   EXPECT_EQ(1, GetFocusedView()->id());
 
   // Tab/Shift+Tab should also cycle focus, not insert a tab character.
   SendKeyEvent(ui::VKEY_TAB, false, false);
   EXPECT_EQ(2, GetFocusedView()->id());
   SendKeyEvent(ui::VKEY_TAB, false, false);
   EXPECT_EQ(3, GetFocusedView()->id());
   // Cycle back to the first textfield.
   SendKeyEvent(ui::VKEY_TAB, false, false);
   EXPECT_EQ(1, GetFocusedView()->id());
@@ skipping 28 matching lines @@
   VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel());
 
   // Exercise the "paste enabled?" check in the verifier.
   SetClipboardText(ui::CLIPBOARD_TYPE_COPY_PASTE, "Test");
   VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel());
 }
 
 TEST_F(TextfieldTest, DoubleAndTripleClickTest) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
-  ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
-                       ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                       ui::EF_LEFT_MOUSE_BUTTON);
-  ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
-                         ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                         ui::EF_LEFT_MOUSE_BUTTON);
-  ui::MouseEvent double_click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
-                              ui::EventTimeForNow(),
-                              ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_DOUBLE_CLICK,
-                              ui::EF_LEFT_MOUSE_BUTTON);
 
   // Test for double click.
-  textfield_->OnMousePressed(click);
-  textfield_->OnMouseReleased(release);
+  MoveMouseTo(gfx::Point());
+  ClickLeftMouseButton();
   EXPECT_TRUE(textfield_->GetSelectedText().empty());
-  textfield_->OnMousePressed(double_click);
-  textfield_->OnMouseReleased(release);
+  ClickLeftMouseButton(ui::EF_IS_DOUBLE_CLICK);
   EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
 
   // Test for triple click.
-  textfield_->OnMousePressed(click);
-  textfield_->OnMouseReleased(release);
+  ClickLeftMouseButton();
   EXPECT_STR_EQ("hello world", textfield_->GetSelectedText());
 
   // Another click should reset back to double click.
-  textfield_->OnMousePressed(click);
-  textfield_->OnMouseReleased(release);
+  ClickLeftMouseButton();
   EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
 }
 
 TEST_F(TextfieldTest, DragToSelect) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
   const int kStart = GetCursorPositionX(5);
   const int kEnd = 500;
   gfx::Point start_point(kStart, 0);
   gfx::Point end_point(kEnd, 0);
-  ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, start_point, start_point,
-                         ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                         ui::EF_LEFT_MOUSE_BUTTON);
-  ui::MouseEvent click_b(ui::ET_MOUSE_PRESSED, end_point, end_point,
-                         ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                         ui::EF_LEFT_MOUSE_BUTTON);
-  ui::MouseEvent drag_left(ui::ET_MOUSE_DRAGGED, gfx::Point(), gfx::Point(),
-                           ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, 0);
-  ui::MouseEvent drag_right(ui::ET_MOUSE_DRAGGED, end_point, end_point,
-                            ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, 0);
-  ui::MouseEvent release(ui::ET_MOUSE_RELEASED, end_point, end_point,
-                         ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                         ui::EF_LEFT_MOUSE_BUTTON);
-  textfield_->OnMousePressed(click_a);
+
+  MoveMouseTo(start_point);
+  PressLeftMouseButton();
   EXPECT_TRUE(textfield_->GetSelectedText().empty());
+
   // Check that dragging left selects the beginning of the string.
-  textfield_->OnMouseDragged(drag_left);
+  DragMouseTo(gfx::Point());
   base::string16 text_left = textfield_->GetSelectedText();
   EXPECT_STR_EQ("hello", text_left);
+
   // Check that dragging right selects the rest of the string.
-  textfield_->OnMouseDragged(drag_right);
+  DragMouseTo(end_point);
   base::string16 text_right = textfield_->GetSelectedText();
   EXPECT_STR_EQ(" world", text_right);
+
   // Check that releasing in the same location does not alter the selection.
-  textfield_->OnMouseReleased(release);
+  ReleaseLeftMouseButton();
   EXPECT_EQ(text_right, textfield_->GetSelectedText());
+
   // Check that dragging from beyond the text length works too.
-  textfield_->OnMousePressed(click_b);
-  textfield_->OnMouseDragged(drag_left);
-  textfield_->OnMouseReleased(release);
+  MoveMouseTo(end_point);
+  PressLeftMouseButton();
+  DragMouseTo(gfx::Point());
+  ReleaseLeftMouseButton();
   EXPECT_EQ(textfield_->text(), textfield_->GetSelectedText());
 }
 
+// This test checks that dragging above the textfield selects to the beginning
+// and dragging below the textfield selects to the end, but only on platforms
+// where that is the expected behavior.
+TEST_F(TextfieldTest, DragUpOrDownSelectsToEnd) {
+  InitTextfield();
+  textfield_->SetText(ASCIIToUTF16("hello world"));
+  const base::string16 expected_up = base::ASCIIToUTF16(
+      PlatformStyle::kTextfieldDragVerticallyDragsToEnd ? "hello" : "lo");
+  const base::string16 expected_down = base::ASCIIToUTF16(
+      PlatformStyle::kTextfieldDragVerticallyDragsToEnd ? " world" : " w");
+  const int kStartX = GetCursorPositionX(5);
+  const int kDownX = GetCursorPositionX(7);
+  const int kUpX = GetCursorPositionX(3);
+  gfx::Point start_point(kStartX, 0);
+  gfx::Point down_point(kDownX, 500);
+  gfx::Point up_point(kUpX, -500);
+
+  MoveMouseTo(start_point);
+  PressLeftMouseButton();
+  DragMouseTo(up_point);
+  ReleaseLeftMouseButton();
+  EXPECT_EQ(textfield_->GetSelectedText(), expected_up);
+
+  MoveMouseTo(start_point);
+  PressLeftMouseButton();
+  DragMouseTo(down_point);
+  ReleaseLeftMouseButton();
+  EXPECT_EQ(textfield_->GetSelectedText(), expected_down);
+}
+
 #if defined(OS_WIN)
 TEST_F(TextfieldTest, DragAndDrop_AcceptDrop) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   ui::OSExchangeData data;
   base::string16 string(ASCIIToUTF16("string "));
   data.SetString(string);
   int formats = 0;
   std::set<ui::Clipboard::FormatType> format_types;
@@ skipping 62 matching lines @@
   // Ensure that textfields without selections do not support drag operations.
   textfield_->ClearSelection();
   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
             textfield_->GetDragOperationsForView(NULL, kStringPoint));
   textfield_->SelectRange(kStringRange);
   // Ensure that password textfields do not support drag operations.
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
             textfield_->GetDragOperationsForView(NULL, kStringPoint));
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_TEXT);
+  MoveMouseTo(kStringPoint);
+  PressLeftMouseButton();
   // Ensure that textfields only initiate drag operations inside the selection.
-  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, kStringPoint, kStringPoint,
-                             ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                             ui::EF_LEFT_MOUSE_BUTTON);
-  textfield_->OnMousePressed(press_event);
   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
             textfield_->GetDragOperationsForView(NULL, gfx::Point()));
   EXPECT_FALSE(textfield_->CanStartDragForView(NULL, gfx::Point(),
                                                gfx::Point()));
   EXPECT_EQ(ui::DragDropTypes::DRAG_COPY,
             textfield_->GetDragOperationsForView(NULL, kStringPoint));
   EXPECT_TRUE(textfield_->CanStartDragForView(NULL, kStringPoint,
                                               gfx::Point()));
   // Ensure that textfields support local moves.
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
       textfield_->GetDragOperationsForView(textfield_, kStringPoint));
 }
 
 TEST_F(TextfieldTest, DragAndDrop_ToTheRight) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   base::string16 string;
   ui::OSExchangeData data;
   int formats = 0;
   int operations = 0;
   std::set<ui::Clipboard::FormatType> format_types;
 
   // Start dragging "ello".
   textfield_->SelectRange(gfx::Range(1, 5));
   gfx::Point point(GetCursorPositionX(3), 0);
-  ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, point, point,
-                         ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                         ui::EF_LEFT_MOUSE_BUTTON);
-  textfield_->OnMousePressed(click_a);
-  EXPECT_TRUE(textfield_->CanStartDragForView(textfield_, click_a.location(),
-                                              gfx::Point()));
-  operations = textfield_->GetDragOperationsForView(textfield_,
-                                                    click_a.location());
+  MoveMouseTo(point);
+  PressLeftMouseButton();
+  EXPECT_TRUE(textfield_->CanStartDragForView(textfield_, point, point));
+  operations = textfield_->GetDragOperationsForView(textfield_, point);
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
             operations);
-  textfield_->WriteDragDataForView(NULL, click_a.location(), &data);
+  textfield_->WriteDragDataForView(nullptr, point, &data);
   EXPECT_TRUE(data.GetString(&string));
   EXPECT_EQ(textfield_->GetSelectedText(), string);
   EXPECT_TRUE(textfield_->GetDropFormats(&formats, &format_types));
   EXPECT_EQ(ui::OSExchangeData::STRING, formats);
   EXPECT_TRUE(format_types.empty());
 
   // Drop "ello" after "w".
   const gfx::Point kDropPoint(GetCursorPositionX(7), 0);
   EXPECT_TRUE(textfield_->CanDrop(data));
   ui::DropTargetEvent drop_a(data, kDropPoint, kDropPoint, operations);
@@ skipping 23 matching lines @@
 
   base::string16 string;
   ui::OSExchangeData data;
   int formats = 0;
   int operations = 0;
   std::set<ui::Clipboard::FormatType> format_types;
 
   // Start dragging " worl".
   textfield_->SelectRange(gfx::Range(5, 10));
   gfx::Point point(GetCursorPositionX(7), 0);
-  ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, point, point,
-                         ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                         ui::EF_LEFT_MOUSE_BUTTON);
-  textfield_->OnMousePressed(click_a);
-  EXPECT_TRUE(textfield_->CanStartDragForView(textfield_, click_a.location(),
-                                              gfx::Point()));
-  operations = textfield_->GetDragOperationsForView(textfield_,
-                                                    click_a.location());
+  MoveMouseTo(point);
+  PressLeftMouseButton();
+  EXPECT_TRUE(textfield_->CanStartDragForView(textfield_, point, gfx::Point()));
+  operations = textfield_->GetDragOperationsForView(textfield_, point);
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
             operations);
-  textfield_->WriteDragDataForView(NULL, click_a.location(), &data);
+  textfield_->WriteDragDataForView(nullptr, point, &data);
   EXPECT_TRUE(data.GetString(&string));
   EXPECT_EQ(textfield_->GetSelectedText(), string);
   EXPECT_TRUE(textfield_->GetDropFormats(&formats, &format_types));
   EXPECT_EQ(ui::OSExchangeData::STRING, formats);
   EXPECT_TRUE(format_types.empty());
 
   // Drop " worl" after "h".
   EXPECT_TRUE(textfield_->CanDrop(data));
   gfx::Point drop_point(GetCursorPositionX(1), 0);
   ui::DropTargetEvent drop_a(data, drop_point, drop_point, operations);
@@ skipping 17 matching lines @@
   EXPECT_STR_EQ("h worlellod", textfield_->text());
 }
 
 TEST_F(TextfieldTest, DragAndDrop_Canceled) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("hello world"));
 
   // Start dragging "worl".
   textfield_->SelectRange(gfx::Range(6, 10));
   gfx::Point point(GetCursorPositionX(8), 0);
-  ui::MouseEvent click(ui::ET_MOUSE_PRESSED, point, point,
-                       ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                       ui::EF_LEFT_MOUSE_BUTTON);
-  textfield_->OnMousePressed(click);
+  MoveMouseTo(point);
+  PressLeftMouseButton();
   ui::OSExchangeData data;
-  textfield_->WriteDragDataForView(NULL, click.location(), &data);
+  textfield_->WriteDragDataForView(nullptr, point, &data);
   EXPECT_TRUE(textfield_->CanDrop(data));
   // Drag the text over somewhere valid, outside the current selection.
   gfx::Point drop_point(GetCursorPositionX(2), 0);
   ui::DropTargetEvent drop(data, drop_point, drop_point,
                            ui::DragDropTypes::DRAG_MOVE);
   EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnDragUpdated(drop));
   // "Cancel" the drag, via move and release over the selection, and OnDragDone.
   gfx::Point drag_point(GetCursorPositionX(9), 0);
-  ui::MouseEvent drag(ui::ET_MOUSE_DRAGGED, drag_point, drag_point,
-                      ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, 0);
-  ui::MouseEvent release(ui::ET_MOUSE_RELEASED, drag_point, drag_point,
-                         ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                         ui::EF_LEFT_MOUSE_BUTTON);
-  textfield_->OnMouseDragged(drag);
-  textfield_->OnMouseReleased(release);
-  textfield_->OnDragDone();
+  DragMouseTo(drag_point);
+  ReleaseLeftMouseButton();
   EXPECT_EQ(ASCIIToUTF16("hello world"), textfield_->text());
 }
 
 TEST_F(TextfieldTest, ReadOnlyTest) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("read only"));
   textfield_->SetReadOnly(true);
   EXPECT_TRUE(textfield_->enabled());
   EXPECT_TRUE(textfield_->IsFocusable());
 
@@ skipping 753 matching lines @@
 
   textfield_->SelectRange(gfx::Range(5, 5));
   const gfx::Rect middle_cursor = GetCursorBounds();
   textfield_->SelectRange(gfx::Range(0, 0));
   const gfx::Point beginning = GetCursorBounds().origin();
 
   // Double click, but do not release the left button.
   MouseClick(middle_cursor, 0);
   const gfx::Point middle(middle_cursor.x(),
                           middle_cursor.y() + middle_cursor.height() / 2);
-  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, middle, middle,
-                             ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
-                             ui::EF_LEFT_MOUSE_BUTTON);
-  textfield_->OnMousePressed(press_event);
+  MoveMouseTo(middle);
+  PressLeftMouseButton();
   EXPECT_EQ(gfx::Range(4, 7), textfield_->GetSelectedRange());
 
   // Drag the mouse to the beginning of the textfield.
-  ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED, beginning, beginning,
-                            ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, 0);
-  textfield_->OnMouseDragged(drag_event);
+  DragMouseTo(beginning);
   EXPECT_EQ(gfx::Range(7, 0), textfield_->GetSelectedRange());
 }
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 // flaky: http://crbug.com/396477
 TEST_F(TextfieldTest, DISABLED_SelectionClipboard) {
   InitTextfield();
   textfield_->SetText(ASCIIToUTF16("0123"));
   gfx::Point point_1(GetCursorPositionX(1), 0);
   gfx::Point point_2(GetCursorPositionX(2), 0);
@@ skipping 341 matching lines @@
 
   textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
   ui::AXViewState state_protected;
   textfield_->GetAccessibleState(&state_protected);
   EXPECT_EQ(ui::AX_ROLE_TEXT_FIELD, state_protected.role);
   EXPECT_EQ(ASCIIToUTF16("********"), state_protected.value);
   EXPECT_TRUE(state_protected.HasStateFlag(ui::AX_STATE_PROTECTED));
 }
 
 }  // namespace views