Introduce ChromeBookmarkClientFactory

chrome/browser/bookmarks/chrome_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 "chrome/browser/bookmarks/chrome_bookmark_client.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/values.h"
@@ skipping 24 matching lines @@
 void NotifyHistoryOfRemovedURLs(Profile* profile,
                                 const std::set<GURL>& removed_urls) {
   HistoryService* history_service =
       HistoryServiceFactory::GetForProfile(profile, Profile::EXPLICIT_ACCESS);
   if (history_service)
     history_service->URLsNoLongerBookmarked(removed_urls);
 }
 
 }  // namespace
 
-ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile, bool index_urls)
-    : profile_(profile),
-      model_(new BookmarkModel(this, index_urls)),
-      managed_bookmarks_tracker_(
-          model_.get(),
-          profile_->GetPrefs(),
-          base::Bind(&ChromeBookmarkClient::GetManagedBookmarksDomain,
-                     base::Unretained(this))),
-      managed_node_(NULL) {
+ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile)
+    : profile_(profile), model_(NULL) {
+}
+
+ChromeBookmarkClient::~ChromeBookmarkClient() {
+}
+
+void ChromeBookmarkClient::Init(BookmarkModel* model) {
+  DCHECK(model);
+  DCHECK(!model_);
+  model_ = model;
   model_->AddObserver(this);
+
+  managed_bookmarks_tracker_.reset(new policy::ManagedBookmarksTracker(
+      model_,
+      profile_->GetPrefs(),
+      base::Bind(&ChromeBookmarkClient::GetManagedBookmarksDomain,
+                 base::Unretained(this))));
+
   // Listen for changes to favicons so that we can update the favicon of the
   // node appropriately.
   registrar_.Add(this,
                  chrome::NOTIFICATION_FAVICON_CHANGED,
                  content::Source<Profile>(profile_));
 }
 
-ChromeBookmarkClient::~ChromeBookmarkClient() {
-  model_->RemoveObserver(this);
+void ChromeBookmarkClient::Shutdown() {
+  if (model_) {
+    registrar_.RemoveAll();
 
-  registrar_.RemoveAll();
+    model_->RemoveObserver(this);
+    model_ = NULL;
+  }
+  BookmarkClient::Shutdown();
 }
 
 bool ChromeBookmarkClient::IsDescendantOfManagedNode(const BookmarkNode* node) {
   return node && node->HasAncestor(managed_node_);
 }
 
 bool ChromeBookmarkClient::HasDescendantsOfManagedNode(
     const std::vector<const BookmarkNode*>& list) {
   for (size_t i = 0; i < list.size(); ++i) {
     if (IsDescendantOfManagedNode(list[i]))
@@ skipping 74 matching lines @@
 
 bookmarks::LoadExtraCallback ChromeBookmarkClient::GetLoadExtraNodesCallback() {
   // Create the managed_node now; it will be populated in the LoadExtraNodes
   // callback.
   managed_node_ = new BookmarkPermanentNode(0);
   return base::Bind(
       &ChromeBookmarkClient::LoadExtraNodes,
       StartupTaskRunnerServiceFactory::GetForProfile(profile_)
           ->GetBookmarkTaskRunner(),
       managed_node_,
-      base::Passed(managed_bookmarks_tracker_.GetInitialManagedBookmarks()));
+      base::Passed(managed_bookmarks_tracker_->GetInitialManagedBookmarks()));
 }
 
 bool ChromeBookmarkClient::CanSetPermanentNodeTitle(
     const BookmarkNode* permanent_node) {
   // The |managed_node_| can have its title updated if the user signs in or
   // out.
   return !IsDescendantOfManagedNode(permanent_node) ||
          permanent_node == managed_node_;
 }
 
@@ skipping 15 matching lines @@
       model_->OnFaviconChanged(favicon_details->urls);
       break;
     }
 
     default:
       NOTREACHED();
       break;
   }
 }
 
-void ChromeBookmarkClient::Shutdown() {
-  model_->Shutdown();
-}
-
 void ChromeBookmarkClient::BookmarkModelChanged() {
 }
 
 void ChromeBookmarkClient::BookmarkNodeRemoved(
     BookmarkModel* model,
     const BookmarkNode* parent,
     int old_index,
     const BookmarkNode* node,
     const std::set<GURL>& removed_urls) {
   NotifyHistoryOfRemovedURLs(profile_, removed_urls);
 }
 
 void ChromeBookmarkClient::BookmarkAllUserNodesRemoved(
     BookmarkModel* model,
     const std::set<GURL>& removed_urls) {
   NotifyHistoryOfRemovedURLs(profile_, removed_urls);
 }
 
 void ChromeBookmarkClient::BookmarkModelLoaded(BookmarkModel* model,
                                                bool ids_reassigned) {
   // Start tracking the managed bookmarks. This will detect any changes that
   // may have occurred while the initial managed bookmarks were being loaded
   // on the background.
-  managed_bookmarks_tracker_.Init(managed_node_);
+  managed_bookmarks_tracker_->Init(managed_node_);
 }
 
 // static
 bookmarks::BookmarkPermanentNodeList ChromeBookmarkClient::LoadExtraNodes(
     const scoped_refptr<base::DeferredSequencedTaskRunner>& profile_io_runner,
     BookmarkPermanentNode* managed_node,
     scoped_ptr<base::ListValue> initial_managed_bookmarks,
     int64* next_node_id) {
   DCHECK(profile_io_runner->RunsTasksOnCurrentThread());
   // Load the initial contents of the |managed_node| now, and assign it an
@@ skipping 11 matching lines @@
   return extra_nodes.Pass();
 }
 
 std::string ChromeBookmarkClient::GetManagedBookmarksDomain() {
   policy::ProfilePolicyConnector* connector =
       policy::ProfilePolicyConnectorFactory::GetForProfile(profile_);
   if (connector->IsPolicyFromCloudPolicy(policy::key::kManagedBookmarks))
     return connector->GetManagementDomain();
   return std::string();
 }