Do not allow multiline input when naming bookmarks/folders on Mac

chrome/browser/bookmarks/bookmark_model_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <set>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 23 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/models/tree_node_iterator.h"
 #include "ui/base/models/tree_node_model.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 
 namespace {
 
+// Test cases used to test the removal of extra whitespace when adding
+// a new folder/bookmark or updating a title of a folder/bookmark.
+struct {
+  const std::string input_title;
+  const std::string expected_title;
+} test_cases[] = {
+  {"foobar", "foobar"},
+  // Newlines.
+  {"foo\nbar", "foo bar"},
+  {"foo\n\nbar", "foo bar"},
+  {"foo\n\n\nbar", "foo bar"},
+  {"foo\r\nbar", "foo bar"},
+  {"foo\r\n\r\nbar", "foo bar"},
+  {"\nfoo\nbar\n", "foo bar"},
+  // Spaces.
+  {"foo  bar", "foo bar"},
+  {" foo bar ", "foo bar"},
+  {"  foo  bar  ", "foo bar"},
+  // Tabs.
+  {"\tfoo\tbar\t", "foo bar"},
+  {"\tfoo bar\t", "foo bar"},
+  // Mixed cases.
+  {"\tfoo\nbar\t", "foo bar"},
+  {"\tfoo\r\nbar\t", "foo bar"},
+  {"  foo\tbar\n", "foo bar"},
+  {"\t foo \t  bar  \t", "foo bar"},
+  {"\n foo\r\n\tbar\n \t", "foo bar"},
+};

[Ilya Sherman, 2011/11/22 21:00:35]

nit: Since you're declaring this outside of the test functions, please rename
this to something more specific, e.g. |whitespace_test_cases|

+
 // Helper to get a mutable bookmark node.
 BookmarkNode* AsMutable(const BookmarkNode* node) {
   return const_cast<BookmarkNode*>(node);
 }
 
 void SwapDateAdded(BookmarkNode* n1, BookmarkNode* n2) {
   Time tmp = n1->date_added();
   n1->set_date_added(n2->date_added());
   n2->set_date_added(tmp);
 }
@@ skipping 151 matching lines @@
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->url());
   ASSERT_EQ(BookmarkNode::URL, new_node->type());
   ASSERT_TRUE(new_node == model_.GetMostRecentlyAddedNodeForURL(url));
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model_.other_node()->id() &&
               new_node->id() != model_.synced_node()->id());
 }
 
+TEST_F(BookmarkModelTest, AddURLWithWhitespaceTitle) {
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+    const BookmarkNode* root = model_.bookmark_bar_node();
+    const string16 title(ASCIIToUTF16(test_cases[i].input_title));
+    const GURL url("http://foo.com");
+
+    const BookmarkNode* new_node = model_.AddURL(root, i, title, url);
+
+    int size = i + 1;
+    EXPECT_EQ(size, root->child_count());
+    EXPECT_EQ(ASCIIToUTF16(test_cases[i].expected_title), new_node->GetTitle());
+    EXPECT_EQ(BookmarkNode::URL, new_node->type());
+  }
+}
+
 TEST_F(BookmarkModelTest, AddURLToSyncedBookmarks) {
   const BookmarkNode* root = model_.synced_node();
   const string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
   const BookmarkNode* new_node = model_.AddURL(root, 0, title, url);
   AssertObserverCount(1, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
@@ skipping 23 matching lines @@
               new_node->id() != model_.other_node()->id() &&
               new_node->id() != model_.synced_node()->id());
 
   // Add another folder, just to make sure folder_ids are incremented correctly.
   ClearCounts();
   model_.AddFolder(root, 0, title);
   AssertObserverCount(1, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 }
 
+TEST_F(BookmarkModelTest, AddFolderWithWhitespaceTitle) {
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+    const BookmarkNode* root = model_.bookmark_bar_node();
+    const string16 title(ASCIIToUTF16(test_cases[i].input_title));
+
+    const BookmarkNode* new_node = model_.AddFolder(root, i, title);
+
+    int size = i + 1;
+    EXPECT_EQ(size, root->child_count());
+    EXPECT_EQ(ASCIIToUTF16(test_cases[i].expected_title), new_node->GetTitle());
+    EXPECT_EQ(BookmarkNode::FOLDER, new_node->type());
+  }
+}
+
 TEST_F(BookmarkModelTest, RemoveURL) {
   const BookmarkNode* root = model_.bookmark_bar_node();
   const string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
   model_.AddURL(root, 0, title, url);
   ClearCounts();
 
   model_.Remove(root, 0);
   ASSERT_EQ(0, root->child_count());
   AssertObserverCount(0, 0, 1, 0, 0);
@@ skipping 34 matching lines @@
 
   ClearCounts();
 
   title = ASCIIToUTF16("foo2");
   model_.SetTitle(node, title);
   AssertObserverCount(0, 0, 0, 1, 0);
   observer_details_.ExpectEquals(node, NULL, -1, -1);
   EXPECT_EQ(title, node->GetTitle());
 }
 
+TEST_F(BookmarkModelTest, SetTitleWithWhitespace) {
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+    const BookmarkNode* root = model_.bookmark_bar_node();
+    string16 title(ASCIIToUTF16("dummy"));
+    const GURL url("http://foo.com");
+    const BookmarkNode* node = model_.AddURL(root, 0, title, url);
+
+    title = ASCIIToUTF16(test_cases[i].input_title);
+    model_.SetTitle(node, title);
+    EXPECT_EQ(ASCIIToUTF16(test_cases[i].expected_title), node->GetTitle());
+  }
+}
+
 TEST_F(BookmarkModelTest, SetURL) {
   const BookmarkNode* root = model_.bookmark_bar_node();
   const string16 title(ASCIIToUTF16("foo"));
   GURL url("http://foo.com");
   const BookmarkNode* node = model_.AddURL(root, 0, title, url);
 
   ClearCounts();
 
   url = GURL("http://foo2.com");
   model_.SetURL(node, url);
@@ skipping 708 matching lines @@
 TEST_F(BookmarkModelTest, SyncNodeVisibileWithChildren) {
   const BookmarkNode* root = model_.synced_node();
   const string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
   model_.AddURL(root, 0, title, url);
   EXPECT_TRUE(model_.synced_node()->IsVisible());
 }
 
 }  // namespace