bookmarks: Componentize bookmark_model_unittest.cc.

components/bookmarks/core/browser/bookmark_model_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 "components/bookmarks/core/browser/bookmark_model.h"
 
 #include <set>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/path_service.h"
 #include "base/strings/string16.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 "base/time/time.h"
-#include "chrome/browser/bookmarks/bookmark_model_factory.h"
-#include "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/core/browser/bookmark_model_observer.h"
 #include "components/bookmarks/core/browser/bookmark_utils.h"
 #include "components/bookmarks/core/test/bookmark_test_helpers.h"
 #include "components/bookmarks/core/test/test_bookmark_client.h"
-#include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/models/tree_node_iterator.h"
 #include "ui/base/models/tree_node_model.h"
 #include "url/gurl.h"
 
 using base::ASCIIToUTF16;
 using base::Time;
 using base::TimeDelta;
 
 namespace {
@@ skipping 853 matching lines @@
     } else {
       model->AddURL(bb_node, i, child->GetTitle(),
           GURL("http://" + base::UTF16ToASCII(child->GetTitle())));
     }
   }
 }
 
 // Test class that creates a BookmarkModel with a real history backend.
 class BookmarkModelTestWithProfile : public testing::Test {
  public:
-  BookmarkModelTestWithProfile()
-      : bb_model_(NULL) {}
-
-  // testing::Test:
-  virtual void TearDown() OVERRIDE {
-    profile_.reset(NULL);
-  }
+  BookmarkModelTestWithProfile() {}
 
  protected:
   // Verifies the contents of the bookmark bar node match the contents of the
   // TestNode.
   void VerifyModelMatchesNode(TestNode* expected, const BookmarkNode* actual) {
     ASSERT_EQ(expected->child_count(), actual->child_count());
     for (int i = 0; i < expected->child_count(); ++i) {
       TestNode* expected_child = expected->GetChild(i);
       const BookmarkNode* actual_child = actual->GetChild(i);
       ASSERT_EQ(expected_child->GetTitle(), actual_child->GetTitle());
@@ skipping 10 matching lines @@
     }
   }
 
   void VerifyNoDuplicateIDs(BookmarkModel* model) {
     ui::TreeNodeIterator<const BookmarkNode> it(model->root_node());
     base::hash_set<int64> ids;
     while (it.has_next())
       ASSERT_TRUE(ids.insert(it.Next()->id()).second);
   }
 
-  void BlockTillBookmarkModelLoaded() {
-    bb_model_ = BookmarkModelFactory::GetForProfile(profile_.get());
-    test::WaitForBookmarkModelToLoad(bb_model_);
-  }
-
-  // The profile.
-  scoped_ptr<TestingProfile> profile_;
-  BookmarkModel* bb_model_;
-
- private:
-  content::TestBrowserThreadBundle thread_bundle_;
+  test::TestBookmarkClient client_;
+  scoped_ptr<BookmarkModel> model_;
 };
 
 // Creates a set of nodes in the bookmark bar model, then recreates the
 // bookmark bar model which triggers loading from the db and checks the loaded
 // structure to make sure it is what we first created.
 TEST_F(BookmarkModelTestWithProfile, CreateAndRestore) {
   struct TestData {
     // Structure of the children of the bookmark bar model node.
     const std::string bbn_contents;
     // Structure of the children of the other node.
     const std::string other_contents;
     // Structure of the children of the synced node.
     const std::string mobile_contents;
   } data[] = {
     // See PopulateNodeFromString for a description of these strings.
     { "", "" },
     { "a", "b" },
     { "a [ b ]", "" },
     { "", "[ b ] a [ c [ d e [ f ] ] ]" },
     { "a [ b ]", "" },
     { "a b c [ d e [ f ] ]", "g h i [ j k [ l ] ]"},
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
-    // Recreate the profile. We need to reset with NULL first so that the last
-    // HistoryService releases the locks on the files it creates and we can
-    // delete them.
-    profile_.reset(NULL);
-    profile_.reset(new TestingProfile());
-    profile_->CreateBookmarkModel(true);
-    ASSERT_TRUE(profile_->CreateHistoryService(true, false));
-    BlockTillBookmarkModelLoaded();
+    model_ = client_.CreateModel(false);
 
     TestNode bbn;
     PopulateNodeFromString(data[i].bbn_contents, &bbn);
-    PopulateBookmarkNode(&bbn, bb_model_, bb_model_->bookmark_bar_node());
+    PopulateBookmarkNode(&bbn, model_.get(), model_->bookmark_bar_node());
 
     TestNode other;
     PopulateNodeFromString(data[i].other_contents, &other);
-    PopulateBookmarkNode(&other, bb_model_, bb_model_->other_node());
+    PopulateBookmarkNode(&other, model_.get(), model_->other_node());
 
     TestNode mobile;
     PopulateNodeFromString(data[i].mobile_contents, &mobile);
-    PopulateBookmarkNode(&mobile, bb_model_, bb_model_->mobile_node());
+    PopulateBookmarkNode(&mobile, model_.get(), model_->mobile_node());
 
-    profile_->CreateBookmarkModel(false);
-    BlockTillBookmarkModelLoaded();
-
-    VerifyModelMatchesNode(&bbn, bb_model_->bookmark_bar_node());
-    VerifyModelMatchesNode(&other, bb_model_->other_node());
-    VerifyModelMatchesNode(&mobile, bb_model_->mobile_node());
-    VerifyNoDuplicateIDs(bb_model_);
+    VerifyModelMatchesNode(&bbn, model_->bookmark_bar_node());
+    VerifyModelMatchesNode(&other, model_->other_node());
+    VerifyModelMatchesNode(&mobile, model_->mobile_node());
+    VerifyNoDuplicateIDs(model_.get());
   }
 }
 
 TEST_F(BookmarkModelTest, Sort) {
   // Populate the bookmark bar node with nodes for 'B', 'a', 'd' and 'C'.
   // 'C' and 'a' are folders.
   TestNode bbn;
   PopulateNodeFromString("B [ a ] d [ a ]", &bbn);
   const BookmarkNode* parent = model_->bookmark_bar_node();
   PopulateBookmarkNode(&bbn, model_.get(), parent);
@@ skipping 140 matching lines @@
   EXPECT_TRUE(node.DeleteMetaInfo("key2.subkey2.leaf"));
   EXPECT_FALSE(node.DeleteMetaInfo("key3"));
   EXPECT_FALSE(node.GetMetaInfo("key1", &out_value));
   EXPECT_FALSE(node.GetMetaInfo("key2.subkey1", &out_value));
   EXPECT_FALSE(node.GetMetaInfo("key2.subkey2", &out_value));
   EXPECT_FALSE(node.GetMetaInfo("key2.subkey2.leaf", &out_value));
   EXPECT_FALSE(node.GetMetaInfoMap());
 }
 
 }  // namespace