Change ownership of BookmarkClient

components/bookmarks/test/test_bookmark_client.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/test/test_bookmark_client.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_node.h"
 #include "components/bookmarks/browser/bookmark_storage.h"
 
 namespace bookmarks {
 
-TestBookmarkClient::TestBookmarkClient() {}
-
-TestBookmarkClient::~TestBookmarkClient() {}
-
-scoped_ptr<BookmarkModel> TestBookmarkClient::CreateModel() {
-  scoped_ptr<BookmarkModel> bookmark_model(new BookmarkModel(this));
-  scoped_ptr<BookmarkLoadDetails> details =
-      bookmark_model->CreateLoadDetails(std::string());
-  details->LoadExtraNodes();
-  bookmark_model->DoneLoading(details.Pass());
+// static
+scoped_ptr<BookmarkModel> TestBookmarkClient::CreateModel(
+    BookmarkPermanentNodeList extra_nodes,
+    TestBookmarkClient** client,
+    bool no_load) {
+  DCHECK(!client || !*client);
+  TestBookmarkClient* bookmark_client = new TestBookmarkClient;
+  bookmark_client->SetExtraNodesToLoad(extra_nodes.Pass());
+  scoped_ptr<BookmarkModel> bookmark_model(
+      new BookmarkModel(scoped_ptr<BookmarkClient>(bookmark_client)));
+  if (!no_load) {
+    scoped_ptr<BookmarkLoadDetails> details =
+        bookmark_model->CreateLoadDetails(std::string());
+    details->LoadExtraNodes();
+    bookmark_model->DoneLoading(details.Pass());
+  }
+  if (client)
+    *client = bookmark_client;
   return bookmark_model.Pass();
 }
 
-void TestBookmarkClient::SetExtraNodesToLoad(
-    BookmarkPermanentNodeList extra_nodes) {
-  extra_nodes_to_load_ = extra_nodes.Pass();
-  // Keep a copy in |extra_nodes_| for the accessor.
-  extra_nodes_ = extra_nodes_to_load_.get();
+scoped_ptr<BookmarkModel> TestBookmarkClient::CreateModel(
+    TestBookmarkClient** client) {
+  return CreateModel(BookmarkPermanentNodeList(), client, false);
+}
+
+scoped_ptr<BookmarkModel> TestBookmarkClient::CreateModel() {
+  return CreateModel(BookmarkPermanentNodeList(), nullptr, false);
 }
 
 bool TestBookmarkClient::IsExtraNodeRoot(const BookmarkNode* node) {
   for (size_t i = 0; i < extra_nodes_.size(); ++i) {
     if (node == extra_nodes_[i])
       return true;
   }
   return false;
 }
 
 bool TestBookmarkClient::IsAnExtraNode(const BookmarkNode* node) {
   if (!node)
     return false;
   for (size_t i = 0; i < extra_nodes_.size(); ++i) {
     if (node->HasAncestor(extra_nodes_[i]))
       return true;
   }
   return false;
 }
 
+TestBookmarkClient::TestBookmarkClient() {
+}
+
+TestBookmarkClient::~TestBookmarkClient() {
+}
+
+void TestBookmarkClient::SetExtraNodesToLoad(
+    BookmarkPermanentNodeList extra_nodes) {
+  extra_nodes_to_load_ = extra_nodes.Pass();
+  // Keep a copy in |extra_nodes_| for the accessor.
+  extra_nodes_ = extra_nodes_to_load_.get();
+}
+
+void TestBookmarkClient::Init(BookmarkModel* bookmark_model) {
+}
+
+base::CancelableTaskTracker::TaskId
+TestBookmarkClient::GetFaviconImageForPageURL(
+    const GURL& page_url,
+    favicon_base::IconType type,
+    const favicon_base::FaviconImageCallback& callback,
+    base::CancelableTaskTracker* tracker) {
+  return base::CancelableTaskTracker::kBadTaskId;
+}
+
+bool TestBookmarkClient::SupportsTypedCountForNodes() {
+  return false;
+}
+
+void TestBookmarkClient::GetTypedCountForNodes(
+    const NodeSet& nodes,
+    NodeTypedCountPairs* node_typed_count_pairs) {
+  NOTREACHED();
+}
+
 void TestBookmarkClient::RecordAction(const base::UserMetricsAction& action) {
 }
 
 LoadExtraCallback TestBookmarkClient::GetLoadExtraNodesCallback(
     scoped_ptr<BookmarkPermanentNode> managed_node,
     scoped_ptr<BookmarkPermanentNode> supervised_node,
     const ExtraNodeLoadedCallback& callback) {
   return base::Bind(&TestBookmarkClient::LoadExtraNodes,
                     base::Passed(&extra_nodes_to_load_));
 }
 
 void TestBookmarkClient::DoneLoading(BookmarkPermanentNode* managed_node,
                                      BookmarkPermanentNode* supervised_node) {
 }
 
 // static
 BookmarkPermanentNodeList TestBookmarkClient::LoadExtraNodes(
     BookmarkPermanentNodeList extra_nodes,
     int64* next_id) {
   return extra_nodes.Pass();
 }
 
 }  // namespace bookmarks