Change ownership of BookmarkClient

components/bookmarks/browser/bookmark_index_unittest.cc

 // Copyright 2014 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 "components/bookmarks/browser/bookmark_index.h"
 
 #include <string>
 #include <vector>
 
 #include "base/macros.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 "components/bookmarks/browser/bookmark_match.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/bookmarks/test/test_bookmark_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 
 namespace bookmarks {
 namespace {
 
 const char kAboutBlankURL[] = "about:blank";
 
-class BookmarkClientMock : public TestBookmarkClient {
+class BookmarkClientMock : public BookmarkClient {
  public:
   BookmarkClientMock(const std::map<GURL, int>& typed_count_map)
       : typed_count_map_(typed_count_map) {}
 
+  void Init(BookmarkModel* bookmark_model) override {}
+
+  base::CancelableTaskTracker::TaskId GetFaviconImageForPageURL(
+      const GURL& page_url,
+      favicon_base::IconType type,
+      const favicon_base::FaviconImageCallback& callback,
+      base::CancelableTaskTracker* tracker) override {
+    return base::CancelableTaskTracker::kBadTaskId;
+  }
+
   bool SupportsTypedCountForNodes() override { return true; }
 
   void GetTypedCountForNodes(
       const NodeSet& nodes,
       NodeTypedCountPairs* node_typed_count_pairs) override {
     for (NodeSet::const_iterator it = nodes.begin(); it != nodes.end(); ++it) {
       const BookmarkNode* node = *it;
       std::map<GURL, int>::const_iterator found =
           typed_count_map_.find(node->url());
       if (found == typed_count_map_.end())
         continue;
 
       node_typed_count_pairs->push_back(std::make_pair(node, found->second));
     }
   }
 
+  void RecordAction(const base::UserMetricsAction& action) override {}
+
+  LoadExtraCallback GetLoadExtraNodesCallback(
+      scoped_ptr<BookmarkPermanentNode> managed_node,
+      scoped_ptr<BookmarkPermanentNode> supervised_node,
+      const ExtraNodeLoadedCallback& callback) override {
+    return LoadExtraCallback();
+  }
+
+  void DoneLoading(BookmarkPermanentNode* managed_node,
+                   BookmarkPermanentNode* supervised_node) override {}
+
  private:
   const std::map<GURL, int> typed_count_map_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkClientMock);
 };
+}  // namespace
 
 class BookmarkIndexTest : public testing::Test {
  public:
-  BookmarkIndexTest() : model_(client_.CreateModel()) {}
+  BookmarkIndexTest() : model_(TestBookmarkClient::CreateModel()) {}
 
   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 58 matching lines @@
   void ExpectMatchPositions(
       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);
     }
   }
 
+  scoped_ptr<BookmarkModel> CreateModelWithMockClient(
+      const std::map<GURL, int>& typed_count_map) {
+    scoped_ptr<BookmarkModel> model(new BookmarkModel(
+        make_scoped_ptr(new BookmarkClientMock(typed_count_map))));
+    scoped_ptr<BookmarkLoadDetails> details =
+        model->CreateLoadDetails(std::string());
+    details->LoadExtraNodes();
+    model->DoneLoading(details.Pass());
+    return model.Pass();
+  }
+
  protected:
-  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 52 matching lines @@
     }
     AddBookmarks(bookmarks);
 
     std::vector<std::string> expected;
     if (!data[i].expected.empty())
       base::SplitString(data[i].expected, ';', &expected);
 
     ExpectMatches(data[i].query, query_parser::MatchingAlgorithm::DEFAULT,
                   expected);
 
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
   }
 }
 
 TEST_F(BookmarkIndexTest, GetBookmarksMatchingAlwaysPrefixSearch) {
   struct TestData {
     const std::string titles;
     const std::string query;
     const std::string expected;
   } data[] = {
     // Trivial test case of only one term, exact match.
@@ skipping 39 matching lines @@
     AddBookmarks(bookmarks);
 
     std::vector<std::string> expected;
     if (!data[i].expected.empty())
       base::SplitString(data[i].expected, ';', &expected);
 
     ExpectMatches(data[i].query,
                   query_parser::MatchingAlgorithm::ALWAYS_PREFIX_SEARCH,
                   expected);
 
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
   }
 }
 
 // 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(data); ++i) {
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
     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, query_parser::MatchingAlgorithm::DEFAULT,
                   expected);
