Omnibox: Make URLs of Bookmarks Searchable

chrome/browser/bookmarks/bookmark_codec_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/bookmarks/bookmark_codec.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 55 matching lines @@
   ASSERT_NO_FATAL_FAILURE(
       AssertNodesEqual(expected->mobile_node(), actual->mobile_node()));
 }
 
 }  // namespace
 
 class BookmarkCodecTest : public testing::Test {
  protected:
   // Helpers to create bookmark models with different data.
   BookmarkModel* CreateTestModel1() {
-    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
+    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL, false));
     const BookmarkNode* bookmark_bar = model->bookmark_bar_node();
     model->AddURL(bookmark_bar, 0, ASCIIToUTF16(kUrl1Title), GURL(kUrl1Url));
     return model.release();
   }
   BookmarkModel* CreateTestModel2() {
-    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
+    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL, false));
     const BookmarkNode* bookmark_bar = model->bookmark_bar_node();
     model->AddURL(bookmark_bar, 0, ASCIIToUTF16(kUrl1Title), GURL(kUrl1Url));
     model->AddURL(bookmark_bar, 1, ASCIIToUTF16(kUrl2Title), GURL(kUrl2Url));
     return model.release();
   }
   BookmarkModel* CreateTestModel3() {
-    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
+    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL, false));
     const BookmarkNode* bookmark_bar = model->bookmark_bar_node();
     model->AddURL(bookmark_bar, 0, ASCIIToUTF16(kUrl1Title), GURL(kUrl1Url));
     const BookmarkNode* folder1 = model->AddFolder(bookmark_bar, 1,
                                                    ASCIIToUTF16(kFolder1Title));
     model->AddURL(folder1, 0, ASCIIToUTF16(kUrl2Title), GURL(kUrl2Url));
     return model.release();
   }
 
   void GetBookmarksBarChildValue(base::Value* value,
                                  size_t index,
@@ skipping 66 matching lines @@
 
   BookmarkModel* DecodeHelper(const base::Value& value,
                               const std::string& expected_stored_checksum,
                               std::string* computed_checksum,
                               bool expected_changes) {
     BookmarkCodec decoder;
     // Computed and stored checksums should be empty.
     EXPECT_EQ("", decoder.computed_checksum());
     EXPECT_EQ("", decoder.stored_checksum());
 
-    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
+    scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL, false));
     EXPECT_TRUE(Decode(&decoder, model.get(), value));
 
     *computed_checksum = decoder.computed_checksum();
     const std::string& stored_checksum = decoder.stored_checksum();
 
     // Computed and stored checksums should not be empty.
     EXPECT_FALSE(computed_checksum->empty());
     EXPECT_FALSE(stored_checksum.empty());
 
     // Stored checksum should be as expected.
