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/bookmarks/test_bookmark_client.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_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, false)) {
-  }
+  BookmarkIndexTest() : model_(client_.CreateModel(false)) {}
 
   typedef std::pair<std::string, std::string> TitleAndURL;
 
   void AddBookmarks(const char** titles, const char** urls, size_t count) {
     // The pair is (title, url).
     std::vector<TitleAndURL> bookmarks;
     for (size_t i = 0; i < count; ++i) {
       TitleAndURL bookmark(titles[i], urls[i]);
       bookmarks.push_back(bookmark);
     }
@@ skipping 56 matching lines @@
       const BookmarkMatch::MatchPositions& actual_positions,
       const BookmarkMatch::MatchPositions& expected_positions) {
     ASSERT_EQ(expected_positions.size(), actual_positions.size());
     for (size_t i = 0; i < expected_positions.size(); ++i) {
       EXPECT_EQ(expected_positions[i].first, actual_positions[i].first);
       EXPECT_EQ(expected_positions[i].second, actual_positions[i].second);
     }
   }
 
  protected:
+  test::TestBookmarkClient client_;
   scoped_ptr<BookmarkModel> model_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BookmarkIndexTest);
 };
 
 // Various permutations with differing input, queries and output that exercises
 // all query paths.
 TEST_F(BookmarkIndexTest, GetBookmarksMatching) {
   struct TestData {
@@ skipping 36 matching lines @@
       bookmarks.push_back(bookmark);
     }
     AddBookmarks(bookmarks);
 
     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, false));
+    model_ = client_.CreateModel(false);
   }
 }
 
 // Analogous to GetBookmarksMatching, this test tests various permutations
 // of title, URL, and input to see if the title/URL matches the input as
 // expected.
 TEST_F(BookmarkIndexTest, GetBookmarksMatchingWithURLs) {
   struct TestData {
     const std::string query;
     const std::string title;
@@ skipping 28 matching lines @@
     { "foo bar", "Baz Barly",    "http://blah.com/foodie",      true  },
     { "foo bar", "Baz Bur",      "http://blah.com/foo/bar",     true  },
     { "foo bar", "Baz Bur",      "http://blah.com/food/barly",  true  },
     { "foo bar", "Baz Bur",      "http://bar.com/blah/foo",     true  },
     { "foo bar", "Baz Bur",      "http://barly.com/blah/food",  true  },
     { "foo bar", "Baz Bur",      "http://bar.com/blah/flub",    false },
     { "foo bar", "Baz Bur",      "http://foo.com/blah/flub",    false }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
-    model_.reset(new BookmarkModel(NULL, true));
+    model_ = client_.CreateModel(true);
     std::vector<TitleAndURL> bookmarks;
     bookmarks.push_back(TitleAndURL(data[i].title, data[i].url));
     AddBookmarks(bookmarks);
 
     std::vector<std::string> expected;
     if (data[i].should_be_retrieved)
       expected.push_back(data[i].title);
 
     ExpectMatches(data[i].query, expected);
   }
@@ skipping 18 matching lines @@
   };
 
   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<BookmarkMatch> matches;
     model_->GetBookmarksMatching(
         base::UTF8ToUTF16(data[i].query), 10, &matches);
     EXPECT_EQ(1u, matches.size());
-    model_.reset(new BookmarkModel(NULL, false));
+    model_ = client_.CreateModel(false);
   }
 }
 
 // Makes sure match positions are updated appropriately for title matches.
 TEST_F(BookmarkIndexTest, MatchPositionsTitles) {
   struct TestData {
     const std::string title;
     const std::string query;
     const std::string expected_title_match_positions;
   } data[] = {
@@ skipping 16 matching lines @@
     std::vector<BookmarkMatch> matches;
     model_->GetBookmarksMatching(ASCIIToUTF16(data[i].query), 1000, &matches);
     ASSERT_EQ(1U, matches.size());
 
     BookmarkMatch::MatchPositions expected_title_matches;
     ExtractMatchPositions(data[i].expected_title_match_positions,
                           &expected_title_matches);
     ExpectMatchPositions(matches[0].title_match_positions,
                          expected_title_matches);
 
-    model_.reset(new BookmarkModel(NULL, false));
+    model_ = client_.CreateModel(false);
   }
 }
 
 // Makes sure match positions are updated appropriately for URL matches.
 TEST_F(BookmarkIndexTest, MatchPositionsURLs) {
   struct TestData {
     const std::string query;
     const std::string url;
     const std::string expected_url_match_positions;
   } data[] = {
     { "foo",      "http://www.foo.com/",    "11,14" },
     { "foo",      "http://www.foodie.com/", "11,14" },
     { "foo",      "http://www.foofoo.com/", "11,14" },
     { "www",      "http://www.foo.com/",    "7,10"  },
     { "foo",      "http://www.foodie.com/blah/foo/fi", "11,14:27,30"      },
     { "foo",      "http://www.blah.com/blah/foo/fi",   "25,28"            },
     { "foo www",  "http://www.foodie.com/blah/foo/fi", "7,10:11,14:27,30" },
     { "www foo",  "http://www.foodie.com/blah/foo/fi", "7,10:11,14:27,30" },
     { "www bla",  "http://www.foodie.com/blah/foo/fi", "7,10:22,25"       },
     { "http",     "http://www.foo.com/",               "0,4"              },
     { "http www", "http://www.foo.com/",               "0,4:7,10"         },
     { "http foo", "http://www.foo.com/",               "0,4:11,14"        },
     { "http foo", "http://www.bar.com/baz/foodie/hi",  "0,4:23,26"        }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
-    model_.reset(new BookmarkModel(NULL, true));
+    model_ = client_.CreateModel(true);
     std::vector<TitleAndURL> bookmarks;
     TitleAndURL bookmark("123456", data[i].url);
     bookmarks.push_back(bookmark);
     AddBookmarks(bookmarks);
 
     std::vector<BookmarkMatch> matches;
     model_->GetBookmarksMatching(ASCIIToUTF16(data[i].query), 1000, &matches);
     ASSERT_EQ(1U, matches.size()) << data[i].url << data[i].query;
 
     BookmarkMatch::MatchPositions expected_url_matches;
@@ skipping 124 matching lines @@
   EXPECT_EQ(data[1].url, matches[3].node->url());
 
   matches.clear();
   // Select top two matches.
   model->GetBookmarksMatching(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());
 }