@@ skipping 17 matching lines @@
     { "foo\xc3\xa4-test", "foo" },
     { "foo", "foo" }
   };
 
   GURL url(kAboutBlankURL);
   for (size_t i = 0; i < arraysize(data); ++i) {
     model_->AddURL(model_->other_node(), 0, UTF8ToUTF16(data[i].title), url);
     std::vector<BookmarkMatch> matches;
     model_->GetBookmarksMatching(UTF8ToUTF16(data[i].query), 10, &matches);
     EXPECT_EQ(1u, matches.size());
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
   }
 }
 
 // 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_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
   }
 }
 
 // Makes sure match positions are updated appropriately for URL matches.
 TEST_F(BookmarkIndexTest, MatchPositionsURLs) {
   // The encoded stuff between /wiki/ and the # is 第二次世界大戦
   const std::string ja_wiki_url = "http://ja.wikipedia.org/wiki/%E7%AC%AC%E4"
       "%BA%8C%E6%AC%A1%E4%B8%96%E7%95%8C%E5%A4%A7%E6%88%A6#.E3.83.B4.E3.82.A7"
       ".E3.83.AB.E3.82.B5.E3.82.A4.E3.83.A6.E4.BD.93.E5.88.B6";
   struct TestData {
@@ skipping 15 matching lines @@
     { "http foo",   "http://www.foo.com/",               "0,4:11,14"        },
     { "http foo",   "http://www.bar.com/baz/foodie/hi",  "0,4:23,26"        },
     { "第二次",      ja_wiki_url,                         "29,56"            },
     { "ja 第二次",   ja_wiki_url,                         "7,9:29,56"        },
     { "第二次 E3.8", ja_wiki_url,                         "29,56:94,98:103,107:"
                                                          "112,116:121,125:"
                                                          "130,134:139,143"  }
   };
 
   for (size_t i = 0; i < arraysize(data); ++i) {
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
     std::vector<TitleAndURL> bookmarks;
     TitleAndURL bookmark("123456", data[i].url);
     bookmarks.push_back(bookmark);
     AddBookmarks(bookmarks);
 
     std::vector<BookmarkMatch> matches;
     model_->GetBookmarksMatching(UTF8ToUTF16(data[i].query), 1000, &matches);
     ASSERT_EQ(1U, matches.size()) << data[i].url << data[i].query;
 
     BookmarkMatch::MatchPositions expected_url_matches;
@@ skipping 72 matching lines @@
     { GURL("http://www.google.com/"),      "Google",           100 },
     { GURL("http://maps.google.com/"),     "Google Maps",       40 },
     { GURL("http://docs.google.com/"),     "Google Docs",       50 },
     { GURL("http://reader.google.com/"),   "Google Reader",     80 },
   };
 
   std::map<GURL, int> typed_count_map;
   for (size_t i = 0; i < arraysize(data); ++i)
     typed_count_map.insert(std::make_pair(data[i].url, data[i].typed_count));
 
-  BookmarkClientMock client(typed_count_map);
-  scoped_ptr<BookmarkModel> model = client.CreateModel();
+  scoped_ptr<BookmarkModel> model(CreateModelWithMockClient(typed_count_map));
 
   for (size_t i = 0; i < arraysize(data); ++i)
     // Populate the BookmarkIndex.
     model->AddURL(
         model->other_node(), i, UTF8ToUTF16(data[i].title), data[i].url);
 
   // Populate match nodes.
   std::vector<BookmarkMatch> matches;
   model->GetBookmarksMatching(ASCIIToUTF16("google"), 4, &matches);
 
@@ skipping 10 matching lines @@
 
   matches.clear();
   // Select top two matches.
   model->GetBookmarksMatching(ASCIIToUTF16("google"), 2, &matches);
 
   ASSERT_EQ(2U, matches.size());
   EXPECT_EQ(data[0].url, matches[0].node->url());
   EXPECT_EQ(data[3].url, matches[1].node->url());
 }
 
-}  // namespace
 }  // namespace bookmarks