Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(146)

Side by Side Diff: ui/views/controls/textfield/textfield_unittest.cc

Issue 135863002: Reland Merge NativeTextfieldViews into views::Textfield. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Handle Ctrl-Shift-Delete and Backspace on Linux, like on ChromeOS. Created 6 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "ui/views/controls/textfield/native_textfield_views.h" 5 #include "ui/views/controls/textfield/textfield.h"
6 6
7 #include <set> 7 #include <set>
8 #include <string> 8 #include <string>
9 #include <vector> 9 #include <vector>
10 10
11 #include "base/auto_reset.h" 11 #include "base/auto_reset.h"
12 #include "base/bind.h" 12 #include "base/bind.h"
13 #include "base/bind_helpers.h" 13 #include "base/bind_helpers.h"
14 #include "base/callback.h" 14 #include "base/callback.h"
15 #include "base/command_line.h" 15 #include "base/command_line.h"
16 #include "base/message_loop/message_loop.h" 16 #include "base/message_loop/message_loop.h"
17 #include "base/pickle.h" 17 #include "base/pickle.h"
18 #include "base/strings/string16.h" 18 #include "base/strings/string16.h"
19 #include "base/strings/utf_string_conversions.h" 19 #include "base/strings/utf_string_conversions.h"
20 #include "grit/ui_strings.h" 20 #include "grit/ui_strings.h"
21 #include "testing/gtest/include/gtest/gtest.h" 21 #include "testing/gtest/include/gtest/gtest.h"
22 #include "ui/base/clipboard/clipboard.h" 22 #include "ui/base/clipboard/clipboard.h"
23 #include "ui/base/clipboard/scoped_clipboard_writer.h" 23 #include "ui/base/clipboard/scoped_clipboard_writer.h"
24 #include "ui/base/dragdrop/drag_drop_types.h" 24 #include "ui/base/dragdrop/drag_drop_types.h"
25 #include "ui/base/ime/text_input_client.h" 25 #include "ui/base/ime/text_input_client.h"
26 #include "ui/base/l10n/l10n_util.h" 26 #include "ui/base/l10n/l10n_util.h"
27 #include "ui/base/ui_base_switches.h" 27 #include "ui/base/ui_base_switches.h"
28 #include "ui/base/ui_base_switches_util.h"
28 #include "ui/events/event.h" 29 #include "ui/events/event.h"
29 #include "ui/events/keycodes/keyboard_codes.h" 30 #include "ui/events/keycodes/keyboard_codes.h"
30 #include "ui/gfx/render_text.h" 31 #include "ui/gfx/render_text.h"
31 #include "ui/views/controls/textfield/textfield.h"
32 #include "ui/views/controls/textfield/textfield_controller.h" 32 #include "ui/views/controls/textfield/textfield_controller.h"
33 #include "ui/views/controls/textfield/textfield_views_model.h" 33 #include "ui/views/controls/textfield/textfield_views_model.h"
34 #include "ui/views/focus/focus_manager.h" 34 #include "ui/views/focus/focus_manager.h"
35 #include "ui/views/ime/mock_input_method.h" 35 #include "ui/views/ime/mock_input_method.h"
36 #include "ui/views/test/test_views_delegate.h" 36 #include "ui/views/test/test_views_delegate.h"
37 #include "ui/views/test/views_test_base.h" 37 #include "ui/views/test/views_test_base.h"
38 #include "ui/views/widget/native_widget_private.h" 38 #include "ui/views/widget/native_widget_private.h"
39 #include "ui/views/widget/widget.h" 39 #include "ui/views/widget/widget.h"
40 #include "url/gurl.h" 40 #include "url/gurl.h"
41 41
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after
112 } 112 }
113 113
114 private: 114 private:
115 DISALLOW_COPY_AND_ASSIGN(GestureEventForTest); 115 DISALLOW_COPY_AND_ASSIGN(GestureEventForTest);
116 }; 116 };
117 117
118 } // namespace 118 } // namespace
119 119
120 namespace views { 120 namespace views {
121 121
122 // TODO(oshima): Move tests that are independent of TextfieldViews to 122 class TextfieldTest : public ViewsTestBase, public TextfieldController {
123 // textfield_unittests.cc once we move the test utility functions
124 // from chrome/browser/automation/ to ui/base/test/.
125 class NativeTextfieldViewsTest : public ViewsTestBase,
126 public TextfieldController {
127 public: 123 public:
128 NativeTextfieldViewsTest() 124 TextfieldTest()
129 : widget_(NULL), 125 : widget_(NULL),
130 textfield_(NULL), 126 textfield_(NULL),
131 textfield_view_(NULL),
132 model_(NULL), 127 model_(NULL),
133 input_method_(NULL), 128 input_method_(NULL),
134 on_before_user_action_(0), 129 on_before_user_action_(0),
135 on_after_user_action_(0) { 130 on_after_user_action_(0) {
136 } 131 }
137 132
138 // ::testing::Test: 133 // ::testing::Test:
139 virtual void SetUp() { 134 virtual void SetUp() {
140 ViewsTestBase::SetUp(); 135 ViewsTestBase::SetUp();
141 } 136 }
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
177 ASSERT_FALSE(textfield_); 172 ASSERT_FALSE(textfield_);
178 textfield_ = new TestTextfield(style); 173 textfield_ = new TestTextfield(style);
179 textfield_->SetController(this); 174 textfield_->SetController(this);
180 widget_ = new Widget(); 175 widget_ = new Widget();
181 Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP); 176 Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
182 params.bounds = gfx::Rect(100, 100, 100, 100); 177 params.bounds = gfx::Rect(100, 100, 100, 100);
183 widget_->Init(params); 178 widget_->Init(params);
184 View* container = new View(); 179 View* container = new View();
185 widget_->SetContentsView(container); 180 widget_->SetContentsView(container);
186 container->AddChildView(textfield_); 181 container->AddChildView(textfield_);
187 182 textfield_->SetBoundsRect(params.bounds);
188 textfield_view_ = textfield_->GetTextfieldViewForTesting();
189 DCHECK(textfield_view_);
190 textfield_view_->SetBoundsRect(params.bounds);
191 textfield_->set_id(1); 183 textfield_->set_id(1);
192 184
193 for (int i = 1; i < count; i++) { 185 for (int i = 1; i < count; i++) {
194 Textfield* textfield = new Textfield(style); 186 Textfield* textfield = new Textfield(style);
195 container->AddChildView(textfield); 187 container->AddChildView(textfield);
196 textfield->set_id(i + 1); 188 textfield->set_id(i + 1);
197 } 189 }
198 190
199 model_ = textfield_view_->model_.get(); 191 model_ = textfield_->model_.get();
200 model_->ClearEditHistory(); 192 model_->ClearEditHistory();
201 193
202 input_method_ = new MockInputMethod(); 194 input_method_ = new MockInputMethod();
203 widget_->ReplaceInputMethod(input_method_); 195 widget_->ReplaceInputMethod(input_method_);
204 196
205 // Activate the widget and focus the textfield for input handling. 197 // Activate the widget and focus the textfield for input handling.
206 widget_->Activate(); 198 widget_->Activate();
207 textfield_->RequestFocus(); 199 textfield_->RequestFocus();
208 } 200 }
209 201
210 ui::MenuModel* GetContextMenuModel() { 202 ui::MenuModel* GetContextMenuModel() {
211 textfield_view_->UpdateContextMenu(); 203 textfield_->UpdateContextMenu();
212 return textfield_view_->context_menu_contents_.get(); 204 return textfield_->context_menu_contents_.get();
213 } 205 }
214 206
215 ui::TouchSelectionController* GetTouchSelectionController() { 207 ui::TouchSelectionController* GetTouchSelectionController() {
216 return textfield_view_->touch_selection_controller_.get(); 208 return textfield_->touch_selection_controller_.get();
217 } 209 }
218 210
219 protected: 211 protected:
220 void SendKeyEvent(ui::KeyboardCode key_code, 212 void SendKeyEvent(ui::KeyboardCode key_code,
221 bool alt, 213 bool alt,
222 bool shift, 214 bool shift,
223 bool control, 215 bool control,
224 bool caps_lock) { 216 bool caps_lock) {
225 int flags = (alt ? ui::EF_ALT_DOWN : 0) | 217 int flags = (alt ? ui::EF_ALT_DOWN : 0) |
226 (shift ? ui::EF_SHIFT_DOWN : 0) | 218 (shift ? ui::EF_SHIFT_DOWN : 0) |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
263 ui::Clipboard::GetForCurrentThread(), 255 ui::Clipboard::GetForCurrentThread(),
264 ui::CLIPBOARD_TYPE_COPY_PASTE); 256 ui::CLIPBOARD_TYPE_COPY_PASTE);
265 clipboard_writer.WriteText(ASCIIToUTF16(text)); 257 clipboard_writer.WriteText(ASCIIToUTF16(text));
266 } 258 }
267 259
268 View* GetFocusedView() { 260 View* GetFocusedView() {
269 return widget_->GetFocusManager()->GetFocusedView(); 261 return widget_->GetFocusManager()->GetFocusedView();
270 } 262 }
271 263
272 int GetCursorPositionX(int cursor_pos) { 264 int GetCursorPositionX(int cursor_pos) {
273 gfx::RenderText* render_text = textfield_view_->GetRenderText(); 265 return textfield_->GetRenderText()->GetCursorBounds(
274 return render_text->GetCursorBounds(
275 gfx::SelectionModel(cursor_pos, gfx::CURSOR_FORWARD), false).x(); 266 gfx::SelectionModel(cursor_pos, gfx::CURSOR_FORWARD), false).x();
276 } 267 }
277 268
278 // Get the current cursor bounds. 269 // Get the current cursor bounds.
279 gfx::Rect GetCursorBounds() { 270 gfx::Rect GetCursorBounds() {
280 gfx::RenderText* render_text = textfield_view_->GetRenderText(); 271 return textfield_->GetRenderText()->GetUpdatedCursorBounds();
281 gfx::Rect bounds = render_text->GetUpdatedCursorBounds();
282 return bounds;
283 } 272 }
284 273
285 // Get the cursor bounds of |sel|. 274 // Get the cursor bounds of |sel|.
286 gfx::Rect GetCursorBounds(const gfx::SelectionModel& sel) { 275 gfx::Rect GetCursorBounds(const gfx::SelectionModel& sel) {
287 gfx::RenderText* render_text = textfield_view_->GetRenderText(); 276 return textfield_->GetRenderText()->GetCursorBounds(sel, true);
288 gfx::Rect bounds = render_text->GetCursorBounds(sel, true);
289 return bounds;
290 } 277 }
291 278
292 gfx::Rect GetDisplayRect() { 279 gfx::Rect GetDisplayRect() {
293 return textfield_view_->GetRenderText()->display_rect(); 280 return textfield_->GetRenderText()->display_rect();
294 } 281 }
295 282
296 // Mouse click on the point whose x-axis is |bound|'s x plus |x_offset| and 283 // Mouse click on the point whose x-axis is |bound|'s x plus |x_offset| and
297 // y-axis is in the middle of |bound|'s vertical range. 284 // y-axis is in the middle of |bound|'s vertical range.
298 void MouseClick(const gfx::Rect bound, int x_offset) { 285 void MouseClick(const gfx::Rect bound, int x_offset) {
299 gfx::Point point(bound.x() + x_offset, bound.y() + bound.height() / 2); 286 gfx::Point point(bound.x() + x_offset, bound.y() + bound.height() / 2);
300 ui::MouseEvent click(ui::ET_MOUSE_PRESSED, point, point, 287 ui::MouseEvent click(ui::ET_MOUSE_PRESSED, point, point,
301 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 288 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
302 textfield_view_->OnMousePressed(click); 289 textfield_->OnMousePressed(click);
303 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, point, point, 290 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, point, point,
304 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 291 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
305 textfield_view_->OnMouseReleased(release); 292 textfield_->OnMouseReleased(release);
306 } 293 }
307 294
308 // This is to avoid double/triple click. 295 // This is to avoid double/triple click.
309 void NonClientMouseClick() { 296 void NonClientMouseClick() {
310 ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), 297 ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
311 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_NON_CLIENT, 298 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_NON_CLIENT,
312 ui::EF_LEFT_MOUSE_BUTTON); 299 ui::EF_LEFT_MOUSE_BUTTON);
313 textfield_view_->OnMousePressed(click); 300 textfield_->OnMousePressed(click);
314 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), 301 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
315 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_NON_CLIENT, 302 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_NON_CLIENT,
316 ui::EF_LEFT_MOUSE_BUTTON); 303 ui::EF_LEFT_MOUSE_BUTTON);
317 textfield_view_->OnMouseReleased(release); 304 textfield_->OnMouseReleased(release);
318 } 305 }
319 306
320 // Wrap for visibility in test classes. 307 // Wrap for visibility in test classes.
321 ui::TextInputType GetTextInputType() { 308 ui::TextInputType GetTextInputType() {
322 return textfield_view_->GetTextInputType(); 309 return textfield_->GetTextInputType();
323 } 310 }
324 311
325 void VerifyTextfieldContextMenuContents(bool textfield_has_selection, 312 void VerifyTextfieldContextMenuContents(bool textfield_has_selection,
326 bool can_undo, 313 bool can_undo,
327 ui::MenuModel* menu) { 314 ui::MenuModel* menu) {
328 EXPECT_EQ(can_undo, menu->IsEnabledAt(0 /* UNDO */)); 315 EXPECT_EQ(can_undo, menu->IsEnabledAt(0 /* UNDO */));
329 EXPECT_TRUE(menu->IsEnabledAt(1 /* Separator */)); 316 EXPECT_TRUE(menu->IsEnabledAt(1 /* Separator */));
330 EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(2 /* CUT */)); 317 EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(2 /* CUT */));
331 EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(3 /* COPY */)); 318 EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(3 /* COPY */));
332 EXPECT_NE(GetClipboardText().empty(), menu->IsEnabledAt(4 /* PASTE */)); 319 EXPECT_NE(GetClipboardText().empty(), menu->IsEnabledAt(4 /* PASTE */));
333 EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(5 /* DELETE */)); 320 EXPECT_EQ(textfield_has_selection, menu->IsEnabledAt(5 /* DELETE */));
334 EXPECT_TRUE(menu->IsEnabledAt(6 /* Separator */)); 321 EXPECT_TRUE(menu->IsEnabledAt(6 /* Separator */));
335 EXPECT_TRUE(menu->IsEnabledAt(7 /* SELECT ALL */)); 322 EXPECT_TRUE(menu->IsEnabledAt(7 /* SELECT ALL */));
336 } 323 }
337 324
338 // We need widget to populate wrapper class. 325 // We need widget to populate wrapper class.
339 Widget* widget_; 326 Widget* widget_;
340 327
341 TestTextfield* textfield_; 328 TestTextfield* textfield_;
342 NativeTextfieldViews* textfield_view_;
343 TextfieldViewsModel* model_; 329 TextfieldViewsModel* model_;
344 330
345 // The string from Controller::ContentsChanged callback. 331 // The string from Controller::ContentsChanged callback.
346 base::string16 last_contents_; 332 base::string16 last_contents_;
347 333
348 // For testing input method related behaviors. 334 // For testing input method related behaviors.
349 MockInputMethod* input_method_; 335 MockInputMethod* input_method_;
350 336
351 // Indicates how many times OnBeforeUserAction() is called. 337 // Indicates how many times OnBeforeUserAction() is called.
352 int on_before_user_action_; 338 int on_before_user_action_;
353 339
354 // Indicates how many times OnAfterUserAction() is called. 340 // Indicates how many times OnAfterUserAction() is called.
355 int on_after_user_action_; 341 int on_after_user_action_;
356 342
357 private: 343 private:
358 DISALLOW_COPY_AND_ASSIGN(NativeTextfieldViewsTest); 344 DISALLOW_COPY_AND_ASSIGN(TextfieldTest);
359 }; 345 };
360 346
361 TEST_F(NativeTextfieldViewsTest, ModelChangesTest) { 347 TEST_F(TextfieldTest, ModelChangesTest) {
362 InitTextfield(Textfield::STYLE_DEFAULT); 348 InitTextfield(Textfield::STYLE_DEFAULT);
363 349
364 // TextfieldController::ContentsChanged() shouldn't be called when changing 350 // TextfieldController::ContentsChanged() shouldn't be called when changing
365 // text programmatically. 351 // text programmatically.
366 last_contents_.clear(); 352 last_contents_.clear();
367 textfield_->SetText(ASCIIToUTF16("this is")); 353 textfield_->SetText(ASCIIToUTF16("this is"));
368 354
369 EXPECT_STR_EQ("this is", model_->GetText()); 355 EXPECT_STR_EQ("this is", model_->text());
370 EXPECT_STR_EQ("this is", textfield_->text()); 356 EXPECT_STR_EQ("this is", textfield_->text());
371 EXPECT_TRUE(last_contents_.empty()); 357 EXPECT_TRUE(last_contents_.empty());
372 358
373 textfield_->AppendText(ASCIIToUTF16(" a test")); 359 textfield_->AppendText(ASCIIToUTF16(" a test"));
374 EXPECT_STR_EQ("this is a test", model_->GetText()); 360 EXPECT_STR_EQ("this is a test", model_->text());
375 EXPECT_STR_EQ("this is a test", textfield_->text()); 361 EXPECT_STR_EQ("this is a test", textfield_->text());
376 EXPECT_TRUE(last_contents_.empty()); 362 EXPECT_TRUE(last_contents_.empty());
377 363
378 EXPECT_EQ(base::string16(), textfield_->GetSelectedText()); 364 EXPECT_EQ(base::string16(), textfield_->GetSelectedText());
379 textfield_->SelectAll(false); 365 textfield_->SelectAll(false);
380 EXPECT_STR_EQ("this is a test", textfield_->GetSelectedText()); 366 EXPECT_STR_EQ("this is a test", textfield_->GetSelectedText());
381 EXPECT_TRUE(last_contents_.empty()); 367 EXPECT_TRUE(last_contents_.empty());
382 } 368 }
383 369
384 TEST_F(NativeTextfieldViewsTest, ModelChangesTestLowerCase) { 370 TEST_F(TextfieldTest, ModelChangesTestLowerCase) {
385 // Check if |model_|'s text is properly lowercased for STYLE_LOWERCASE. 371 // Check if |model_|'s text is properly lowercased for STYLE_LOWERCASE.
386 InitTextfield(Textfield::STYLE_LOWERCASE); 372 InitTextfield(Textfield::STYLE_LOWERCASE);
387 EXPECT_EQ(0U, textfield_->GetCursorPosition()); 373 EXPECT_EQ(0U, textfield_->GetCursorPosition());
388 374
389 last_contents_.clear(); 375 last_contents_.clear();
390 textfield_->SetText(ASCIIToUTF16("THIS IS")); 376 textfield_->SetText(ASCIIToUTF16("THIS IS"));
391 EXPECT_EQ(7U, textfield_->GetCursorPosition()); 377 EXPECT_EQ(7U, textfield_->GetCursorPosition());
392 378
393 EXPECT_STR_EQ("this is", model_->GetText()); 379 EXPECT_STR_EQ("this is", textfield_->text());
394 EXPECT_STR_EQ("THIS IS", textfield_->text());
395 EXPECT_TRUE(last_contents_.empty()); 380 EXPECT_TRUE(last_contents_.empty());
396 381
397 textfield_->AppendText(ASCIIToUTF16(" A TEST")); 382 textfield_->AppendText(ASCIIToUTF16(" A TEST"));
398 EXPECT_EQ(7U, textfield_->GetCursorPosition()); 383 EXPECT_EQ(7U, textfield_->GetCursorPosition());
399 EXPECT_STR_EQ("this is a test", model_->GetText()); 384 EXPECT_STR_EQ("this is a test", textfield_->text());
400 EXPECT_STR_EQ("THIS IS A TEST", textfield_->text());
401 385
402 EXPECT_TRUE(last_contents_.empty()); 386 EXPECT_TRUE(last_contents_.empty());
403 } 387 }
404 388
405 TEST_F(NativeTextfieldViewsTest, ModelChangesTestLowerCaseI18n) { 389 TEST_F(TextfieldTest, ModelChangesTestLowerCaseI18n) {
406 // Check if lower case conversion works for non-ASCII characters. 390 // Check if lower case conversion works for non-ASCII characters.
407 InitTextfield(Textfield::STYLE_LOWERCASE); 391 InitTextfield(Textfield::STYLE_LOWERCASE);
408 EXPECT_EQ(0U, textfield_->GetCursorPosition()); 392 EXPECT_EQ(0U, textfield_->GetCursorPosition());
409 393
410 last_contents_.clear(); 394 last_contents_.clear();
411 // Zenkaku Japanese "ABCabc" 395 // Zenkaku Japanese "ABCabc"
412 textfield_->SetText(WideToUTF16(L"\xFF21\xFF22\xFF23\xFF41\xFF42\xFF43")); 396 textfield_->SetText(WideToUTF16(L"\xFF21\xFF22\xFF23\xFF41\xFF42\xFF43"));
413 EXPECT_EQ(6U, textfield_->GetCursorPosition()); 397 EXPECT_EQ(6U, textfield_->GetCursorPosition());
414 // Zenkaku Japanese "abcabc" 398 // Zenkaku Japanese "abcabc"
415 EXPECT_EQ(WideToUTF16(L"\xFF41\xFF42\xFF43\xFF41\xFF42\xFF43"), 399 EXPECT_EQ(WideToUTF16(L"\xFF41\xFF42\xFF43\xFF41\xFF42\xFF43"),
416 model_->GetText());
417 // Zenkaku Japanese "ABCabc"
418 EXPECT_EQ(WideToUTF16(L"\xFF21\xFF22\xFF23\xFF41\xFF42\xFF43"),
419 textfield_->text()); 400 textfield_->text());
420 EXPECT_TRUE(last_contents_.empty()); 401 EXPECT_TRUE(last_contents_.empty());
421 402
422 // Zenkaku Japanese "XYZxyz" 403 // Zenkaku Japanese "XYZxyz"
423 textfield_->AppendText(WideToUTF16(L"\xFF38\xFF39\xFF3A\xFF58\xFF59\xFF5A")); 404 textfield_->AppendText(WideToUTF16(L"\xFF38\xFF39\xFF3A\xFF58\xFF59\xFF5A"));
424 EXPECT_EQ(6U, textfield_->GetCursorPosition()); 405 EXPECT_EQ(6U, textfield_->GetCursorPosition());
425 // Zenkaku Japanese "abcabcxyzxyz" 406 // Zenkaku Japanese "abcabcxyzxyz"
426 EXPECT_EQ(WideToUTF16(L"\xFF41\xFF42\xFF43\xFF41\xFF42\xFF43" 407 EXPECT_EQ(WideToUTF16(L"\xFF41\xFF42\xFF43\xFF41\xFF42\xFF43"
427 L"\xFF58\xFF59\xFF5A\xFF58\xFF59\xFF5A"), 408 L"\xFF58\xFF59\xFF5A\xFF58\xFF59\xFF5A"),
428 model_->GetText());
429 // Zenkaku Japanese "ABCabcXYZxyz"
430 EXPECT_EQ(WideToUTF16(L"\xFF21\xFF22\xFF23\xFF41\xFF42\xFF43"
431 L"\xFF38\xFF39\xFF3A\xFF58\xFF59\xFF5A"),
432 textfield_->text()); 409 textfield_->text());
433 EXPECT_TRUE(last_contents_.empty()); 410 EXPECT_TRUE(last_contents_.empty());
434 } 411 }
435 412
436 TEST_F(NativeTextfieldViewsTest, ModelChangesTestLowerCaseWithLocale) { 413 TEST_F(TextfieldTest, ModelChangesTestLowerCaseWithLocale) {
437 // Check if lower case conversion honors locale properly. 414 // Check if lower case conversion honors locale properly.
438 std::string locale = l10n_util::GetApplicationLocale(""); 415 std::string locale = l10n_util::GetApplicationLocale("");
439 base::i18n::SetICUDefaultLocale("tr"); 416 base::i18n::SetICUDefaultLocale("tr");
440 417
441 InitTextfield(Textfield::STYLE_LOWERCASE); 418 InitTextfield(Textfield::STYLE_LOWERCASE);
442 EXPECT_EQ(0U, textfield_->GetCursorPosition()); 419 EXPECT_EQ(0U, textfield_->GetCursorPosition());
443 420
444 last_contents_.clear(); 421 last_contents_.clear();
445 // Turkish 'I' should be converted to dotless 'i' (U+0131). 422 // Turkish 'I' should be converted to dotless 'i' (U+0131).
446 textfield_->SetText(WideToUTF16(L"I")); 423 textfield_->SetText(WideToUTF16(L"I"));
447 EXPECT_EQ(1U, textfield_->GetCursorPosition()); 424 EXPECT_EQ(1U, textfield_->GetCursorPosition());
448 EXPECT_EQ(WideToUTF16(L"\x0131"), model_->GetText()); 425 EXPECT_EQ(WideToUTF16(L"\x0131"), textfield_->text());
449 EXPECT_EQ(WideToUTF16(L"I"), textfield_->text());
450 EXPECT_TRUE(last_contents_.empty()); 426 EXPECT_TRUE(last_contents_.empty());
451 427
452 base::i18n::SetICUDefaultLocale(locale); 428 base::i18n::SetICUDefaultLocale(locale);
453 429
454 // On default (en) locale, 'I' should be converted to 'i'. 430 // On default (en) locale, 'I' should be converted to 'i'.
455 textfield_->SetText(WideToUTF16(L"I")); 431 textfield_->SetText(WideToUTF16(L"I"));
456 EXPECT_EQ(1U, textfield_->GetCursorPosition()); 432 EXPECT_EQ(1U, textfield_->GetCursorPosition());
457 EXPECT_EQ(WideToUTF16(L"i"), model_->GetText()); 433 EXPECT_EQ(WideToUTF16(L"i"), textfield_->text());
458 EXPECT_EQ(WideToUTF16(L"I"), textfield_->text());
459 EXPECT_TRUE(last_contents_.empty()); 434 EXPECT_TRUE(last_contents_.empty());
460 } 435 }
461 436
462 TEST_F(NativeTextfieldViewsTest, KeyTest) { 437 TEST_F(TextfieldTest, KeyTest) {
463 InitTextfield(Textfield::STYLE_DEFAULT); 438 InitTextfield(Textfield::STYLE_DEFAULT);
464 // Event flags: key, alt, shift, ctrl, caps-lock. 439 // Event flags: key, alt, shift, ctrl, caps-lock.
465 SendKeyEvent(ui::VKEY_T, false, true, false, false); 440 SendKeyEvent(ui::VKEY_T, false, true, false, false);
466 SendKeyEvent(ui::VKEY_E, false, false, false, false); 441 SendKeyEvent(ui::VKEY_E, false, false, false, false);
467 SendKeyEvent(ui::VKEY_X, false, true, false, true); 442 SendKeyEvent(ui::VKEY_X, false, true, false, true);
468 SendKeyEvent(ui::VKEY_T, false, false, false, true); 443 SendKeyEvent(ui::VKEY_T, false, false, false, true);
469 SendKeyEvent(ui::VKEY_1, false, true, false, false); 444 SendKeyEvent(ui::VKEY_1, false, true, false, false);
470 SendKeyEvent(ui::VKEY_1, false, false, false, false); 445 SendKeyEvent(ui::VKEY_1, false, false, false, false);
471 SendKeyEvent(ui::VKEY_1, false, true, false, true); 446 SendKeyEvent(ui::VKEY_1, false, true, false, true);
472 SendKeyEvent(ui::VKEY_1, false, false, false, true); 447 SendKeyEvent(ui::VKEY_1, false, false, false, true);
473 EXPECT_STR_EQ("TexT!1!1", textfield_->text()); 448 EXPECT_STR_EQ("TexT!1!1", textfield_->text());
474 } 449 }
475 450
476 TEST_F(NativeTextfieldViewsTest, ControlAndSelectTest) { 451 TEST_F(TextfieldTest, ControlAndSelectTest) {
477 // Insert a test string in a textfield. 452 // Insert a test string in a textfield.
478 InitTextfield(Textfield::STYLE_DEFAULT); 453 InitTextfield(Textfield::STYLE_DEFAULT);
479 textfield_->SetText(ASCIIToUTF16("one two three")); 454 textfield_->SetText(ASCIIToUTF16("one two three"));
480 SendKeyEvent(ui::VKEY_HOME, false /* shift */, false /* control */); 455 SendKeyEvent(ui::VKEY_HOME, false /* shift */, false /* control */);
481 SendKeyEvent(ui::VKEY_RIGHT, true, false); 456 SendKeyEvent(ui::VKEY_RIGHT, true, false);
482 SendKeyEvent(ui::VKEY_RIGHT, true, false); 457 SendKeyEvent(ui::VKEY_RIGHT, true, false);
483 SendKeyEvent(ui::VKEY_RIGHT, true, false); 458 SendKeyEvent(ui::VKEY_RIGHT, true, false);
484 459
485 EXPECT_STR_EQ("one", textfield_->GetSelectedText()); 460 EXPECT_STR_EQ("one", textfield_->GetSelectedText());
486 461
(...skipping 14 matching lines...) Expand all
501 SendKeyEvent(ui::VKEY_O, true, false); 476 SendKeyEvent(ui::VKEY_O, true, false);
502 SendKeyEvent(ui::VKEY_SPACE, false, false); 477 SendKeyEvent(ui::VKEY_SPACE, false, false);
503 EXPECT_STR_EQ("ZERO two three", textfield_->text()); 478 EXPECT_STR_EQ("ZERO two three", textfield_->text());
504 479
505 SendKeyEvent(ui::VKEY_END, true, false); 480 SendKeyEvent(ui::VKEY_END, true, false);
506 EXPECT_STR_EQ("two three", textfield_->GetSelectedText()); 481 EXPECT_STR_EQ("two three", textfield_->GetSelectedText());
507 SendKeyEvent(ui::VKEY_HOME, true, false); 482 SendKeyEvent(ui::VKEY_HOME, true, false);
508 EXPECT_STR_EQ("ZERO ", textfield_->GetSelectedText()); 483 EXPECT_STR_EQ("ZERO ", textfield_->GetSelectedText());
509 } 484 }
510 485
511 TEST_F(NativeTextfieldViewsTest, InsertionDeletionTest) { 486 TEST_F(TextfieldTest, InsertionDeletionTest) {
512 // Insert a test string in a textfield. 487 // Insert a test string in a textfield.
513 InitTextfield(Textfield::STYLE_DEFAULT); 488 InitTextfield(Textfield::STYLE_DEFAULT);
514 for (size_t i = 0; i < 10; i++) 489 for (size_t i = 0; i < 10; i++)
515 SendKeyEvent(static_cast<ui::KeyboardCode>(ui::VKEY_A + i)); 490 SendKeyEvent(static_cast<ui::KeyboardCode>(ui::VKEY_A + i));
516 EXPECT_STR_EQ("abcdefghij", textfield_->text()); 491 EXPECT_STR_EQ("abcdefghij", textfield_->text());
517 492
518 // Test the delete and backspace keys. 493 // Test the delete and backspace keys.
519 textfield_->SelectRange(gfx::Range(5)); 494 textfield_->SelectRange(gfx::Range(5));
520 for (int i = 0; i < 3; i++) 495 for (int i = 0; i < 3; i++)
521 SendKeyEvent(ui::VKEY_BACK); 496 SendKeyEvent(ui::VKEY_BACK);
522 EXPECT_STR_EQ("abfghij", textfield_->text()); 497 EXPECT_STR_EQ("abfghij", textfield_->text());
523 for (int i = 0; i < 3; i++) 498 for (int i = 0; i < 3; i++)
524 SendKeyEvent(ui::VKEY_DELETE); 499 SendKeyEvent(ui::VKEY_DELETE);
525 EXPECT_STR_EQ("abij", textfield_->text()); 500 EXPECT_STR_EQ("abij", textfield_->text());
526 501
527 // Select all and replace with "k". 502 // Select all and replace with "k".
528 textfield_->SelectAll(false); 503 textfield_->SelectAll(false);
529 SendKeyEvent(ui::VKEY_K); 504 SendKeyEvent(ui::VKEY_K);
530 EXPECT_STR_EQ("k", textfield_->text()); 505 EXPECT_STR_EQ("k", textfield_->text());
531 506
532 // Delete the previous word from cursor. 507 // Delete the previous word from cursor.
533 textfield_->SetText(ASCIIToUTF16("one two three four")); 508 textfield_->SetText(ASCIIToUTF16("one two three four"));
534 SendKeyEvent(ui::VKEY_END); 509 SendKeyEvent(ui::VKEY_END);
535 SendKeyEvent(ui::VKEY_BACK, false, false, true, false); 510 SendKeyEvent(ui::VKEY_BACK, false, false, true, false);
536 EXPECT_STR_EQ("one two three ", textfield_->text()); 511 EXPECT_STR_EQ("one two three ", textfield_->text());
537 512
538 // Delete text preceeding the cursor in chromeos, do nothing in windows. 513 // Delete to a line break on Linux and ChromeOS, no-op on Windows.
539 SendKeyEvent(ui::VKEY_LEFT, false, false, true, false); 514 SendKeyEvent(ui::VKEY_LEFT, false, false, true, false);
540 SendKeyEvent(ui::VKEY_BACK, false, true, true, false); 515 SendKeyEvent(ui::VKEY_BACK, false, true, true, false);
541 #if defined(OS_WIN) 516 #if defined(OS_LINUX)
517 EXPECT_STR_EQ("three ", textfield_->text());
518 #else
542 EXPECT_STR_EQ("one two three ", textfield_->text()); 519 EXPECT_STR_EQ("one two three ", textfield_->text());
543 #else
544 EXPECT_STR_EQ("three ", textfield_->text());
545 #endif 520 #endif
546 521
547 // Delete the next word from cursor. 522 // Delete the next word from cursor.
548 textfield_->SetText(ASCIIToUTF16("one two three four")); 523 textfield_->SetText(ASCIIToUTF16("one two three four"));
549 SendKeyEvent(ui::VKEY_HOME); 524 SendKeyEvent(ui::VKEY_HOME);
550 SendKeyEvent(ui::VKEY_DELETE, false, false, true, false); 525 SendKeyEvent(ui::VKEY_DELETE, false, false, true, false);
551 EXPECT_STR_EQ(" two three four", textfield_->text()); 526 EXPECT_STR_EQ(" two three four", textfield_->text());
552 527
553 // Delete text following the cursor in chromeos, do nothing in windows. 528 // Delete to a line break on Linux and ChromeOS, no-op on Windows.
554 SendKeyEvent(ui::VKEY_RIGHT, false, false, true, false); 529 SendKeyEvent(ui::VKEY_RIGHT, false, false, true, false);
555 SendKeyEvent(ui::VKEY_DELETE, false, true, true, false); 530 SendKeyEvent(ui::VKEY_DELETE, false, true, true, false);
556 #if defined(OS_WIN) 531 #if defined(OS_LINUX)
532 EXPECT_STR_EQ(" two", textfield_->text());
533 #else
557 EXPECT_STR_EQ(" two three four", textfield_->text()); 534 EXPECT_STR_EQ(" two three four", textfield_->text());
558 #else
559 EXPECT_STR_EQ(" two", textfield_->text());
560 #endif 535 #endif
561 } 536 }
562 537
563 TEST_F(NativeTextfieldViewsTest, PasswordTest) { 538 TEST_F(TextfieldTest, PasswordTest) {
564 InitTextfield(Textfield::STYLE_OBSCURED); 539 InitTextfield(Textfield::STYLE_OBSCURED);
565 EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType()); 540 EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
566 EXPECT_TRUE(textfield_->enabled()); 541 EXPECT_TRUE(textfield_->enabled());
567 EXPECT_TRUE(textfield_->focusable()); 542 EXPECT_TRUE(textfield_->focusable());
568 543
569 last_contents_.clear(); 544 last_contents_.clear();
570 textfield_->SetText(ASCIIToUTF16("password")); 545 textfield_->SetText(ASCIIToUTF16("password"));
571 // Ensure text() and the callback returns the actual text instead of "*". 546 // Ensure text() and the callback returns the actual text instead of "*".
572 EXPECT_STR_EQ("password", textfield_->text()); 547 EXPECT_STR_EQ("password", textfield_->text());
573 EXPECT_TRUE(last_contents_.empty()); 548 EXPECT_TRUE(last_contents_.empty());
574 model_->SelectAll(false); 549 model_->SelectAll(false);
575 SetClipboardText("foo"); 550 SetClipboardText("foo");
576 551
577 // Cut and copy should be disabled. 552 // Cut and copy should be disabled.
578 EXPECT_FALSE(textfield_view_->IsCommandIdEnabled(IDS_APP_CUT)); 553 EXPECT_FALSE(textfield_->IsCommandIdEnabled(IDS_APP_CUT));
579 textfield_view_->ExecuteCommand(IDS_APP_CUT, 0); 554 textfield_->ExecuteCommand(IDS_APP_CUT, 0);
580 SendKeyEvent(ui::VKEY_X, false, true); 555 SendKeyEvent(ui::VKEY_X, false, true);
581 EXPECT_FALSE(textfield_view_->IsCommandIdEnabled(IDS_APP_COPY)); 556 EXPECT_FALSE(textfield_->IsCommandIdEnabled(IDS_APP_COPY));
582 textfield_view_->ExecuteCommand(IDS_APP_COPY, 0); 557 textfield_->ExecuteCommand(IDS_APP_COPY, 0);
583 SendKeyEvent(ui::VKEY_C, false, true); 558 SendKeyEvent(ui::VKEY_C, false, true);
584 SendKeyEvent(ui::VKEY_INSERT, false, true); 559 SendKeyEvent(ui::VKEY_INSERT, false, true);
585 EXPECT_STR_EQ("foo", base::string16(GetClipboardText())); 560 EXPECT_STR_EQ("foo", base::string16(GetClipboardText()));
586 EXPECT_STR_EQ("password", textfield_->text()); 561 EXPECT_STR_EQ("password", textfield_->text());
587 // [Shift]+[Delete] should just delete without copying text to the clipboard. 562 // [Shift]+[Delete] should just delete without copying text to the clipboard.
588 textfield_->SelectAll(false); 563 textfield_->SelectAll(false);
589 SendKeyEvent(ui::VKEY_DELETE, true, false); 564 SendKeyEvent(ui::VKEY_DELETE, true, false);
590 565
591 // Paste should work normally. 566 // Paste should work normally.
592 EXPECT_TRUE(textfield_view_->IsCommandIdEnabled(IDS_APP_PASTE)); 567 EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_PASTE));
593 textfield_view_->ExecuteCommand(IDS_APP_PASTE, 0); 568 textfield_->ExecuteCommand(IDS_APP_PASTE, 0);
594 SendKeyEvent(ui::VKEY_V, false, true); 569 SendKeyEvent(ui::VKEY_V, false, true);
595 SendKeyEvent(ui::VKEY_INSERT, true, false); 570 SendKeyEvent(ui::VKEY_INSERT, true, false);
596 EXPECT_STR_EQ("foo", base::string16(GetClipboardText())); 571 EXPECT_STR_EQ("foo", base::string16(GetClipboardText()));
597 EXPECT_STR_EQ("foofoofoo", textfield_->text()); 572 EXPECT_STR_EQ("foofoofoo", textfield_->text());
598 } 573 }
599 574
600 TEST_F(NativeTextfieldViewsTest, InputTypeSetsObscured) { 575 TEST_F(TextfieldTest, InputTypeSetsObscured) {
601 InitTextfield(Textfield::STYLE_DEFAULT); 576 InitTextfield(Textfield::STYLE_DEFAULT);
602 577
603 // Defaults to TEXT 578 // Defaults to TEXT
604 EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType()); 579 EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType());
605 580
606 // Setting to TEXT_INPUT_TYPE_PASSWORD also sets obscured state of textfield. 581 // Setting to TEXT_INPUT_TYPE_PASSWORD also sets obscured state of textfield.
607 textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD); 582 textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
608 EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType()); 583 EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
609 EXPECT_TRUE(textfield_->IsObscured()); 584 EXPECT_TRUE(textfield_->IsObscured());
610 } 585 }
611 586
612 TEST_F(NativeTextfieldViewsTest, ObscuredSetsInputType) { 587 TEST_F(TextfieldTest, ObscuredSetsInputType) {
613 InitTextfield(Textfield::STYLE_DEFAULT); 588 InitTextfield(Textfield::STYLE_DEFAULT);
614 589
615 // Defaults to TEXT 590 // Defaults to TEXT
616 EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType()); 591 EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType());
617 592
618 textfield_->SetObscured(true); 593 textfield_->SetObscured(true);
619 EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType()); 594 EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, GetTextInputType());
620 595
621 textfield_->SetObscured(false); 596 textfield_->SetObscured(false);
622 EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType()); 597 EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType());
623 } 598 }
624 599
625 TEST_F(NativeTextfieldViewsTest, TextInputType) { 600 TEST_F(TextfieldTest, TextInputType) {
626 InitTextfield(Textfield::STYLE_DEFAULT); 601 InitTextfield(Textfield::STYLE_DEFAULT);
627 602
628 // Defaults to TEXT 603 // Defaults to TEXT
629 EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType()); 604 EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, GetTextInputType());
630 605
631 // And can be set. 606 // And can be set.
632 textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_URL); 607 textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_URL);
633 EXPECT_EQ(ui::TEXT_INPUT_TYPE_URL, GetTextInputType()); 608 EXPECT_EQ(ui::TEXT_INPUT_TYPE_URL, GetTextInputType());
634 609
635 // Readonly textfields have type NONE 610 // Readonly textfields have type NONE
636 textfield_->SetReadOnly(true); 611 textfield_->SetReadOnly(true);
637 EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType()); 612 EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType());
638 613
639 textfield_->SetReadOnly(false); 614 textfield_->SetReadOnly(false);
640 EXPECT_EQ(ui::TEXT_INPUT_TYPE_URL, GetTextInputType()); 615 EXPECT_EQ(ui::TEXT_INPUT_TYPE_URL, GetTextInputType());
641 616
642 // As do disabled textfields 617 // As do disabled textfields
643 textfield_->SetEnabled(false); 618 textfield_->SetEnabled(false);
644 EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType()); 619 EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType());
645 } 620 }
646 621
647 TEST_F(NativeTextfieldViewsTest, OnKeyPressReturnValueTest) { 622 TEST_F(TextfieldTest, OnKeyPressReturnValueTest) {
648 InitTextfield(Textfield::STYLE_DEFAULT); 623 InitTextfield(Textfield::STYLE_DEFAULT);
649 624
650 // Character keys will be handled by input method. 625 // Character keys will be handled by input method.
651 SendKeyEvent(ui::VKEY_A); 626 SendKeyEvent(ui::VKEY_A);
652 EXPECT_TRUE(textfield_->key_received()); 627 EXPECT_TRUE(textfield_->key_received());
653 EXPECT_FALSE(textfield_->key_handled()); 628 EXPECT_FALSE(textfield_->key_handled());
654 textfield_->clear(); 629 textfield_->clear();
655 630
656 // Home will be handled. 631 // Home will be handled.
657 SendKeyEvent(ui::VKEY_HOME); 632 SendKeyEvent(ui::VKEY_HOME);
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
700 EXPECT_TRUE(textfield_->key_handled()); 675 EXPECT_TRUE(textfield_->key_handled());
701 textfield_->clear(); 676 textfield_->clear();
702 677
703 // Now left key should not be handled. 678 // Now left key should not be handled.
704 SendKeyEvent(ui::VKEY_LEFT); 679 SendKeyEvent(ui::VKEY_LEFT);
705 EXPECT_TRUE(textfield_->key_received()); 680 EXPECT_TRUE(textfield_->key_received());
706 EXPECT_FALSE(textfield_->key_handled()); 681 EXPECT_FALSE(textfield_->key_handled());
707 textfield_->clear(); 682 textfield_->clear();
708 } 683 }
709 684
710 TEST_F(NativeTextfieldViewsTest, CursorMovement) { 685 TEST_F(TextfieldTest, CursorMovement) {
711 InitTextfield(Textfield::STYLE_DEFAULT); 686 InitTextfield(Textfield::STYLE_DEFAULT);
712 687
713 // Test with trailing whitespace. 688 // Test with trailing whitespace.
714 textfield_->SetText(ASCIIToUTF16("one two hre ")); 689 textfield_->SetText(ASCIIToUTF16("one two hre "));
715 690
716 // Send the cursor at the end. 691 // Send the cursor at the end.
717 SendKeyEvent(ui::VKEY_END); 692 SendKeyEvent(ui::VKEY_END);
718 693
719 // Ctrl+Left should move the cursor just before the last word. 694 // Ctrl+Left should move the cursor just before the last word.
720 SendKeyEvent(ui::VKEY_LEFT, false, true); 695 SendKeyEvent(ui::VKEY_LEFT, false, true);
(...skipping 29 matching lines...) Expand all
750 725
751 // Ctrl+Left to move the cursor to the beginning of the first word. 726 // Ctrl+Left to move the cursor to the beginning of the first word.
752 SendKeyEvent(ui::VKEY_LEFT, false, true); 727 SendKeyEvent(ui::VKEY_LEFT, false, true);
753 // Ctrl+Left again should move the cursor back to the very beginning. 728 // Ctrl+Left again should move the cursor back to the very beginning.
754 SendKeyEvent(ui::VKEY_LEFT, false, true); 729 SendKeyEvent(ui::VKEY_LEFT, false, true);
755 SendKeyEvent(ui::VKEY_DELETE); 730 SendKeyEvent(ui::VKEY_DELETE);
756 EXPECT_STR_EQ("one two", textfield_->text()); 731 EXPECT_STR_EQ("one two", textfield_->text());
757 EXPECT_STR_EQ("one two", last_contents_); 732 EXPECT_STR_EQ("one two", last_contents_);
758 } 733 }
759 734
760 TEST_F(NativeTextfieldViewsTest, FocusTraversalTest) { 735 TEST_F(TextfieldTest, FocusTraversalTest) {
761 InitTextfields(Textfield::STYLE_DEFAULT, 3); 736 InitTextfields(Textfield::STYLE_DEFAULT, 3);
762 textfield_->RequestFocus(); 737 textfield_->RequestFocus();
763 738
764 EXPECT_EQ(1, GetFocusedView()->id()); 739 EXPECT_EQ(1, GetFocusedView()->id());
765 widget_->GetFocusManager()->AdvanceFocus(false); 740 widget_->GetFocusManager()->AdvanceFocus(false);
766 EXPECT_EQ(2, GetFocusedView()->id()); 741 EXPECT_EQ(2, GetFocusedView()->id());
767 widget_->GetFocusManager()->AdvanceFocus(false); 742 widget_->GetFocusManager()->AdvanceFocus(false);
768 EXPECT_EQ(3, GetFocusedView()->id()); 743 EXPECT_EQ(3, GetFocusedView()->id());
769 // Cycle back to the first textfield. 744 // Cycle back to the first textfield.
770 widget_->GetFocusManager()->AdvanceFocus(false); 745 widget_->GetFocusManager()->AdvanceFocus(false);
(...skipping 11 matching lines...) Expand all
782 757
783 // Request focus should still work. 758 // Request focus should still work.
784 textfield_->RequestFocus(); 759 textfield_->RequestFocus();
785 EXPECT_EQ(1, GetFocusedView()->id()); 760 EXPECT_EQ(1, GetFocusedView()->id());
786 761
787 // Test if clicking on textfield view sets the focus to textfield_. 762 // Test if clicking on textfield view sets the focus to textfield_.
788 widget_->GetFocusManager()->AdvanceFocus(true); 763 widget_->GetFocusManager()->AdvanceFocus(true);
789 EXPECT_EQ(3, GetFocusedView()->id()); 764 EXPECT_EQ(3, GetFocusedView()->id());
790 ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), 765 ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
791 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 766 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
792 textfield_view_->OnMousePressed(click); 767 textfield_->OnMousePressed(click);
793 EXPECT_EQ(1, GetFocusedView()->id()); 768 EXPECT_EQ(1, GetFocusedView()->id());
794 } 769 }
795 770
796 TEST_F(NativeTextfieldViewsTest, ContextMenuDisplayTest) { 771 TEST_F(TextfieldTest, ContextMenuDisplayTest) {
797 InitTextfield(Textfield::STYLE_DEFAULT); 772 InitTextfield(Textfield::STYLE_DEFAULT);
798 EXPECT_TRUE(textfield_->context_menu_controller()); 773 EXPECT_TRUE(textfield_->context_menu_controller());
799 textfield_->SetText(ASCIIToUTF16("hello world")); 774 textfield_->SetText(ASCIIToUTF16("hello world"));
800 ui::Clipboard::GetForCurrentThread()->Clear(ui::CLIPBOARD_TYPE_COPY_PASTE); 775 ui::Clipboard::GetForCurrentThread()->Clear(ui::CLIPBOARD_TYPE_COPY_PASTE);
801 textfield_view_->ClearEditHistory(); 776 textfield_->ClearEditHistory();
802 EXPECT_TRUE(GetContextMenuModel()); 777 EXPECT_TRUE(GetContextMenuModel());
803 VerifyTextfieldContextMenuContents(false, false, GetContextMenuModel()); 778 VerifyTextfieldContextMenuContents(false, false, GetContextMenuModel());
804 779
805 textfield_->SelectAll(false); 780 textfield_->SelectAll(false);
806 VerifyTextfieldContextMenuContents(true, false, GetContextMenuModel()); 781 VerifyTextfieldContextMenuContents(true, false, GetContextMenuModel());
807 782
808 SendKeyEvent(ui::VKEY_T); 783 SendKeyEvent(ui::VKEY_T);
809 VerifyTextfieldContextMenuContents(false, true, GetContextMenuModel()); 784 VerifyTextfieldContextMenuContents(false, true, GetContextMenuModel());
810 785
811 textfield_->SelectAll(false); 786 textfield_->SelectAll(false);
812 VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel()); 787 VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel());
813 788
814 // Exercise the "paste enabled?" check in the verifier. 789 // Exercise the "paste enabled?" check in the verifier.
815 SetClipboardText("Test"); 790 SetClipboardText("Test");
816 VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel()); 791 VerifyTextfieldContextMenuContents(true, true, GetContextMenuModel());
817 } 792 }
818 793
819 TEST_F(NativeTextfieldViewsTest, DoubleAndTripleClickTest) { 794 TEST_F(TextfieldTest, DoubleAndTripleClickTest) {
820 InitTextfield(Textfield::STYLE_DEFAULT); 795 InitTextfield(Textfield::STYLE_DEFAULT);
821 textfield_->SetText(ASCIIToUTF16("hello world")); 796 textfield_->SetText(ASCIIToUTF16("hello world"));
822 ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), 797 ui::MouseEvent click(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
823 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 798 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
824 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), 799 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
825 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 800 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
826 ui::MouseEvent double_click( 801 ui::MouseEvent double_click(
827 ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), 802 ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
828 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_DOUBLE_CLICK, 803 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_IS_DOUBLE_CLICK,
829 ui::EF_LEFT_MOUSE_BUTTON); 804 ui::EF_LEFT_MOUSE_BUTTON);
830 805
831 // Test for double click. 806 // Test for double click.
832 textfield_view_->OnMousePressed(click); 807 textfield_->OnMousePressed(click);
833 textfield_view_->OnMouseReleased(release); 808 textfield_->OnMouseReleased(release);
834 EXPECT_TRUE(textfield_->GetSelectedText().empty()); 809 EXPECT_TRUE(textfield_->GetSelectedText().empty());
835 textfield_view_->OnMousePressed(double_click); 810 textfield_->OnMousePressed(double_click);
836 textfield_view_->OnMouseReleased(release); 811 textfield_->OnMouseReleased(release);
837 EXPECT_STR_EQ("hello", textfield_->GetSelectedText()); 812 EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
838 813
839 // Test for triple click. 814 // Test for triple click.
840 textfield_view_->OnMousePressed(click); 815 textfield_->OnMousePressed(click);
841 textfield_view_->OnMouseReleased(release); 816 textfield_->OnMouseReleased(release);
842 EXPECT_STR_EQ("hello world", textfield_->GetSelectedText()); 817 EXPECT_STR_EQ("hello world", textfield_->GetSelectedText());
843 818
844 // Another click should reset back to double click. 819 // Another click should reset back to double click.
845 textfield_view_->OnMousePressed(click); 820 textfield_->OnMousePressed(click);
846 textfield_view_->OnMouseReleased(release); 821 textfield_->OnMouseReleased(release);
847 EXPECT_STR_EQ("hello", textfield_->GetSelectedText()); 822 EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
848 } 823 }
849 824
850 TEST_F(NativeTextfieldViewsTest, DragToSelect) { 825 TEST_F(TextfieldTest, DragToSelect) {
851 InitTextfield(Textfield::STYLE_DEFAULT); 826 InitTextfield(Textfield::STYLE_DEFAULT);
852 textfield_->SetText(ASCIIToUTF16("hello world")); 827 textfield_->SetText(ASCIIToUTF16("hello world"));
853 const int kStart = GetCursorPositionX(5); 828 const int kStart = GetCursorPositionX(5);
854 const int kEnd = 500; 829 const int kEnd = 500;
855 gfx::Point start_point(kStart, 0); 830 gfx::Point start_point(kStart, 0);
856 gfx::Point end_point(kEnd, 0); 831 gfx::Point end_point(kEnd, 0);
857 ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, start_point, start_point, 832 ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, start_point, start_point,
858 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 833 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
859 ui::MouseEvent click_b(ui::ET_MOUSE_PRESSED, end_point, end_point, 834 ui::MouseEvent click_b(ui::ET_MOUSE_PRESSED, end_point, end_point,
860 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 835 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
861 ui::MouseEvent drag_left(ui::ET_MOUSE_DRAGGED, gfx::Point(), gfx::Point(), 836 ui::MouseEvent drag_left(ui::ET_MOUSE_DRAGGED, gfx::Point(), gfx::Point(),
862 ui::EF_LEFT_MOUSE_BUTTON, 0); 837 ui::EF_LEFT_MOUSE_BUTTON, 0);
863 ui::MouseEvent drag_right(ui::ET_MOUSE_DRAGGED, end_point, end_point, 838 ui::MouseEvent drag_right(ui::ET_MOUSE_DRAGGED, end_point, end_point,
864 ui::EF_LEFT_MOUSE_BUTTON, 0); 839 ui::EF_LEFT_MOUSE_BUTTON, 0);
865 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, end_point, end_point, 840 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, end_point, end_point,
866 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 841 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
867 textfield_view_->OnMousePressed(click_a); 842 textfield_->OnMousePressed(click_a);
868 EXPECT_TRUE(textfield_->GetSelectedText().empty()); 843 EXPECT_TRUE(textfield_->GetSelectedText().empty());
869 // Check that dragging left selects the beginning of the string. 844 // Check that dragging left selects the beginning of the string.
870 textfield_view_->OnMouseDragged(drag_left); 845 textfield_->OnMouseDragged(drag_left);
871 base::string16 text_left = textfield_->GetSelectedText(); 846 base::string16 text_left = textfield_->GetSelectedText();
872 EXPECT_STR_EQ("hello", text_left); 847 EXPECT_STR_EQ("hello", text_left);
873 // Check that dragging right selects the rest of the string. 848 // Check that dragging right selects the rest of the string.
874 textfield_view_->OnMouseDragged(drag_right); 849 textfield_->OnMouseDragged(drag_right);
875 base::string16 text_right = textfield_->GetSelectedText(); 850 base::string16 text_right = textfield_->GetSelectedText();
876 EXPECT_STR_EQ(" world", text_right); 851 EXPECT_STR_EQ(" world", text_right);
877 // Check that releasing in the same location does not alter the selection. 852 // Check that releasing in the same location does not alter the selection.
878 textfield_view_->OnMouseReleased(release); 853 textfield_->OnMouseReleased(release);
879 EXPECT_EQ(text_right, textfield_->GetSelectedText()); 854 EXPECT_EQ(text_right, textfield_->GetSelectedText());
880 // Check that dragging from beyond the text length works too. 855 // Check that dragging from beyond the text length works too.
881 textfield_view_->OnMousePressed(click_b); 856 textfield_->OnMousePressed(click_b);
882 textfield_view_->OnMouseDragged(drag_left); 857 textfield_->OnMouseDragged(drag_left);
883 textfield_view_->OnMouseReleased(release); 858 textfield_->OnMouseReleased(release);
884 EXPECT_EQ(textfield_->text(), textfield_->GetSelectedText()); 859 EXPECT_EQ(textfield_->text(), textfield_->GetSelectedText());
885 } 860 }
886 861
887 #if defined(OS_WIN) 862 #if defined(OS_WIN)
888 TEST_F(NativeTextfieldViewsTest, DragAndDrop_AcceptDrop) { 863 TEST_F(TextfieldTest, DragAndDrop_AcceptDrop) {
889 InitTextfield(Textfield::STYLE_DEFAULT); 864 InitTextfield(Textfield::STYLE_DEFAULT);
890 textfield_->SetText(ASCIIToUTF16("hello world")); 865 textfield_->SetText(ASCIIToUTF16("hello world"));
891 866
892 ui::OSExchangeData data; 867 ui::OSExchangeData data;
893 base::string16 string(ASCIIToUTF16("string ")); 868 base::string16 string(ASCIIToUTF16("string "));
894 data.SetString(string); 869 data.SetString(string);
895 int formats = 0; 870 int formats = 0;
896 std::set<OSExchangeData::CustomFormat> custom_formats; 871 std::set<OSExchangeData::CustomFormat> custom_formats;
897 872
898 // Ensure that disabled textfields do not accept drops. 873 // Ensure that disabled textfields do not accept drops.
899 textfield_->SetEnabled(false); 874 textfield_->SetEnabled(false);
900 EXPECT_FALSE(textfield_view_->GetDropFormats(&formats, &custom_formats)); 875 EXPECT_FALSE(textfield_->GetDropFormats(&formats, &custom_formats));
901 EXPECT_EQ(0, formats); 876 EXPECT_EQ(0, formats);
902 EXPECT_TRUE(custom_formats.empty()); 877 EXPECT_TRUE(custom_formats.empty());
903 EXPECT_FALSE(textfield_view_->CanDrop(data)); 878 EXPECT_FALSE(textfield_->CanDrop(data));
904 textfield_->SetEnabled(true); 879 textfield_->SetEnabled(true);
905 880
906 // Ensure that read-only textfields do not accept drops. 881 // Ensure that read-only textfields do not accept drops.
907 textfield_->SetReadOnly(true); 882 textfield_->SetReadOnly(true);
908 EXPECT_FALSE(textfield_view_->GetDropFormats(&formats, &custom_formats)); 883 EXPECT_FALSE(textfield_->GetDropFormats(&formats, &custom_formats));
909 EXPECT_EQ(0, formats); 884 EXPECT_EQ(0, formats);
910 EXPECT_TRUE(custom_formats.empty()); 885 EXPECT_TRUE(custom_formats.empty());
911 EXPECT_FALSE(textfield_view_->CanDrop(data)); 886 EXPECT_FALSE(textfield_->CanDrop(data));
912 textfield_->SetReadOnly(false); 887 textfield_->SetReadOnly(false);
913 888
914 // Ensure that enabled and editable textfields do accept drops. 889 // Ensure that enabled and editable textfields do accept drops.
915 EXPECT_TRUE(textfield_view_->GetDropFormats(&formats, &custom_formats)); 890 EXPECT_TRUE(textfield_->GetDropFormats(&formats, &custom_formats));
916 EXPECT_EQ(ui::OSExchangeData::STRING, formats); 891 EXPECT_EQ(ui::OSExchangeData::STRING, formats);
917 EXPECT_TRUE(custom_formats.empty()); 892 EXPECT_TRUE(custom_formats.empty());
918 EXPECT_TRUE(textfield_view_->CanDrop(data)); 893 EXPECT_TRUE(textfield_->CanDrop(data));
919 gfx::Point drop_point(GetCursorPositionX(6), 0); 894 gfx::Point drop_point(GetCursorPositionX(6), 0);
920 ui::DropTargetEvent drop(data, drop_point, drop_point, 895 ui::DropTargetEvent drop(data, drop_point, drop_point,
921 ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_MOVE); 896 ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_MOVE);
922 EXPECT_EQ(ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_MOVE, 897 EXPECT_EQ(ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_MOVE,
923 textfield_view_->OnDragUpdated(drop)); 898 textfield_->OnDragUpdated(drop));
924 EXPECT_EQ(ui::DragDropTypes::DRAG_COPY, textfield_view_->OnPerformDrop(drop)); 899 EXPECT_EQ(ui::DragDropTypes::DRAG_COPY, textfield_->OnPerformDrop(drop));
925 EXPECT_STR_EQ("hello string world", textfield_->text()); 900 EXPECT_STR_EQ("hello string world", textfield_->text());
926 901
927 // Ensure that textfields do not accept non-OSExchangeData::STRING types. 902 // Ensure that textfields do not accept non-OSExchangeData::STRING types.
928 ui::OSExchangeData bad_data; 903 ui::OSExchangeData bad_data;
929 bad_data.SetFilename(base::FilePath(FILE_PATH_LITERAL("x"))); 904 bad_data.SetFilename(base::FilePath(FILE_PATH_LITERAL("x")));
930 #if defined(OS_WIN) 905 #if defined(OS_WIN)
931 ui::OSExchangeData::CustomFormat fmt = ui::Clipboard::GetBitmapFormatType(); 906 ui::OSExchangeData::CustomFormat fmt = ui::Clipboard::GetBitmapFormatType();
932 bad_data.SetPickledData(fmt, Pickle()); 907 bad_data.SetPickledData(fmt, Pickle());
933 bad_data.SetFileContents(base::FilePath(L"x"), "x"); 908 bad_data.SetFileContents(base::FilePath(L"x"), "x");
934 bad_data.SetHtml(base::string16(ASCIIToUTF16("x")), GURL("x.org")); 909 bad_data.SetHtml(base::string16(ASCIIToUTF16("x")), GURL("x.org"));
935 ui::OSExchangeData::DownloadFileInfo download(base::FilePath(), NULL); 910 ui::OSExchangeData::DownloadFileInfo download(base::FilePath(), NULL);
936 bad_data.SetDownloadFileInfo(download); 911 bad_data.SetDownloadFileInfo(download);
937 #endif 912 #endif
938 EXPECT_FALSE(textfield_view_->CanDrop(bad_data)); 913 EXPECT_FALSE(textfield_->CanDrop(bad_data));
939 } 914 }
940 #endif 915 #endif
941 916
942 TEST_F(NativeTextfieldViewsTest, DragAndDrop_InitiateDrag) { 917 TEST_F(TextfieldTest, DragAndDrop_InitiateDrag) {
943 InitTextfield(Textfield::STYLE_DEFAULT); 918 InitTextfield(Textfield::STYLE_DEFAULT);
944 textfield_->SetText(ASCIIToUTF16("hello string world")); 919 textfield_->SetText(ASCIIToUTF16("hello string world"));
945 920
946 // Ensure the textfield will provide selected text for drag data. 921 // Ensure the textfield will provide selected text for drag data.
947 base::string16 string; 922 base::string16 string;
948 ui::OSExchangeData data; 923 ui::OSExchangeData data;
949 const gfx::Range kStringRange(6, 12); 924 const gfx::Range kStringRange(6, 12);
950 textfield_->SelectRange(kStringRange); 925 textfield_->SelectRange(kStringRange);
951 const gfx::Point kStringPoint(GetCursorPositionX(9), 0); 926 const gfx::Point kStringPoint(GetCursorPositionX(9), 0);
952 textfield_view_->WriteDragDataForView(NULL, kStringPoint, &data); 927 textfield_->WriteDragDataForView(NULL, kStringPoint, &data);
953 EXPECT_TRUE(data.GetString(&string)); 928 EXPECT_TRUE(data.GetString(&string));
954 EXPECT_EQ(textfield_->GetSelectedText(), string); 929 EXPECT_EQ(textfield_->GetSelectedText(), string);
955 930
956 // Ensure that disabled textfields do not support drag operations. 931 // Ensure that disabled textfields do not support drag operations.
957 textfield_->SetEnabled(false); 932 textfield_->SetEnabled(false);
958 EXPECT_EQ(ui::DragDropTypes::DRAG_NONE, 933 EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
959 textfield_view_->GetDragOperationsForView(NULL, kStringPoint)); 934 textfield_->GetDragOperationsForView(NULL, kStringPoint));
960 textfield_->SetEnabled(true); 935 textfield_->SetEnabled(true);
961 // Ensure that textfields without selections do not support drag operations. 936 // Ensure that textfields without selections do not support drag operations.
962 textfield_->ClearSelection(); 937 textfield_->ClearSelection();
963 EXPECT_EQ(ui::DragDropTypes::DRAG_NONE, 938 EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
964 textfield_view_->GetDragOperationsForView(NULL, kStringPoint)); 939 textfield_->GetDragOperationsForView(NULL, kStringPoint));
965 textfield_->SelectRange(kStringRange); 940 textfield_->SelectRange(kStringRange);
966 // Ensure that password textfields do not support drag operations. 941 // Ensure that password textfields do not support drag operations.
967 textfield_->SetObscured(true); 942 textfield_->SetObscured(true);
968 EXPECT_EQ(ui::DragDropTypes::DRAG_NONE, 943 EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
969 textfield_view_->GetDragOperationsForView(NULL, kStringPoint)); 944 textfield_->GetDragOperationsForView(NULL, kStringPoint));
970 textfield_->SetObscured(false); 945 textfield_->SetObscured(false);
971 // Ensure that textfields only initiate drag operations inside the selection. 946 // Ensure that textfields only initiate drag operations inside the selection.
972 ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, kStringPoint, kStringPoint, 947 ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, kStringPoint, kStringPoint,
973 ui::EF_LEFT_MOUSE_BUTTON, 948 ui::EF_LEFT_MOUSE_BUTTON,
974 ui::EF_LEFT_MOUSE_BUTTON); 949 ui::EF_LEFT_MOUSE_BUTTON);
975 textfield_view_->OnMousePressed(press_event); 950 textfield_->OnMousePressed(press_event);
976 EXPECT_EQ(ui::DragDropTypes::DRAG_NONE, 951 EXPECT_EQ(ui::DragDropTypes::DRAG_NONE,
977 textfield_view_->GetDragOperationsForView(NULL, gfx::Point())); 952 textfield_->GetDragOperationsForView(NULL, gfx::Point()));
978 EXPECT_FALSE(textfield_view_->CanStartDragForView(NULL, gfx::Point(), 953 EXPECT_FALSE(textfield_->CanStartDragForView(NULL, gfx::Point(),
979 gfx::Point())); 954 gfx::Point()));
980 EXPECT_EQ(ui::DragDropTypes::DRAG_COPY, 955 EXPECT_EQ(ui::DragDropTypes::DRAG_COPY,
981 textfield_view_->GetDragOperationsForView(NULL, kStringPoint)); 956 textfield_->GetDragOperationsForView(NULL, kStringPoint));
982 EXPECT_TRUE(textfield_view_->CanStartDragForView(NULL, kStringPoint, 957 EXPECT_TRUE(textfield_->CanStartDragForView(NULL, kStringPoint,
983 gfx::Point())); 958 gfx::Point()));
984 // Ensure that textfields support local moves. 959 // Ensure that textfields support local moves.
985 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY, 960 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
986 textfield_view_->GetDragOperationsForView(textfield_view_, kStringPoint)); 961 textfield_->GetDragOperationsForView(textfield_, kStringPoint));
987 } 962 }
988 963
989 TEST_F(NativeTextfieldViewsTest, DragAndDrop_ToTheRight) { 964 TEST_F(TextfieldTest, DragAndDrop_ToTheRight) {
990 InitTextfield(Textfield::STYLE_DEFAULT); 965 InitTextfield(Textfield::STYLE_DEFAULT);
991 textfield_->SetText(ASCIIToUTF16("hello world")); 966 textfield_->SetText(ASCIIToUTF16("hello world"));
992 967
993 base::string16 string; 968 base::string16 string;
994 ui::OSExchangeData data; 969 ui::OSExchangeData data;
995 int formats = 0; 970 int formats = 0;
996 int operations = 0; 971 int operations = 0;
997 std::set<OSExchangeData::CustomFormat> custom_formats; 972 std::set<OSExchangeData::CustomFormat> custom_formats;
998 973
999 // Start dragging "ello". 974 // Start dragging "ello".
1000 textfield_->SelectRange(gfx::Range(1, 5)); 975 textfield_->SelectRange(gfx::Range(1, 5));
1001 gfx::Point point(GetCursorPositionX(3), 0); 976 gfx::Point point(GetCursorPositionX(3), 0);
1002 ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, point, point, 977 ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, point, point,
1003 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 978 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
1004 textfield_view_->OnMousePressed(click_a); 979 textfield_->OnMousePressed(click_a);
1005 EXPECT_TRUE(textfield_view_->CanStartDragForView(textfield_view_, 980 EXPECT_TRUE(textfield_->CanStartDragForView(textfield_, click_a.location(),
1006 click_a.location(), gfx::Point())); 981 gfx::Point()));
1007 operations = textfield_view_->GetDragOperationsForView(textfield_view_, 982 operations = textfield_->GetDragOperationsForView(textfield_,
1008 click_a.location()); 983 click_a.location());
1009 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY, 984 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
1010 operations); 985 operations);
1011 textfield_view_->WriteDragDataForView(NULL, click_a.location(), &data); 986 textfield_->WriteDragDataForView(NULL, click_a.location(), &data);
1012 EXPECT_TRUE(data.GetString(&string)); 987 EXPECT_TRUE(data.GetString(&string));
1013 EXPECT_EQ(textfield_->GetSelectedText(), string); 988 EXPECT_EQ(textfield_->GetSelectedText(), string);
1014 EXPECT_TRUE(textfield_view_->GetDropFormats(&formats, &custom_formats)); 989 EXPECT_TRUE(textfield_->GetDropFormats(&formats, &custom_formats));
1015 EXPECT_EQ(ui::OSExchangeData::STRING, formats); 990 EXPECT_EQ(ui::OSExchangeData::STRING, formats);
1016 EXPECT_TRUE(custom_formats.empty()); 991 EXPECT_TRUE(custom_formats.empty());
1017 992
1018 // Drop "ello" after "w". 993 // Drop "ello" after "w".
1019 const gfx::Point kDropPoint(GetCursorPositionX(7), 0); 994 const gfx::Point kDropPoint(GetCursorPositionX(7), 0);
1020 EXPECT_TRUE(textfield_view_->CanDrop(data)); 995 EXPECT_TRUE(textfield_->CanDrop(data));
1021 ui::DropTargetEvent drop_a(data, kDropPoint, kDropPoint, operations); 996 ui::DropTargetEvent drop_a(data, kDropPoint, kDropPoint, operations);
1022 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, 997 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnDragUpdated(drop_a));
1023 textfield_view_->OnDragUpdated(drop_a)); 998 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnPerformDrop(drop_a));
1024 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE,
1025 textfield_view_->OnPerformDrop(drop_a));
1026 EXPECT_STR_EQ("h welloorld", textfield_->text()); 999 EXPECT_STR_EQ("h welloorld", textfield_->text());
1027 textfield_view_->OnDragDone(); 1000 textfield_->OnDragDone();
1028 1001
1029 // Undo/Redo the drag&drop change. 1002 // Undo/Redo the drag&drop change.
1030 SendKeyEvent(ui::VKEY_Z, false, true); 1003 SendKeyEvent(ui::VKEY_Z, false, true);
1031 EXPECT_STR_EQ("hello world", textfield_->text()); 1004 EXPECT_STR_EQ("hello world", textfield_->text());
1032 SendKeyEvent(ui::VKEY_Z, false, true); 1005 SendKeyEvent(ui::VKEY_Z, false, true);
1033 EXPECT_STR_EQ("", textfield_->text()); 1006 EXPECT_STR_EQ("", textfield_->text());
1034 SendKeyEvent(ui::VKEY_Z, false, true); 1007 SendKeyEvent(ui::VKEY_Z, false, true);
1035 EXPECT_STR_EQ("", textfield_->text()); 1008 EXPECT_STR_EQ("", textfield_->text());
1036 SendKeyEvent(ui::VKEY_Y, false, true); 1009 SendKeyEvent(ui::VKEY_Y, false, true);
1037 EXPECT_STR_EQ("hello world", textfield_->text()); 1010 EXPECT_STR_EQ("hello world", textfield_->text());
1038 SendKeyEvent(ui::VKEY_Y, false, true); 1011 SendKeyEvent(ui::VKEY_Y, false, true);
1039 EXPECT_STR_EQ("h welloorld", textfield_->text()); 1012 EXPECT_STR_EQ("h welloorld", textfield_->text());
1040 SendKeyEvent(ui::VKEY_Y, false, true); 1013 SendKeyEvent(ui::VKEY_Y, false, true);
1041 EXPECT_STR_EQ("h welloorld", textfield_->text()); 1014 EXPECT_STR_EQ("h welloorld", textfield_->text());
1042 } 1015 }
1043 1016
1044 TEST_F(NativeTextfieldViewsTest, DragAndDrop_ToTheLeft) { 1017 TEST_F(TextfieldTest, DragAndDrop_ToTheLeft) {
1045 InitTextfield(Textfield::STYLE_DEFAULT); 1018 InitTextfield(Textfield::STYLE_DEFAULT);
1046 textfield_->SetText(ASCIIToUTF16("hello world")); 1019 textfield_->SetText(ASCIIToUTF16("hello world"));
1047 1020
1048 base::string16 string; 1021 base::string16 string;
1049 ui::OSExchangeData data; 1022 ui::OSExchangeData data;
1050 int formats = 0; 1023 int formats = 0;
1051 int operations = 0; 1024 int operations = 0;
1052 std::set<OSExchangeData::CustomFormat> custom_formats; 1025 std::set<OSExchangeData::CustomFormat> custom_formats;
1053 1026
1054 // Start dragging " worl". 1027 // Start dragging " worl".
1055 textfield_->SelectRange(gfx::Range(5, 10)); 1028 textfield_->SelectRange(gfx::Range(5, 10));
1056 gfx::Point point(GetCursorPositionX(7), 0); 1029 gfx::Point point(GetCursorPositionX(7), 0);
1057 ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, point, point, 1030 ui::MouseEvent click_a(ui::ET_MOUSE_PRESSED, point, point,
1058 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 1031 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
1059 textfield_view_->OnMousePressed(click_a); 1032 textfield_->OnMousePressed(click_a);
1060 EXPECT_TRUE(textfield_view_->CanStartDragForView(textfield_view_, 1033 EXPECT_TRUE(textfield_->CanStartDragForView(textfield_, click_a.location(),
1061 click_a.location(), gfx::Point())); 1034 gfx::Point()));
1062 operations = textfield_view_->GetDragOperationsForView(textfield_view_, 1035 operations = textfield_->GetDragOperationsForView(textfield_,
1063 click_a.location()); 1036 click_a.location());
1064 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY, 1037 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY,
1065 operations); 1038 operations);
1066 textfield_view_->WriteDragDataForView(NULL, click_a.location(), &data); 1039 textfield_->WriteDragDataForView(NULL, click_a.location(), &data);
1067 EXPECT_TRUE(data.GetString(&string)); 1040 EXPECT_TRUE(data.GetString(&string));
1068 EXPECT_EQ(textfield_->GetSelectedText(), string); 1041 EXPECT_EQ(textfield_->GetSelectedText(), string);
1069 EXPECT_TRUE(textfield_view_->GetDropFormats(&formats, &custom_formats)); 1042 EXPECT_TRUE(textfield_->GetDropFormats(&formats, &custom_formats));
1070 EXPECT_EQ(ui::OSExchangeData::STRING, formats); 1043 EXPECT_EQ(ui::OSExchangeData::STRING, formats);
1071 EXPECT_TRUE(custom_formats.empty()); 1044 EXPECT_TRUE(custom_formats.empty());
1072 1045
1073 // Drop " worl" after "h". 1046 // Drop " worl" after "h".
1074 EXPECT_TRUE(textfield_view_->CanDrop(data)); 1047 EXPECT_TRUE(textfield_->CanDrop(data));
1075 gfx::Point drop_point(GetCursorPositionX(1), 0); 1048 gfx::Point drop_point(GetCursorPositionX(1), 0);
1076 ui::DropTargetEvent drop_a(data, drop_point, drop_point, operations); 1049 ui::DropTargetEvent drop_a(data, drop_point, drop_point, operations);
1077 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, 1050 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnDragUpdated(drop_a));
1078 textfield_view_->OnDragUpdated(drop_a)); 1051 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnPerformDrop(drop_a));
1079 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE,
1080 textfield_view_->OnPerformDrop(drop_a));
1081 EXPECT_STR_EQ("h worlellod", textfield_->text()); 1052 EXPECT_STR_EQ("h worlellod", textfield_->text());
1082 textfield_view_->OnDragDone(); 1053 textfield_->OnDragDone();
1083 1054
1084 // Undo/Redo the drag&drop change. 1055 // Undo/Redo the drag&drop change.
1085 SendKeyEvent(ui::VKEY_Z, false, true); 1056 SendKeyEvent(ui::VKEY_Z, false, true);
1086 EXPECT_STR_EQ("hello world", textfield_->text()); 1057 EXPECT_STR_EQ("hello world", textfield_->text());
1087 SendKeyEvent(ui::VKEY_Z, false, true); 1058 SendKeyEvent(ui::VKEY_Z, false, true);
1088 EXPECT_STR_EQ("", textfield_->text()); 1059 EXPECT_STR_EQ("", textfield_->text());
1089 SendKeyEvent(ui::VKEY_Z, false, true); 1060 SendKeyEvent(ui::VKEY_Z, false, true);
1090 EXPECT_STR_EQ("", textfield_->text()); 1061 EXPECT_STR_EQ("", textfield_->text());
1091 SendKeyEvent(ui::VKEY_Y, false, true); 1062 SendKeyEvent(ui::VKEY_Y, false, true);
1092 EXPECT_STR_EQ("hello world", textfield_->text()); 1063 EXPECT_STR_EQ("hello world", textfield_->text());
1093 SendKeyEvent(ui::VKEY_Y, false, true); 1064 SendKeyEvent(ui::VKEY_Y, false, true);
1094 EXPECT_STR_EQ("h worlellod", textfield_->text()); 1065 EXPECT_STR_EQ("h worlellod", textfield_->text());
1095 SendKeyEvent(ui::VKEY_Y, false, true); 1066 SendKeyEvent(ui::VKEY_Y, false, true);
1096 EXPECT_STR_EQ("h worlellod", textfield_->text()); 1067 EXPECT_STR_EQ("h worlellod", textfield_->text());
1097 } 1068 }
1098 1069
1099 TEST_F(NativeTextfieldViewsTest, DragAndDrop_Canceled) { 1070 TEST_F(TextfieldTest, DragAndDrop_Canceled) {
1100 InitTextfield(Textfield::STYLE_DEFAULT); 1071 InitTextfield(Textfield::STYLE_DEFAULT);
1101 textfield_->SetText(ASCIIToUTF16("hello world")); 1072 textfield_->SetText(ASCIIToUTF16("hello world"));
1102 1073
1103 // Start dragging "worl". 1074 // Start dragging "worl".
1104 textfield_->SelectRange(gfx::Range(6, 10)); 1075 textfield_->SelectRange(gfx::Range(6, 10));
1105 gfx::Point point(GetCursorPositionX(8), 0); 1076 gfx::Point point(GetCursorPositionX(8), 0);
1106 ui::MouseEvent click(ui::ET_MOUSE_PRESSED, point, point, 1077 ui::MouseEvent click(ui::ET_MOUSE_PRESSED, point, point,
1107 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 1078 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
1108 textfield_view_->OnMousePressed(click); 1079 textfield_->OnMousePressed(click);
1109 ui::OSExchangeData data; 1080 ui::OSExchangeData data;
1110 textfield_view_->WriteDragDataForView(NULL, click.location(), &data); 1081 textfield_->WriteDragDataForView(NULL, click.location(), &data);
1111 EXPECT_TRUE(textfield_view_->CanDrop(data)); 1082 EXPECT_TRUE(textfield_->CanDrop(data));
1112 // Drag the text over somewhere valid, outside the current selection. 1083 // Drag the text over somewhere valid, outside the current selection.
1113 gfx::Point drop_point(GetCursorPositionX(2), 0); 1084 gfx::Point drop_point(GetCursorPositionX(2), 0);
1114 ui::DropTargetEvent drop(data, drop_point, drop_point, 1085 ui::DropTargetEvent drop(data, drop_point, drop_point,
1115 ui::DragDropTypes::DRAG_MOVE); 1086 ui::DragDropTypes::DRAG_MOVE);
1116 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_view_->OnDragUpdated(drop)); 1087 EXPECT_EQ(ui::DragDropTypes::DRAG_MOVE, textfield_->OnDragUpdated(drop));
1117 // "Cancel" the drag, via move and release over the selection, and OnDragDone. 1088 // "Cancel" the drag, via move and release over the selection, and OnDragDone.
1118 gfx::Point drag_point(GetCursorPositionX(9), 0); 1089 gfx::Point drag_point(GetCursorPositionX(9), 0);
1119 ui::MouseEvent drag(ui::ET_MOUSE_DRAGGED, drag_point, drag_point, 1090 ui::MouseEvent drag(ui::ET_MOUSE_DRAGGED, drag_point, drag_point,
1120 ui::EF_LEFT_MOUSE_BUTTON, 0); 1091 ui::EF_LEFT_MOUSE_BUTTON, 0);
1121 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, drag_point, drag_point, 1092 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, drag_point, drag_point,
1122 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); 1093 ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
1123 textfield_view_->OnMouseDragged(drag); 1094 textfield_->OnMouseDragged(drag);
1124 textfield_view_->OnMouseReleased(release); 1095 textfield_->OnMouseReleased(release);
1125 textfield_view_->OnDragDone(); 1096 textfield_->OnDragDone();
1126 EXPECT_EQ(ASCIIToUTF16("hello world"), textfield_->text()); 1097 EXPECT_EQ(ASCIIToUTF16("hello world"), textfield_->text());
1127 } 1098 }
1128 1099
1129 TEST_F(NativeTextfieldViewsTest, ReadOnlyTest) { 1100 TEST_F(TextfieldTest, ReadOnlyTest) {
1130 InitTextfield(Textfield::STYLE_DEFAULT); 1101 InitTextfield(Textfield::STYLE_DEFAULT);
1131 textfield_->SetText(ASCIIToUTF16("read only")); 1102 textfield_->SetText(ASCIIToUTF16("read only"));
1132 textfield_->SetReadOnly(true); 1103 textfield_->SetReadOnly(true);
1133 EXPECT_TRUE(textfield_->enabled()); 1104 EXPECT_TRUE(textfield_->enabled());
1134 EXPECT_TRUE(textfield_->focusable()); 1105 EXPECT_TRUE(textfield_->focusable());
1135 1106
1136 SendKeyEvent(ui::VKEY_HOME); 1107 SendKeyEvent(ui::VKEY_HOME);
1137 EXPECT_EQ(0U, textfield_->GetCursorPosition()); 1108 EXPECT_EQ(0U, textfield_->GetCursorPosition());
1138 SendKeyEvent(ui::VKEY_END); 1109 SendKeyEvent(ui::VKEY_END);
1139 EXPECT_EQ(9U, textfield_->GetCursorPosition()); 1110 EXPECT_EQ(9U, textfield_->GetCursorPosition());
1140 1111
1141 SendKeyEvent(ui::VKEY_LEFT, false, false); 1112 SendKeyEvent(ui::VKEY_LEFT, false, false);
1142 EXPECT_EQ(8U, textfield_->GetCursorPosition()); 1113 EXPECT_EQ(8U, textfield_->GetCursorPosition());
1143 SendKeyEvent(ui::VKEY_LEFT, false, true); 1114 SendKeyEvent(ui::VKEY_LEFT, false, true);
1144 EXPECT_EQ(5U, textfield_->GetCursorPosition()); 1115 EXPECT_EQ(5U, textfield_->GetCursorPosition());
1145 SendKeyEvent(ui::VKEY_LEFT, true, true); 1116 SendKeyEvent(ui::VKEY_LEFT, true, true);
1146 EXPECT_EQ(0U, textfield_->GetCursorPosition()); 1117 EXPECT_EQ(0U, textfield_->GetCursorPosition());
1147 EXPECT_STR_EQ("read ", textfield_->GetSelectedText()); 1118 EXPECT_STR_EQ("read ", textfield_->GetSelectedText());
1148 textfield_->SelectAll(false); 1119 textfield_->SelectAll(false);
1149 EXPECT_STR_EQ("read only", textfield_->GetSelectedText()); 1120 EXPECT_STR_EQ("read only", textfield_->GetSelectedText());
1150 1121
1151 // Cut should be disabled. 1122 // Cut should be disabled.
1152 SetClipboardText("Test"); 1123 SetClipboardText("Test");
1153 EXPECT_FALSE(textfield_view_->IsCommandIdEnabled(IDS_APP_CUT)); 1124 EXPECT_FALSE(textfield_->IsCommandIdEnabled(IDS_APP_CUT));
1154 textfield_view_->ExecuteCommand(IDS_APP_CUT, 0); 1125 textfield_->ExecuteCommand(IDS_APP_CUT, 0);
1155 SendKeyEvent(ui::VKEY_X, false, true); 1126 SendKeyEvent(ui::VKEY_X, false, true);
1156 SendKeyEvent(ui::VKEY_DELETE, true, false); 1127 SendKeyEvent(ui::VKEY_DELETE, true, false);
1157 EXPECT_STR_EQ("Test", base::string16(GetClipboardText())); 1128 EXPECT_STR_EQ("Test", base::string16(GetClipboardText()));
1158 EXPECT_STR_EQ("read only", textfield_->text()); 1129 EXPECT_STR_EQ("read only", textfield_->text());
1159 1130
1160 // Paste should be disabled. 1131 // Paste should be disabled.
1161 EXPECT_FALSE(textfield_view_->IsCommandIdEnabled(IDS_APP_PASTE)); 1132 EXPECT_FALSE(textfield_->IsCommandIdEnabled(IDS_APP_PASTE));
1162 textfield_view_->ExecuteCommand(IDS_APP_PASTE, 0); 1133 textfield_->ExecuteCommand(IDS_APP_PASTE, 0);
1163 SendKeyEvent(ui::VKEY_V, false, true); 1134 SendKeyEvent(ui::VKEY_V, false, true);
1164 SendKeyEvent(ui::VKEY_INSERT, true, false); 1135 SendKeyEvent(ui::VKEY_INSERT, true, false);
1165 EXPECT_STR_EQ("read only", textfield_->text()); 1136 EXPECT_STR_EQ("read only", textfield_->text());
1166 1137
1167 // Copy should work normally. 1138 // Copy should work normally.
1168 SetClipboardText("Test"); 1139 SetClipboardText("Test");
1169 EXPECT_TRUE(textfield_view_->IsCommandIdEnabled(IDS_APP_COPY)); 1140 EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_COPY));
1170 textfield_view_->ExecuteCommand(IDS_APP_COPY, 0); 1141 textfield_->ExecuteCommand(IDS_APP_COPY, 0);
1171 EXPECT_STR_EQ("read only", base::string16(GetClipboardText())); 1142 EXPECT_STR_EQ("read only", base::string16(GetClipboardText()));
1172 SetClipboardText("Test"); 1143 SetClipboardText("Test");
1173 SendKeyEvent(ui::VKEY_C, false, true); 1144 SendKeyEvent(ui::VKEY_C, false, true);
1174 EXPECT_STR_EQ("read only", base::string16(GetClipboardText())); 1145 EXPECT_STR_EQ("read only", base::string16(GetClipboardText()));
1175 SetClipboardText("Test"); 1146 SetClipboardText("Test");
1176 SendKeyEvent(ui::VKEY_INSERT, false, true); 1147 SendKeyEvent(ui::VKEY_INSERT, false, true);
1177 EXPECT_STR_EQ("read only", base::string16(GetClipboardText())); 1148 EXPECT_STR_EQ("read only", base::string16(GetClipboardText()));
1178 1149
1179 // SetText should work even in read only mode. 1150 // SetText should work even in read only mode.
1180 textfield_->SetText(ASCIIToUTF16(" four five six ")); 1151 textfield_->SetText(ASCIIToUTF16(" four five six "));
1181 EXPECT_STR_EQ(" four five six ", textfield_->text()); 1152 EXPECT_STR_EQ(" four five six ", textfield_->text());
1182 1153
1183 textfield_->SelectAll(false); 1154 textfield_->SelectAll(false);
1184 EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText()); 1155 EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
1185 1156
1186 // Text field is unmodifiable and selection shouldn't change. 1157 // Text field is unmodifiable and selection shouldn't change.
1187 SendKeyEvent(ui::VKEY_DELETE); 1158 SendKeyEvent(ui::VKEY_DELETE);
1188 EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText()); 1159 EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
1189 SendKeyEvent(ui::VKEY_BACK); 1160 SendKeyEvent(ui::VKEY_BACK);
1190 EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText()); 1161 EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
1191 SendKeyEvent(ui::VKEY_T); 1162 SendKeyEvent(ui::VKEY_T);
1192 EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText()); 1163 EXPECT_STR_EQ(" four five six ", textfield_->GetSelectedText());
1193 } 1164 }
1194 1165
1195 TEST_F(NativeTextfieldViewsTest, TextInputClientTest) { 1166 TEST_F(TextfieldTest, TextInputClientTest) {
1196 InitTextfield(Textfield::STYLE_DEFAULT); 1167 InitTextfield(Textfield::STYLE_DEFAULT);
1197 ui::TextInputClient* client = textfield_->GetTextInputClient(); 1168 ui::TextInputClient* client = textfield_->GetTextInputClient();
1198 EXPECT_TRUE(client); 1169 EXPECT_TRUE(client);
1199 EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, client->GetTextInputType()); 1170 EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, client->GetTextInputType());
1200 1171
1201 textfield_->SetText(ASCIIToUTF16("0123456789")); 1172 textfield_->SetText(ASCIIToUTF16("0123456789"));
1202 gfx::Range range; 1173 gfx::Range range;
1203 EXPECT_TRUE(client->GetTextRange(&range)); 1174 EXPECT_TRUE(client->GetTextRange(&range));
1204 EXPECT_EQ(0U, range.start()); 1175 EXPECT_EQ(0U, range.start());
1205 EXPECT_EQ(10U, range.end()); 1176 EXPECT_EQ(10U, range.end());
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after
1290 EXPECT_TRUE(input_method_->text_input_type_changed()); 1261 EXPECT_TRUE(input_method_->text_input_type_changed());
1291 EXPECT_FALSE(textfield_->GetTextInputClient()); 1262 EXPECT_FALSE(textfield_->GetTextInputClient());
1292 1263
1293 textfield_->SetReadOnly(false); 1264 textfield_->SetReadOnly(false);
1294 input_method_->Clear(); 1265 input_method_->Clear();
1295 textfield_->SetObscured(true); 1266 textfield_->SetObscured(true);
1296 EXPECT_TRUE(input_method_->text_input_type_changed()); 1267 EXPECT_TRUE(input_method_->text_input_type_changed());
1297 EXPECT_TRUE(textfield_->GetTextInputClient()); 1268 EXPECT_TRUE(textfield_->GetTextInputClient());
1298 } 1269 }
1299 1270
1300 TEST_F(NativeTextfieldViewsTest, UndoRedoTest) { 1271 TEST_F(TextfieldTest, UndoRedoTest) {
1301 InitTextfield(Textfield::STYLE_DEFAULT); 1272 InitTextfield(Textfield::STYLE_DEFAULT);
1302 SendKeyEvent(ui::VKEY_A); 1273 SendKeyEvent(ui::VKEY_A);
1303 EXPECT_STR_EQ("a", textfield_->text()); 1274 EXPECT_STR_EQ("a", textfield_->text());
1304 SendKeyEvent(ui::VKEY_Z, false, true); 1275 SendKeyEvent(ui::VKEY_Z, false, true);
1305 EXPECT_STR_EQ("", textfield_->text()); 1276 EXPECT_STR_EQ("", textfield_->text());
1306 SendKeyEvent(ui::VKEY_Z, false, true); 1277 SendKeyEvent(ui::VKEY_Z, false, true);
1307 EXPECT_STR_EQ("", textfield_->text()); 1278 EXPECT_STR_EQ("", textfield_->text());
1308 SendKeyEvent(ui::VKEY_Y, false, true); 1279 SendKeyEvent(ui::VKEY_Y, false, true);
1309 EXPECT_STR_EQ("a", textfield_->text()); 1280 EXPECT_STR_EQ("a", textfield_->text());
1310 SendKeyEvent(ui::VKEY_Y, false, true); 1281 SendKeyEvent(ui::VKEY_Y, false, true);
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after
1385 SendKeyEvent(ui::VKEY_Y, false, true); 1356 SendKeyEvent(ui::VKEY_Y, false, true);
1386 EXPECT_STR_EQ("ab", textfield_->text()); 1357 EXPECT_STR_EQ("ab", textfield_->text());
1387 SendKeyEvent(ui::VKEY_Y, false, true); 1358 SendKeyEvent(ui::VKEY_Y, false, true);
1388 EXPECT_STR_EQ("b", textfield_->text()); 1359 EXPECT_STR_EQ("b", textfield_->text());
1389 SendKeyEvent(ui::VKEY_Y, false, true); 1360 SendKeyEvent(ui::VKEY_Y, false, true);
1390 EXPECT_STR_EQ("", textfield_->text()); 1361 EXPECT_STR_EQ("", textfield_->text());
1391 SendKeyEvent(ui::VKEY_Y, false, true); 1362 SendKeyEvent(ui::VKEY_Y, false, true);
1392 EXPECT_STR_EQ("", textfield_->text()); 1363 EXPECT_STR_EQ("", textfield_->text());
1393 } 1364 }
1394 1365
1395 TEST_F(NativeTextfieldViewsTest, CutCopyPaste) { 1366 TEST_F(TextfieldTest, CutCopyPaste) {
1396 InitTextfield(Textfield::STYLE_DEFAULT); 1367 InitTextfield(Textfield::STYLE_DEFAULT);
1397 1368
1398 // Ensure IDS_APP_CUT cuts. 1369 // Ensure IDS_APP_CUT cuts.
1399 textfield_->SetText(ASCIIToUTF16("123")); 1370 textfield_->SetText(ASCIIToUTF16("123"));
1400 textfield_->SelectAll(false); 1371 textfield_->SelectAll(false);
1401 EXPECT_TRUE(textfield_view_->IsCommandIdEnabled(IDS_APP_CUT)); 1372 EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_CUT));
1402 textfield_view_->ExecuteCommand(IDS_APP_CUT, 0); 1373 textfield_->ExecuteCommand(IDS_APP_CUT, 0);
1403 EXPECT_STR_EQ("123", base::string16(GetClipboardText())); 1374 EXPECT_STR_EQ("123", base::string16(GetClipboardText()));
1404 EXPECT_STR_EQ("", textfield_->text()); 1375 EXPECT_STR_EQ("", textfield_->text());
1405 1376
1406 // Ensure [Ctrl]+[x] cuts and [Ctrl]+[Alt][x] does nothing. 1377 // Ensure [Ctrl]+[x] cuts and [Ctrl]+[Alt][x] does nothing.
1407 textfield_->SetText(ASCIIToUTF16("456")); 1378 textfield_->SetText(ASCIIToUTF16("456"));
1408 textfield_->SelectAll(false); 1379 textfield_->SelectAll(false);
1409 SendKeyEvent(ui::VKEY_X, true, false, true, false); 1380 SendKeyEvent(ui::VKEY_X, true, false, true, false);
1410 EXPECT_STR_EQ("123", base::string16(GetClipboardText())); 1381 EXPECT_STR_EQ("123", base::string16(GetClipboardText()));
1411 EXPECT_STR_EQ("456", textfield_->text()); 1382 EXPECT_STR_EQ("456", textfield_->text());
1412 SendKeyEvent(ui::VKEY_X, false, true); 1383 SendKeyEvent(ui::VKEY_X, false, true);
1413 EXPECT_STR_EQ("456", base::string16(GetClipboardText())); 1384 EXPECT_STR_EQ("456", base::string16(GetClipboardText()));
1414 EXPECT_STR_EQ("", textfield_->text()); 1385 EXPECT_STR_EQ("", textfield_->text());
1415 1386
1416 // Ensure [Shift]+[Delete] cuts. 1387 // Ensure [Shift]+[Delete] cuts.
1417 textfield_->SetText(ASCIIToUTF16("123")); 1388 textfield_->SetText(ASCIIToUTF16("123"));
1418 textfield_->SelectAll(false); 1389 textfield_->SelectAll(false);
1419 SendKeyEvent(ui::VKEY_DELETE, true, false); 1390 SendKeyEvent(ui::VKEY_DELETE, true, false);
1420 EXPECT_STR_EQ("123", base::string16(GetClipboardText())); 1391 EXPECT_STR_EQ("123", base::string16(GetClipboardText()));
1421 EXPECT_STR_EQ("", textfield_->text()); 1392 EXPECT_STR_EQ("", textfield_->text());
1422 1393
1423 // Ensure IDS_APP_COPY copies. 1394 // Ensure IDS_APP_COPY copies.
1424 textfield_->SetText(ASCIIToUTF16("789")); 1395 textfield_->SetText(ASCIIToUTF16("789"));
1425 textfield_->SelectAll(false); 1396 textfield_->SelectAll(false);
1426 EXPECT_TRUE(textfield_view_->IsCommandIdEnabled(IDS_APP_COPY)); 1397 EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_COPY));
1427 textfield_view_->ExecuteCommand(IDS_APP_COPY, 0); 1398 textfield_->ExecuteCommand(IDS_APP_COPY, 0);
1428 EXPECT_STR_EQ("789", base::string16(GetClipboardText())); 1399 EXPECT_STR_EQ("789", base::string16(GetClipboardText()));
1429 1400
1430 // Ensure [Ctrl]+[c] copies and [Ctrl]+[Alt][c] does nothing. 1401 // Ensure [Ctrl]+[c] copies and [Ctrl]+[Alt][c] does nothing.
1431 textfield_->SetText(ASCIIToUTF16("012")); 1402 textfield_->SetText(ASCIIToUTF16("012"));
1432 textfield_->SelectAll(false); 1403 textfield_->SelectAll(false);
1433 SendKeyEvent(ui::VKEY_C, true, false, true, false); 1404 SendKeyEvent(ui::VKEY_C, true, false, true, false);
1434 EXPECT_STR_EQ("789", base::string16(GetClipboardText())); 1405 EXPECT_STR_EQ("789", base::string16(GetClipboardText()));
1435 SendKeyEvent(ui::VKEY_C, false, true); 1406 SendKeyEvent(ui::VKEY_C, false, true);
1436 EXPECT_STR_EQ("012", base::string16(GetClipboardText())); 1407 EXPECT_STR_EQ("012", base::string16(GetClipboardText()));
1437 1408
1438 // Ensure [Ctrl]+[Insert] copies. 1409 // Ensure [Ctrl]+[Insert] copies.
1439 textfield_->SetText(ASCIIToUTF16("345")); 1410 textfield_->SetText(ASCIIToUTF16("345"));
1440 textfield_->SelectAll(false); 1411 textfield_->SelectAll(false);
1441 SendKeyEvent(ui::VKEY_INSERT, false, true); 1412 SendKeyEvent(ui::VKEY_INSERT, false, true);
1442 EXPECT_STR_EQ("345", base::string16(GetClipboardText())); 1413 EXPECT_STR_EQ("345", base::string16(GetClipboardText()));
1443 EXPECT_STR_EQ("345", textfield_->text()); 1414 EXPECT_STR_EQ("345", textfield_->text());
1444 1415
1445 // Ensure IDS_APP_PASTE, [Ctrl]+[V], and [Shift]+[Insert] pastes; 1416 // Ensure IDS_APP_PASTE, [Ctrl]+[V], and [Shift]+[Insert] pastes;
1446 // also ensure that [Ctrl]+[Alt]+[V] does nothing. 1417 // also ensure that [Ctrl]+[Alt]+[V] does nothing.
1447 SetClipboardText("abc"); 1418 SetClipboardText("abc");
1448 textfield_->SetText(base::string16()); 1419 textfield_->SetText(base::string16());
1449 EXPECT_TRUE(textfield_view_->IsCommandIdEnabled(IDS_APP_PASTE)); 1420 EXPECT_TRUE(textfield_->IsCommandIdEnabled(IDS_APP_PASTE));
1450 textfield_view_->ExecuteCommand(IDS_APP_PASTE, 0); 1421 textfield_->ExecuteCommand(IDS_APP_PASTE, 0);
1451 EXPECT_STR_EQ("abc", textfield_->text()); 1422 EXPECT_STR_EQ("abc", textfield_->text());
1452 SendKeyEvent(ui::VKEY_V, false, true); 1423 SendKeyEvent(ui::VKEY_V, false, true);
1453 EXPECT_STR_EQ("abcabc", textfield_->text()); 1424 EXPECT_STR_EQ("abcabc", textfield_->text());
1454 SendKeyEvent(ui::VKEY_INSERT, true, false); 1425 SendKeyEvent(ui::VKEY_INSERT, true, false);
1455 EXPECT_STR_EQ("abcabcabc", textfield_->text()); 1426 EXPECT_STR_EQ("abcabcabc", textfield_->text());
1456 SendKeyEvent(ui::VKEY_V, true, false, true, false); 1427 SendKeyEvent(ui::VKEY_V, true, false, true, false);
1457 EXPECT_STR_EQ("abcabcabc", textfield_->text()); 1428 EXPECT_STR_EQ("abcabcabc", textfield_->text());
1458 1429
1459 // Ensure [Ctrl]+[Shift]+[Insert] is a no-op. 1430 // Ensure [Ctrl]+[Shift]+[Insert] is a no-op.
1460 textfield_->SelectAll(false); 1431 textfield_->SelectAll(false);
1461 SendKeyEvent(ui::VKEY_INSERT, true, true); 1432 SendKeyEvent(ui::VKEY_INSERT, true, true);
1462 EXPECT_STR_EQ("abc", base::string16(GetClipboardText())); 1433 EXPECT_STR_EQ("abc", base::string16(GetClipboardText()));
1463 EXPECT_STR_EQ("abcabcabc", textfield_->text()); 1434 EXPECT_STR_EQ("abcabcabc", textfield_->text());
1464 } 1435 }
1465 1436
1466 TEST_F(NativeTextfieldViewsTest, OvertypeMode) { 1437 TEST_F(TextfieldTest, OvertypeMode) {
1467 InitTextfield(Textfield::STYLE_DEFAULT); 1438 InitTextfield(Textfield::STYLE_DEFAULT);
1468 // Overtype mode should be disabled (no-op [Insert]). 1439 // Overtype mode should be disabled (no-op [Insert]).
1469 textfield_->SetText(ASCIIToUTF16("2")); 1440 textfield_->SetText(ASCIIToUTF16("2"));
1470 SendKeyEvent(ui::VKEY_HOME); 1441 SendKeyEvent(ui::VKEY_HOME);
1471 SendKeyEvent(ui::VKEY_INSERT); 1442 SendKeyEvent(ui::VKEY_INSERT);
1472 SendKeyEvent(ui::VKEY_1, false, false); 1443 SendKeyEvent(ui::VKEY_1, false, false);
1473 EXPECT_STR_EQ("12", textfield_->text()); 1444 EXPECT_STR_EQ("12", textfield_->text());
1474 } 1445 }
1475 1446
1476 TEST_F(NativeTextfieldViewsTest, TextCursorDisplayTest) { 1447 TEST_F(TextfieldTest, TextCursorDisplayTest) {
1477 InitTextfield(Textfield::STYLE_DEFAULT); 1448 InitTextfield(Textfield::STYLE_DEFAULT);
1478 // LTR-RTL string in LTR context. 1449 // LTR-RTL string in LTR context.
1479 SendKeyEvent('a'); 1450 SendKeyEvent('a');
1480 EXPECT_STR_EQ("a", textfield_->text()); 1451 EXPECT_STR_EQ("a", textfield_->text());
1481 int x = GetCursorBounds().x(); 1452 int x = GetCursorBounds().x();
1482 int prev_x = x; 1453 int prev_x = x;
1483 1454
1484 SendKeyEvent('b'); 1455 SendKeyEvent('b');
1485 EXPECT_STR_EQ("ab", textfield_->text()); 1456 EXPECT_STR_EQ("ab", textfield_->text());
1486 x = GetCursorBounds().x(); 1457 x = GetCursorBounds().x();
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
1518 x = GetCursorBounds().x(); 1489 x = GetCursorBounds().x();
1519 EXPECT_LT(prev_x, x); 1490 EXPECT_LT(prev_x, x);
1520 prev_x = x; 1491 prev_x = x;
1521 1492
1522 SendKeyEvent('b'); 1493 SendKeyEvent('b');
1523 EXPECT_EQ(WideToUTF16(L"\x05E1\x5E2" L"ab"), textfield_->text()); 1494 EXPECT_EQ(WideToUTF16(L"\x05E1\x5E2" L"ab"), textfield_->text());
1524 x = GetCursorBounds().x(); 1495 x = GetCursorBounds().x();
1525 EXPECT_LT(prev_x, x); 1496 EXPECT_LT(prev_x, x);
1526 } 1497 }
1527 1498
1528 TEST_F(NativeTextfieldViewsTest, TextCursorDisplayInRTLTest) { 1499 TEST_F(TextfieldTest, TextCursorDisplayInRTLTest) {
1529 std::string locale = l10n_util::GetApplicationLocale(""); 1500 std::string locale = l10n_util::GetApplicationLocale("");
1530 base::i18n::SetICUDefaultLocale("he"); 1501 base::i18n::SetICUDefaultLocale("he");
1531 1502
1532 InitTextfield(Textfield::STYLE_DEFAULT); 1503 InitTextfield(Textfield::STYLE_DEFAULT);
1533 // LTR-RTL string in RTL context. 1504 // LTR-RTL string in RTL context.
1534 SendKeyEvent('a'); 1505 SendKeyEvent('a');
1535 EXPECT_STR_EQ("a", textfield_->text()); 1506 EXPECT_STR_EQ("a", textfield_->text());
1536 int x = GetCursorBounds().x(); 1507 int x = GetCursorBounds().x();
1537 EXPECT_EQ(GetDisplayRect().right() - 1, x); 1508 EXPECT_EQ(GetDisplayRect().right() - 1, x);
1538 int prev_x = x; 1509 int prev_x = x;
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
1576 1547
1577 SendKeyEvent('b'); 1548 SendKeyEvent('b');
1578 EXPECT_EQ(WideToUTF16(L"\x05E1\x5E2" L"ab"), textfield_->text()); 1549 EXPECT_EQ(WideToUTF16(L"\x05E1\x5E2" L"ab"), textfield_->text());
1579 x = GetCursorBounds().x(); 1550 x = GetCursorBounds().x();
1580 EXPECT_EQ(prev_x, x); 1551 EXPECT_EQ(prev_x, x);
1581 1552
1582 // Reset locale. 1553 // Reset locale.
1583 base::i18n::SetICUDefaultLocale(locale); 1554 base::i18n::SetICUDefaultLocale(locale);
1584 } 1555 }
1585 1556
1586 TEST_F(NativeTextfieldViewsTest, HitInsideTextAreaTest) { 1557 TEST_F(TextfieldTest, HitInsideTextAreaTest) {
1587 InitTextfield(Textfield::STYLE_DEFAULT); 1558 InitTextfield(Textfield::STYLE_DEFAULT);
1588 textfield_->SetText(WideToUTF16(L"ab\x05E1\x5E2")); 1559 textfield_->SetText(WideToUTF16(L"ab\x05E1\x5E2"));
1589 std::vector<gfx::Rect> cursor_bounds; 1560 std::vector<gfx::Rect> cursor_bounds;
1590 1561
1591 // Save each cursor bound. 1562 // Save each cursor bound.
1592 gfx::SelectionModel sel(0, gfx::CURSOR_FORWARD); 1563 gfx::SelectionModel sel(0, gfx::CURSOR_FORWARD);
1593 cursor_bounds.push_back(GetCursorBounds(sel)); 1564 cursor_bounds.push_back(GetCursorBounds(sel));
1594 1565
1595 sel = gfx::SelectionModel(1, gfx::CURSOR_BACKWARD); 1566 sel = gfx::SelectionModel(1, gfx::CURSOR_BACKWARD);
1596 gfx::Rect bound = GetCursorBounds(sel); 1567 gfx::Rect bound = GetCursorBounds(sel);
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
1631 // for the test to run if using sleep(). 1602 // for the test to run if using sleep().
1632 NonClientMouseClick(); 1603 NonClientMouseClick();
1633 1604
1634 MouseClick(cursor_bounds[i + 1], - (half_width / 2)); 1605 MouseClick(cursor_bounds[i + 1], - (half_width / 2));
1635 EXPECT_EQ(cursor_pos_expected[index++], textfield_->GetCursorPosition()); 1606 EXPECT_EQ(cursor_pos_expected[index++], textfield_->GetCursorPosition());
1636 1607
1637 NonClientMouseClick(); 1608 NonClientMouseClick();
1638 } 1609 }
1639 } 1610 }
1640 1611
1641 TEST_F(NativeTextfieldViewsTest, HitOutsideTextAreaTest) { 1612 TEST_F(TextfieldTest, HitOutsideTextAreaTest) {
1642 InitTextfield(Textfield::STYLE_DEFAULT); 1613 InitTextfield(Textfield::STYLE_DEFAULT);
1643 1614
1644 // LTR-RTL string in LTR context. 1615 // LTR-RTL string in LTR context.
1645 textfield_->SetText(WideToUTF16(L"ab\x05E1\x5E2")); 1616 textfield_->SetText(WideToUTF16(L"ab\x05E1\x5E2"));
1646 1617
1647 SendKeyEvent(ui::VKEY_HOME); 1618 SendKeyEvent(ui::VKEY_HOME);
1648 gfx::Rect bound = GetCursorBounds(); 1619 gfx::Rect bound = GetCursorBounds();
1649 MouseClick(bound, -10); 1620 MouseClick(bound, -10);
1650 EXPECT_EQ(bound, GetCursorBounds()); 1621 EXPECT_EQ(bound, GetCursorBounds());
1651 1622
(...skipping 11 matching lines...) Expand all
1663 bound = GetCursorBounds(); 1634 bound = GetCursorBounds();
1664 MouseClick(bound, 10); 1635 MouseClick(bound, 10);
1665 EXPECT_EQ(bound, GetCursorBounds()); 1636 EXPECT_EQ(bound, GetCursorBounds());
1666 1637
1667 SendKeyEvent(ui::VKEY_END); 1638 SendKeyEvent(ui::VKEY_END);
1668 bound = GetCursorBounds(); 1639 bound = GetCursorBounds();
1669 MouseClick(bound, -10); 1640 MouseClick(bound, -10);
1670 EXPECT_EQ(bound, GetCursorBounds()); 1641 EXPECT_EQ(bound, GetCursorBounds());
1671 } 1642 }
1672 1643
1673 TEST_F(NativeTextfieldViewsTest, HitOutsideTextAreaInRTLTest) { 1644 TEST_F(TextfieldTest, HitOutsideTextAreaInRTLTest) {
1674 std::string locale = l10n_util::GetApplicationLocale(""); 1645 std::string locale = l10n_util::GetApplicationLocale("");
1675 base::i18n::SetICUDefaultLocale("he"); 1646 base::i18n::SetICUDefaultLocale("he");
1676 1647
1677 InitTextfield(Textfield::STYLE_DEFAULT); 1648 InitTextfield(Textfield::STYLE_DEFAULT);
1678 1649
1679 // RTL-LTR string in RTL context. 1650 // RTL-LTR string in RTL context.
1680 textfield_->SetText(WideToUTF16(L"\x05E1\x5E2" L"ab")); 1651 textfield_->SetText(WideToUTF16(L"\x05E1\x5E2" L"ab"));
1681 SendKeyEvent(ui::VKEY_HOME); 1652 SendKeyEvent(ui::VKEY_HOME);
1682 gfx::Rect bound = GetCursorBounds(); 1653 gfx::Rect bound = GetCursorBounds();
1683 MouseClick(bound, 10); 1654 MouseClick(bound, 10);
(...skipping 15 matching lines...) Expand all
1699 1670
1700 SendKeyEvent(ui::VKEY_END); 1671 SendKeyEvent(ui::VKEY_END);
1701 bound = GetCursorBounds(); 1672 bound = GetCursorBounds();
1702 MouseClick(bound, 10); 1673 MouseClick(bound, 10);
1703 EXPECT_EQ(bound, GetCursorBounds()); 1674 EXPECT_EQ(bound, GetCursorBounds());
1704 1675
1705 // Reset locale. 1676 // Reset locale.
1706 base::i18n::SetICUDefaultLocale(locale); 1677 base::i18n::SetICUDefaultLocale(locale);
1707 } 1678 }
1708 1679
1709 TEST_F(NativeTextfieldViewsTest, OverflowTest) { 1680 TEST_F(TextfieldTest, OverflowTest) {
1710 InitTextfield(Textfield::STYLE_DEFAULT); 1681 InitTextfield(Textfield::STYLE_DEFAULT);
1711 1682
1712 base::string16 str; 1683 base::string16 str;
1713 for (int i = 0; i < 500; ++i) 1684 for (int i = 0; i < 500; ++i)
1714 SendKeyEvent('a'); 1685 SendKeyEvent('a');
1715 SendKeyEvent(kHebrewLetterSamekh); 1686 SendKeyEvent(kHebrewLetterSamekh);
1716 EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds())); 1687 EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
1717 1688
1718 // Test mouse pointing. 1689 // Test mouse pointing.
1719 MouseClick(GetCursorBounds(), -1); 1690 MouseClick(GetCursorBounds(), -1);
1720 EXPECT_EQ(500U, textfield_->GetCursorPosition()); 1691 EXPECT_EQ(500U, textfield_->GetCursorPosition());
1721 1692
1722 // Clear text. 1693 // Clear text.
1723 SendKeyEvent(ui::VKEY_A, false, true); 1694 SendKeyEvent(ui::VKEY_A, false, true);
1724 SendKeyEvent('\n'); 1695 SendKeyEvent('\n');
1725 1696
1726 for (int i = 0; i < 500; ++i) 1697 for (int i = 0; i < 500; ++i)
1727 SendKeyEvent(kHebrewLetterSamekh); 1698 SendKeyEvent(kHebrewLetterSamekh);
1728 SendKeyEvent('a'); 1699 SendKeyEvent('a');
1729 EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds())); 1700 EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
1730 1701
1731 MouseClick(GetCursorBounds(), -1); 1702 MouseClick(GetCursorBounds(), -1);
1732 EXPECT_EQ(501U, textfield_->GetCursorPosition()); 1703 EXPECT_EQ(501U, textfield_->GetCursorPosition());
1733 } 1704 }
1734 1705
1735 TEST_F(NativeTextfieldViewsTest, OverflowInRTLTest) { 1706 TEST_F(TextfieldTest, OverflowInRTLTest) {
1736 std::string locale = l10n_util::GetApplicationLocale(""); 1707 std::string locale = l10n_util::GetApplicationLocale("");
1737 base::i18n::SetICUDefaultLocale("he"); 1708 base::i18n::SetICUDefaultLocale("he");
1738 1709
1739 InitTextfield(Textfield::STYLE_DEFAULT); 1710 InitTextfield(Textfield::STYLE_DEFAULT);
1740 1711
1741 base::string16 str; 1712 base::string16 str;
1742 for (int i = 0; i < 500; ++i) 1713 for (int i = 0; i < 500; ++i)
1743 SendKeyEvent('a'); 1714 SendKeyEvent('a');
1744 SendKeyEvent(kHebrewLetterSamekh); 1715 SendKeyEvent(kHebrewLetterSamekh);
1745 EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds())); 1716 EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
(...skipping 10 matching lines...) Expand all
1756 SendKeyEvent('a'); 1727 SendKeyEvent('a');
1757 EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds())); 1728 EXPECT_TRUE(GetDisplayRect().Contains(GetCursorBounds()));
1758 1729
1759 MouseClick(GetCursorBounds(), 1); 1730 MouseClick(GetCursorBounds(), 1);
1760 EXPECT_EQ(500U, textfield_->GetCursorPosition()); 1731 EXPECT_EQ(500U, textfield_->GetCursorPosition());
1761 1732
1762 // Reset locale. 1733 // Reset locale.
1763 base::i18n::SetICUDefaultLocale(locale); 1734 base::i18n::SetICUDefaultLocale(locale);
1764 } 1735 }
1765 1736
1766 TEST_F(NativeTextfieldViewsTest, GetCompositionCharacterBoundsTest) { 1737 TEST_F(TextfieldTest, GetCompositionCharacterBoundsTest) {
1767 InitTextfield(Textfield::STYLE_DEFAULT); 1738 InitTextfield(Textfield::STYLE_DEFAULT);
1768 1739
1769 base::string16 str; 1740 base::string16 str;
1770 const uint32 char_count = 10UL; 1741 const uint32 char_count = 10UL;
1771 ui::CompositionText composition; 1742 ui::CompositionText composition;
1772 composition.text = UTF8ToUTF16("0123456789"); 1743 composition.text = UTF8ToUTF16("0123456789");
1773 ui::TextInputClient* client = textfield_->GetTextInputClient(); 1744 ui::TextInputClient* client = textfield_->GetTextInputClient();
1774 1745
1775 // Return false if there is no composition text. 1746 // Return false if there is no composition text.
1776 gfx::Rect rect; 1747 gfx::Rect rect;
1777 EXPECT_FALSE(client->GetCompositionCharacterBounds(0, &rect)); 1748 EXPECT_FALSE(client->GetCompositionCharacterBounds(0, &rect));
1778 1749
1779 // Get each character boundary by cursor. 1750 // Get each character boundary by cursor.
1780 gfx::Rect char_rect_in_screen_coord[char_count]; 1751 gfx::Rect char_rect_in_screen_coord[char_count];
1781 gfx::Rect prev_cursor = GetCursorBounds(); 1752 gfx::Rect prev_cursor = GetCursorBounds();
1782 for (uint32 i = 0; i < char_count; ++i) { 1753 for (uint32 i = 0; i < char_count; ++i) {
1783 composition.selection = gfx::Range(0, i+1); 1754 composition.selection = gfx::Range(0, i+1);
1784 client->SetCompositionText(composition); 1755 client->SetCompositionText(composition);
1785 EXPECT_TRUE(client->HasCompositionText()) << " i=" << i; 1756 EXPECT_TRUE(client->HasCompositionText()) << " i=" << i;
1786 gfx::Rect cursor_bounds = GetCursorBounds(); 1757 gfx::Rect cursor_bounds = GetCursorBounds();
1787 gfx::Point top_left(prev_cursor.x(), prev_cursor.y()); 1758 gfx::Point top_left(prev_cursor.x(), prev_cursor.y());
1788 gfx::Point bottom_right(cursor_bounds.x(), prev_cursor.bottom()); 1759 gfx::Point bottom_right(cursor_bounds.x(), prev_cursor.bottom());
1789 views::View::ConvertPointToScreen(textfield_view_, &top_left); 1760 views::View::ConvertPointToScreen(textfield_, &top_left);
1790 views::View::ConvertPointToScreen(textfield_view_, &bottom_right); 1761 views::View::ConvertPointToScreen(textfield_, &bottom_right);
1791 char_rect_in_screen_coord[i].set_origin(top_left); 1762 char_rect_in_screen_coord[i].set_origin(top_left);
1792 char_rect_in_screen_coord[i].set_width(bottom_right.x() - top_left.x()); 1763 char_rect_in_screen_coord[i].set_width(bottom_right.x() - top_left.x());
1793 char_rect_in_screen_coord[i].set_height(bottom_right.y() - top_left.y()); 1764 char_rect_in_screen_coord[i].set_height(bottom_right.y() - top_left.y());
1794 prev_cursor = cursor_bounds; 1765 prev_cursor = cursor_bounds;
1795 } 1766 }
1796 1767
1797 for (uint32 i = 0; i < char_count; ++i) { 1768 for (uint32 i = 0; i < char_count; ++i) {
1798 gfx::Rect actual_rect; 1769 gfx::Rect actual_rect;
1799 EXPECT_TRUE(client->GetCompositionCharacterBounds(i, &actual_rect)) 1770 EXPECT_TRUE(client->GetCompositionCharacterBounds(i, &actual_rect))
1800 << " i=" << i; 1771 << " i=" << i;
1801 EXPECT_EQ(char_rect_in_screen_coord[i], actual_rect) << " i=" << i; 1772 EXPECT_EQ(char_rect_in_screen_coord[i], actual_rect) << " i=" << i;
1802 } 1773 }
1803 1774
1804 // Return false if the index is out of range. 1775 // Return false if the index is out of range.
1805 EXPECT_FALSE(client->GetCompositionCharacterBounds(char_count, &rect)); 1776 EXPECT_FALSE(client->GetCompositionCharacterBounds(char_count, &rect));
1806 EXPECT_FALSE(client->GetCompositionCharacterBounds(char_count + 1, &rect)); 1777 EXPECT_FALSE(client->GetCompositionCharacterBounds(char_count + 1, &rect));
1807 EXPECT_FALSE(client->GetCompositionCharacterBounds(char_count + 100, &rect)); 1778 EXPECT_FALSE(client->GetCompositionCharacterBounds(char_count + 100, &rect));
1808 } 1779 }
1809 1780
1810 TEST_F(NativeTextfieldViewsTest, GetCompositionCharacterBounds_ComplexText) { 1781 TEST_F(TextfieldTest, GetCompositionCharacterBounds_ComplexText) {
1811 InitTextfield(Textfield::STYLE_DEFAULT); 1782 InitTextfield(Textfield::STYLE_DEFAULT);
1812 1783
1813 const base::char16 kUtf16Chars[] = { 1784 const base::char16 kUtf16Chars[] = {
1814 // U+0020 SPACE 1785 // U+0020 SPACE
1815 0x0020, 1786 0x0020,
1816 // U+1F408 (CAT) as surrogate pair 1787 // U+1F408 (CAT) as surrogate pair
1817 0xd83d, 0xdc08, 1788 0xd83d, 0xdc08,
1818 // U+5642 as Ideographic Variation Sequences 1789 // U+5642 as Ideographic Variation Sequences
1819 0x5642, 0xDB40, 0xDD00, 1790 0x5642, 0xDB40, 0xDD00,
1820 // U+260E (BLACK TELEPHONE) as Emoji Variation Sequences 1791 // U+260E (BLACK TELEPHONE) as Emoji Variation Sequences
(...skipping 16 matching lines...) Expand all
1837 1808
1838 // Here we might expect the following results but it actually depends on how 1809 // Here we might expect the following results but it actually depends on how
1839 // Uniscribe or HarfBuzz treats them with given font. 1810 // Uniscribe or HarfBuzz treats them with given font.
1840 // - rects[1] == rects[2] 1811 // - rects[1] == rects[2]
1841 // - rects[3] == rects[4] == rects[5] 1812 // - rects[3] == rects[4] == rects[5]
1842 // - rects[6] == rects[7] 1813 // - rects[6] == rects[7]
1843 } 1814 }
1844 1815
1845 // The word we select by double clicking should remain selected regardless of 1816 // The word we select by double clicking should remain selected regardless of
1846 // where we drag the mouse afterwards without releasing the left button. 1817 // where we drag the mouse afterwards without releasing the left button.
1847 TEST_F(NativeTextfieldViewsTest, KeepInitiallySelectedWord) { 1818 TEST_F(TextfieldTest, KeepInitiallySelectedWord) {
1848 InitTextfield(Textfield::STYLE_DEFAULT); 1819 InitTextfield(Textfield::STYLE_DEFAULT);
1849 1820
1850 textfield_->SetText(ASCIIToUTF16("abc def ghi")); 1821 textfield_->SetText(ASCIIToUTF16("abc def ghi"));
1851 1822
1852 textfield_->SelectRange(gfx::Range(5, 5)); 1823 textfield_->SelectRange(gfx::Range(5, 5));
1853 const gfx::Rect middle_cursor = GetCursorBounds(); 1824 const gfx::Rect middle_cursor = GetCursorBounds();
1854 textfield_->SelectRange(gfx::Range(0, 0)); 1825 textfield_->SelectRange(gfx::Range(0, 0));
1855 const gfx::Point beginning = GetCursorBounds().origin(); 1826 const gfx::Point beginning = GetCursorBounds().origin();
1856 1827
1857 // Double click, but do not release the left button. 1828 // Double click, but do not release the left button.
1858 MouseClick(middle_cursor, 0); 1829 MouseClick(middle_cursor, 0);
1859 const gfx::Point middle(middle_cursor.x(), 1830 const gfx::Point middle(middle_cursor.x(),
1860 middle_cursor.y() + middle_cursor.height() / 2); 1831 middle_cursor.y() + middle_cursor.height() / 2);
1861 ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, middle, middle, 1832 ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, middle, middle,
1862 ui::EF_LEFT_MOUSE_BUTTON, 1833 ui::EF_LEFT_MOUSE_BUTTON,
1863 ui::EF_LEFT_MOUSE_BUTTON); 1834 ui::EF_LEFT_MOUSE_BUTTON);
1864 textfield_view_->OnMousePressed(press_event); 1835 textfield_->OnMousePressed(press_event);
1865 EXPECT_EQ(gfx::Range(4, 7), textfield_->GetSelectedRange()); 1836 EXPECT_EQ(gfx::Range(4, 7), textfield_->GetSelectedRange());
1866 1837
1867 // Drag the mouse to the beginning of the textfield. 1838 // Drag the mouse to the beginning of the textfield.
1868 ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED, beginning, beginning, 1839 ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED, beginning, beginning,
1869 ui::EF_LEFT_MOUSE_BUTTON, 0); 1840 ui::EF_LEFT_MOUSE_BUTTON, 0);
1870 textfield_view_->OnMouseDragged(drag_event); 1841 textfield_->OnMouseDragged(drag_event);
1871 EXPECT_EQ(gfx::Range(7, 0), textfield_->GetSelectedRange()); 1842 EXPECT_EQ(gfx::Range(7, 0), textfield_->GetSelectedRange());
1872 } 1843 }
1873 1844
1874 // Touch selection and draggin currently only works for chromeos. 1845 // Touch selection and dragging currently only works for chromeos.
1875 #if defined(OS_CHROMEOS) 1846 #if defined(OS_CHROMEOS)
1876 TEST_F(NativeTextfieldViewsTest, TouchSelectionAndDraggingTest) { 1847 TEST_F(TextfieldTest, TouchSelectionAndDraggingTest) {
1877 InitTextfield(Textfield::STYLE_DEFAULT); 1848 InitTextfield(Textfield::STYLE_DEFAULT);
1878 textfield_->SetText(ASCIIToUTF16("hello world")); 1849 textfield_->SetText(ASCIIToUTF16("hello world"));
1879 EXPECT_FALSE(GetTouchSelectionController()); 1850 EXPECT_FALSE(GetTouchSelectionController());
1880 const int eventX = GetCursorPositionX(2); 1851 const int x = GetCursorPositionX(2);
1881 const int eventY = 0; 1852 GestureEventForTest tap(ui::ET_GESTURE_TAP, x, 0, 1.0f, 0.0f);
1853 GestureEventForTest tap_down(ui::ET_GESTURE_TAP_DOWN, x, 0, 0.0f, 0.0f);
1854 GestureEventForTest long_press(ui::ET_GESTURE_LONG_PRESS, x, 0, 0.0f, 0.0f);
1882 CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableTouchEditing); 1855 CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableTouchEditing);
1883 1856
1884 // Tapping on the textfield should turn on the TouchSelectionController. 1857 // Tapping on the textfield should turn on the TouchSelectionController.
1885 GestureEventForTest tap(ui::ET_GESTURE_TAP, eventX, eventY, 1.0f, 0.0f); 1858 textfield_->OnGestureEvent(&tap);
1886 textfield_view_->OnGestureEvent(&tap);
1887 EXPECT_TRUE(GetTouchSelectionController()); 1859 EXPECT_TRUE(GetTouchSelectionController());
1888 1860
1889 // Un-focusing the textfield should reset the TouchSelectionController 1861 // Un-focusing the textfield should reset the TouchSelectionController
1890 textfield_view_->GetFocusManager()->ClearFocus(); 1862 textfield_->GetFocusManager()->ClearFocus();
1891 EXPECT_FALSE(GetTouchSelectionController()); 1863 EXPECT_FALSE(GetTouchSelectionController());
1892 1864
1893 // With touch editing enabled, long press should not show context menu. 1865 // With touch editing enabled, long press should not show context menu.
1894 // Instead, select word and invoke TouchSelectionController. 1866 // Instead, select word and invoke TouchSelectionController.
1895 GestureEventForTest tap_down(ui::ET_GESTURE_TAP_DOWN, eventX, eventY, 0.0f, 1867 textfield_->OnGestureEvent(&tap_down);
1896 0.0f); 1868 textfield_->OnGestureEvent(&long_press);
1897 textfield_view_->OnGestureEvent(&tap_down);
1898 GestureEventForTest long_press(ui::ET_GESTURE_LONG_PRESS, eventX, eventY,
1899 0.0f, 0.0f);
1900 textfield_view_->OnGestureEvent(&long_press);
1901 EXPECT_STR_EQ("hello", textfield_->GetSelectedText()); 1869 EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
1902 EXPECT_TRUE(GetTouchSelectionController()); 1870 EXPECT_TRUE(GetTouchSelectionController());
1903 1871
1904 // Long pressing again in the selecting region should not do anything since 1872 // With touch drag drop enabled, long pressing in the selected region should
1905 // touch drag drop is not yet enabled. 1873 // start a drag and remove TouchSelectionController.
1906 textfield_view_->OnGestureEvent(&tap_down); 1874 ASSERT_TRUE(switches::IsTouchDragDropEnabled());
1907 textfield_view_->OnGestureEvent(&long_press); 1875 textfield_->OnGestureEvent(&tap_down);
1876 textfield_->OnGestureEvent(&long_press);
1877 EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
1878 EXPECT_FALSE(GetTouchSelectionController());
1879
1880 // After disabling touch drag drop, long pressing again in the selection
1881 // region should not do anything.
1882 CommandLine::ForCurrentProcess()->AppendSwitch(
1883 switches::kDisableTouchDragDrop);
1884 ASSERT_FALSE(switches::IsTouchDragDropEnabled());
1885 textfield_->OnGestureEvent(&tap_down);
1886 textfield_->OnGestureEvent(&long_press);
1908 EXPECT_STR_EQ("hello", textfield_->GetSelectedText()); 1887 EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
1909 EXPECT_TRUE(GetTouchSelectionController()); 1888 EXPECT_TRUE(GetTouchSelectionController());
1910 EXPECT_TRUE(long_press.handled()); 1889 EXPECT_TRUE(long_press.handled());
1911
1912 // After enabling touch drag drop, long pressing in the selected region should
1913 // start a drag and remove TouchSelectionController.
1914 CommandLine::ForCurrentProcess()->AppendSwitch(
1915 switches::kEnableTouchDragDrop);
1916 textfield_view_->OnGestureEvent(&tap_down);
1917
1918 // Create a new long press event since the previous one is not marked handled.
1919 GestureEventForTest long_press2(ui::ET_GESTURE_LONG_PRESS, eventX, eventY,
1920 0.0f, 0.0f);
1921 textfield_view_->OnGestureEvent(&long_press2);
1922 EXPECT_STR_EQ("hello", textfield_->GetSelectedText());
1923 EXPECT_FALSE(GetTouchSelectionController());
1924 } 1890 }
1925 1891
1926 TEST_F(NativeTextfieldViewsTest, TouchScrubbingSelection) { 1892 TEST_F(TextfieldTest, TouchScrubbingSelection) {
1927 InitTextfield(Textfield::STYLE_DEFAULT); 1893 InitTextfield(Textfield::STYLE_DEFAULT);
1928 textfield_->SetText(ASCIIToUTF16("hello world")); 1894 textfield_->SetText(ASCIIToUTF16("hello world"));
1929 EXPECT_FALSE(GetTouchSelectionController()); 1895 EXPECT_FALSE(GetTouchSelectionController());
1930 1896
1931 CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableTouchEditing); 1897 CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableTouchEditing);
1932 1898
1933 // Simulate touch-scrubbing. 1899 // Simulate touch-scrubbing.
1934 int scrubbing_start = GetCursorPositionX(1); 1900 int scrubbing_start = GetCursorPositionX(1);
1935 int scrubbing_end = GetCursorPositionX(6); 1901 int scrubbing_end = GetCursorPositionX(6);
1936 1902
1937 GestureEventForTest tap_down(ui::ET_GESTURE_TAP_DOWN, scrubbing_start, 0, 1903 GestureEventForTest tap_down(ui::ET_GESTURE_TAP_DOWN, scrubbing_start, 0,
1938 0.0f, 0.0f); 1904 0.0f, 0.0f);
1939 textfield_view_->OnGestureEvent(&tap_down); 1905 textfield_->OnGestureEvent(&tap_down);
1940 1906
1941 GestureEventForTest tap_cancel(ui::ET_GESTURE_TAP_CANCEL, scrubbing_start, 0, 1907 GestureEventForTest tap_cancel(ui::ET_GESTURE_TAP_CANCEL, scrubbing_start, 0,
1942 0.0f, 0.0f); 1908 0.0f, 0.0f);
1943 textfield_view_->OnGestureEvent(&tap_cancel); 1909 textfield_->OnGestureEvent(&tap_cancel);
1944 1910
1945 GestureEventForTest scroll_begin(ui::ET_GESTURE_SCROLL_BEGIN, scrubbing_start, 1911 GestureEventForTest scroll_begin(ui::ET_GESTURE_SCROLL_BEGIN, scrubbing_start,
1946 0, 0.0f, 0.0f); 1912 0, 0.0f, 0.0f);
1947 textfield_view_->OnGestureEvent(&scroll_begin); 1913 textfield_->OnGestureEvent(&scroll_begin);
1948 1914
1949 GestureEventForTest scroll_update(ui::ET_GESTURE_SCROLL_UPDATE, scrubbing_end, 1915 GestureEventForTest scroll_update(ui::ET_GESTURE_SCROLL_UPDATE, scrubbing_end,
1950 0, scrubbing_end - scrubbing_start, 0.0f); 1916 0, scrubbing_end - scrubbing_start, 0.0f);
1951 textfield_view_->OnGestureEvent(&scroll_update); 1917 textfield_->OnGestureEvent(&scroll_update);
1952 1918
1953 GestureEventForTest scroll_end(ui::ET_GESTURE_SCROLL_END, scrubbing_end, 0, 1919 GestureEventForTest scroll_end(ui::ET_GESTURE_SCROLL_END, scrubbing_end, 0,
1954 0.0f, 0.0f); 1920 0.0f, 0.0f);
1955 textfield_view_->OnGestureEvent(&scroll_end); 1921 textfield_->OnGestureEvent(&scroll_end);
1956 1922
1957 GestureEventForTest end(ui::ET_GESTURE_END, scrubbing_end, 0, 0.0f, 0.0f); 1923 GestureEventForTest end(ui::ET_GESTURE_END, scrubbing_end, 0, 0.0f, 0.0f);
1958 textfield_view_->OnGestureEvent(&end); 1924 textfield_->OnGestureEvent(&end);
1959 1925
1960 // In the end, part of text should have been selected and handles should have 1926 // In the end, part of text should have been selected and handles should have
1961 // appeared. 1927 // appeared.
1962 EXPECT_STR_EQ("ello ", textfield_->GetSelectedText()); 1928 EXPECT_STR_EQ("ello ", textfield_->GetSelectedText());
1963 EXPECT_TRUE(GetTouchSelectionController()); 1929 EXPECT_TRUE(GetTouchSelectionController());
1964 } 1930 }
1965 #endif 1931 #endif
1966 1932
1967 // Long_Press gesture in NativeTextfieldViews can initiate a drag and drop now. 1933 // Long_Press gesture in Textfield can initiate a drag and drop now.
1968 TEST_F(NativeTextfieldViewsTest, TestLongPressInitiatesDragDrop) { 1934 TEST_F(TextfieldTest, TestLongPressInitiatesDragDrop) {
1969 InitTextfield(Textfield::STYLE_DEFAULT); 1935 InitTextfield(Textfield::STYLE_DEFAULT);
1970 textfield_->SetText(ASCIIToUTF16("Hello string world")); 1936 textfield_->SetText(ASCIIToUTF16("Hello string world"));
1971 1937
1972 // Ensure the textfield will provide selected text for drag data. 1938 // Ensure the textfield will provide selected text for drag data.
1973 textfield_->SelectRange(gfx::Range(6, 12)); 1939 textfield_->SelectRange(gfx::Range(6, 12));
1974 const gfx::Point kStringPoint(GetCursorPositionX(9), 0); 1940 const gfx::Point kStringPoint(GetCursorPositionX(9), 0);
1975 1941
1976 // Enable touch-drag-drop to make long press effective. 1942 // Enable touch-drag-drop to make long press effective.
1977 CommandLine::ForCurrentProcess()->AppendSwitch( 1943 CommandLine::ForCurrentProcess()->AppendSwitch(
1978 switches::kEnableTouchDragDrop); 1944 switches::kEnableTouchDragDrop);
1979 1945
1980 // Create a long press event in the selected region should start a drag. 1946 // Create a long press event in the selected region should start a drag.
1981 GestureEventForTest long_press(ui::ET_GESTURE_LONG_PRESS, kStringPoint.x(), 1947 GestureEventForTest long_press(ui::ET_GESTURE_LONG_PRESS, kStringPoint.x(),
1982 kStringPoint.y(), 0.0f, 0.0f); 1948 kStringPoint.y(), 0.0f, 0.0f);
1983 textfield_view_->OnGestureEvent(&long_press); 1949 textfield_->OnGestureEvent(&long_press);
1984 EXPECT_TRUE(textfield_view_->CanStartDragForView(NULL, 1950 EXPECT_TRUE(textfield_->CanStartDragForView(NULL, kStringPoint,
1985 kStringPoint, kStringPoint)); 1951 kStringPoint));
1986 } 1952 }
1987 1953
1988 TEST_F(NativeTextfieldViewsTest, GetTextfieldBaseline_FontFallbackTest) { 1954 TEST_F(TextfieldTest, GetTextfieldBaseline_FontFallbackTest) {
1989 InitTextfield(Textfield::STYLE_DEFAULT); 1955 InitTextfield(Textfield::STYLE_DEFAULT);
1990 textfield_->SetText(UTF8ToUTF16("abc")); 1956 textfield_->SetText(UTF8ToUTF16("abc"));
1991 const int old_baseline = textfield_->GetBaseline(); 1957 const int old_baseline = textfield_->GetBaseline();
1992 1958
1993 // Set text which may fall back to a font which has taller baseline than 1959 // Set text which may fall back to a font which has taller baseline than
1994 // the default font. 1960 // the default font.
1995 textfield_->SetText(UTF8ToUTF16("\xE0\xB9\x91")); 1961 textfield_->SetText(UTF8ToUTF16("\xE0\xB9\x91"));
1996 const int new_baseline = textfield_->GetBaseline(); 1962 const int new_baseline = textfield_->GetBaseline();
1997 1963
1998 // Regardless of the text, the baseline must be the same. 1964 // Regardless of the text, the baseline must be the same.
1999 EXPECT_EQ(new_baseline, old_baseline); 1965 EXPECT_EQ(new_baseline, old_baseline);
2000 } 1966 }
2001 1967
2002 } // namespace views 1968 } // namespace views
OLDNEW
« no previous file with comments | « ui/views/controls/textfield/textfield_controller.cc ('k') | ui/views/controls/textfield/textfield_views_model.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698