Introduce BookmarkClient interface to abstract embedder

chrome/browser/bookmarks/bookmark_index_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_index.h"
 
 #include <string>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_test_helpers.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/url_database.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/bookmarks/core/browser/bookmark_client.h"
 #include "components/bookmarks/core/browser/bookmark_title_match.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 
 class BookmarkIndexTest : public testing::Test {
  public:
-  BookmarkIndexTest() : model_(new BookmarkModel(NULL)) {}
+  BookmarkIndexTest() { ResetBookmarkMarkModel(); }
 
   void AddBookmarksWithTitles(const char** titles, size_t count) {
     std::vector<std::string> title_vector;
     for (size_t i = 0; i < count; ++i)
       title_vector.push_back(titles[i]);
     AddBookmarksWithTitles(title_vector);
   }
 
   void AddBookmarksWithTitles(const std::vector<std::string>& titles) {
     GURL url("about:blank");
@@ skipping 54 matching lines @@
     ASSERT_EQ(1U, matches.size());
     const BookmarkTitleMatch& match = matches[0];
     ASSERT_EQ(expected_positions.size(), match.match_positions.size());
     for (size_t i = 0; i < expected_positions.size(); ++i) {
       EXPECT_EQ(expected_positions[i].first, match.match_positions[i].first);
       EXPECT_EQ(expected_positions[i].second, match.match_positions[i].second);
     }
   }
 
  protected:
+  test::TestBookmarkClient client_;
   scoped_ptr<BookmarkModel> model_;
 
+  void ResetBookmarkMarkModel() { model_.reset(client_.CreateModel()); }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BookmarkIndexTest);
 };
 
 // Various permutations with differing input, queries and output that exercises
 // all query paths.
 TEST_F(BookmarkIndexTest, Tests) {
   struct TestData {
     const std::string input;
     const std::string query;
@@ skipping 28 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     std::vector<std::string> titles;
     base::SplitString(data[i].input, ';', &titles);
     AddBookmarksWithTitles(titles);
 
     std::vector<std::string> expected;
     if (!data[i].expected.empty())
       base::SplitString(data[i].expected, ';', &expected);
 
     ExpectMatches(data[i].query, expected);
-
-    model_.reset(new BookmarkModel(NULL));
+    ResetBookmarkMarkModel();
   }
 }
 
 TEST_F(BookmarkIndexTest, TestNormalization) {
   struct TestData {
     const char* title;
     const char* query;
   } data[] = {
     { "fooa\xcc\x88-test", "foo\xc3\xa4-test" },
     { "fooa\xcc\x88-test", "fooa\xcc\x88-test" },
     { "fooa\xcc\x88-test", "foo\xc3\xa4" },
     { "fooa\xcc\x88-test", "fooa\xcc\x88" },
     { "fooa\xcc\x88-test", "foo" },
     { "foo\xc3\xa4-test", "foo\xc3\xa4-test" },
     { "foo\xc3\xa4-test", "fooa\xcc\x88-test" },
     { "foo\xc3\xa4-test", "foo\xc3\xa4" },
     { "foo\xc3\xa4-test", "fooa\xcc\x88" },
     { "foo\xc3\xa4-test", "foo" },
     { "foo", "foo" }
   };
 
   GURL url("about:blank");
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     model_->AddURL(model_->other_node(), 0, base::UTF8ToUTF16(data[i].title),
                    url);
     std::vector<BookmarkTitleMatch> matches;
     model_->GetBookmarksWithTitlesMatching(
         base::UTF8ToUTF16(data[i].query), 10, &matches);
     EXPECT_EQ(1u, matches.size());
-    model_.reset(new BookmarkModel(NULL));
+    ResetBookmarkMarkModel();
   }
 }
 
 // Makes sure match positions are updated appropriately.
 TEST_F(BookmarkIndexTest, MatchPositions) {
   struct TestData {
     const std::string title;
     const std::string query;
     const std::string expected;
   } data[] = {
     // Trivial test case of only one term, exact match.
     { "a",                        "A",        "0,1" },
     { "foo bar",                  "bar",      "4,7" },
     { "fooey bark",               "bar foo",  "0,3:6,9"},
     // Non-trivial tests.
     { "foobar foo",               "foobar foo",   "0,6:7,10" },
     { "foobar foo",               "foo foobar",   "0,6:7,10" },
     { "foobar foobar",            "foobar foo",   "0,6:7,13" },
     { "foobar foobar",            "foo foobar",   "0,6:7,13" },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     std::vector<std::string> titles;
     titles.push_back(data[i].title);
     AddBookmarksWithTitles(titles);
 
     BookmarkTitleMatch::MatchPositions expected_matches;
     ExtractMatchPositions(data[i].expected, &expected_matches);
     ExpectMatchPositions(data[i].query, expected_matches);
 
-    model_.reset(new BookmarkModel(NULL));
+    ResetBookmarkMarkModel();
   }
 }
 
 // Makes sure index is updated when a node is removed.
 TEST_F(BookmarkIndexTest, Remove) {
   const char* input[] = { "a", "b" };
   AddBookmarksWithTitles(input, ARRAYSIZE_UNSAFE(input));
 
   // Remove the node and make sure we don't get back any results.
   model_->Remove(model_->other_node(), 0);
@@ skipping 108 matching lines @@
   EXPECT_EQ(data[1].url, matches[3].node->url());
 
   matches.clear();
   // Select top two matches.
   model->GetBookmarksWithTitlesMatching(ASCIIToUTF16("google"), 2, &matches);
 
   EXPECT_EQ(2, static_cast<int>(matches.size()));
   EXPECT_EQ(data[0].url, matches[0].node->url());
   EXPECT_EQ(data[3].url, matches[1].node->url());
 }