@@ skipping 117 matching lines @@
                         GURL("http://newurl2.com"));
 
   ExpectIDsUnique(decoded_model.get());
 }
 
 TEST_F(BookmarkCodecTest, PersistIDsTest) {
   scoped_ptr<BookmarkModel> model_to_encode(CreateTestModel3());
   BookmarkCodec encoder;
   scoped_ptr<base::Value> model_value(encoder.Encode(model_to_encode.get()));
 
-  BookmarkModel decoded_model(NULL);
+  BookmarkModel decoded_model(NULL, false);
   BookmarkCodec decoder;
   ASSERT_TRUE(Decode(&decoder, &decoded_model, *model_value.get()));
   ASSERT_NO_FATAL_FAILURE(
       AssertModelsEqual(model_to_encode.get(), &decoded_model));
 
   // Add a couple of more items to the decoded bookmark model and make sure
   // ID persistence is working properly.
   const BookmarkNode* bookmark_bar = decoded_model.bookmark_bar_node();
   decoded_model.AddURL(
       bookmark_bar, bookmark_bar->child_count(), ASCIIToUTF16(kUrl3Title),
       GURL(kUrl3Url));
   const BookmarkNode* folder2_node = decoded_model.AddFolder(
       bookmark_bar, bookmark_bar->child_count(), ASCIIToUTF16(kFolder2Title));
   decoded_model.AddURL(folder2_node, 0, ASCIIToUTF16(kUrl4Title),
                        GURL(kUrl4Url));
 
   BookmarkCodec encoder2;
   scoped_ptr<base::Value> model_value2(encoder2.Encode(&decoded_model));
 
-  BookmarkModel decoded_model2(NULL);
+  BookmarkModel decoded_model2(NULL, false);
   BookmarkCodec decoder2;
   ASSERT_TRUE(Decode(&decoder2, &decoded_model2, *model_value2.get()));
   ASSERT_NO_FATAL_FAILURE(AssertModelsEqual(&decoded_model, &decoded_model2));
 }
 
 TEST_F(BookmarkCodecTest, CanDecodeModelWithoutMobileBookmarks) {
   base::FilePath test_data_directory;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory));
   base::FilePath test_file = test_data_directory.AppendASCII(
       "bookmarks/model_without_sync.json");
   ASSERT_TRUE(base::PathExists(test_file));
 
   JSONFileValueSerializer serializer(test_file);
   scoped_ptr<base::Value> root(serializer.Deserialize(NULL, NULL));
 
-  BookmarkModel decoded_model(NULL);
+  BookmarkModel decoded_model(NULL, false);
   BookmarkCodec decoder;
   ASSERT_TRUE(Decode(&decoder, &decoded_model, *root.get()));
   ExpectIDsUnique(&decoded_model);
 
   const BookmarkNode* bbn = decoded_model.bookmark_bar_node();
   ASSERT_EQ(1, bbn->child_count());
 
   const BookmarkNode* child = bbn->GetChild(0);
   EXPECT_EQ(BookmarkNode::FOLDER, child->type());
   EXPECT_EQ(ASCIIToUTF16("Folder A"), child->GetTitle());
@@ skipping 67 matching lines @@
 TEST_F(BookmarkCodecTest, CanDecodeMetaInfoAsString) {
   base::FilePath test_data_directory;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory));
   base::FilePath test_file = test_data_directory.AppendASCII(
       "bookmarks/meta_info_as_string.json");
   ASSERT_TRUE(base::PathExists(test_file));
 
   JSONFileValueSerializer serializer(test_file);
   scoped_ptr<base::Value> root(serializer.Deserialize(NULL, NULL));
 
-  BookmarkModel model(NULL);
+  BookmarkModel model(NULL, false);
   BookmarkCodec decoder;
   ASSERT_TRUE(Decode(&decoder, &model, *root.get()));
 
   EXPECT_EQ(1, model.root_node()->sync_transaction_version());
   const BookmarkNode* bbn = model.bookmark_bar_node();
   EXPECT_EQ(BookmarkNode::kInvalidSyncTransactionVersion,
             bbn->GetChild(0)->sync_transaction_version());
   EXPECT_EQ(42, bbn->GetChild(1)->sync_transaction_version());
 
   const char kSyncTransactionVersionKey[] = "sync.transaction_version";
   const char kNormalKey[] = "key";
   const char kNestedKey[] = "nested.key";
   std::string meta_value;
   EXPECT_FALSE(model.root_node()->GetMetaInfo(kSyncTransactionVersionKey,
                                                &meta_value));
   EXPECT_FALSE(bbn->GetChild(1)->GetMetaInfo(kSyncTransactionVersionKey,
                                              &meta_value));
   EXPECT_TRUE(bbn->GetChild(0)->GetMetaInfo(kNormalKey, &meta_value));
   EXPECT_EQ("value", meta_value);
   EXPECT_TRUE(bbn->GetChild(1)->GetMetaInfo(kNormalKey, &meta_value));
   EXPECT_EQ("value2", meta_value);
   EXPECT_TRUE(bbn->GetChild(0)->GetMetaInfo(kNestedKey, &meta_value));
   EXPECT_EQ("value3", meta_value);
 }