Remove dependency of HistoryServiceFactory on 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"
 #include "chrome/browser/favicon/favicon_service_factory.h"
+#include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_node.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/managed/managed_bookmarks_tracker.h"
 #include "components/favicon/core/favicon_service.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/url_database.h"
@@ skipping 34 matching lines @@
   node->set_id(id);
   *next_node_id = ManagedBookmarksTracker::LoadInitial(
       node, initial_bookmarks, id + 1);
   node->set_visible(!node->empty());
 }
 
 }  // namespace
 
 ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile)
     : profile_(profile),
-      history_service_(NULL),
-      model_(NULL),
-      managed_node_(NULL),
-      supervised_node_(NULL) {
+      model_(nullptr),
+      managed_node_(nullptr),
+      supervised_node_(nullptr) {
 }
 
 ChromeBookmarkClient::~ChromeBookmarkClient() {
 }
 
 void ChromeBookmarkClient::Init(BookmarkModel* model) {
   DCHECK(model);
   DCHECK(!model_);
   model_ = model;
   model_->AddObserver(this);
 
   managed_bookmarks_tracker_.reset(new ManagedBookmarksTracker(
       model_,
       profile_->GetPrefs(),
       false,
       base::Bind(&ChromeBookmarkClient::GetManagedBookmarksDomain,
                  base::Unretained(this))));
   supervised_bookmarks_tracker_.reset(new ManagedBookmarksTracker(
       model_,
       profile_->GetPrefs(),
       true,
       base::Callback<std::string()>()));
 }
 
 void ChromeBookmarkClient::Shutdown() {
-  favicon_changed_subscription_.reset();
   if (model_) {
     model_->RemoveObserver(this);
-    model_ = NULL;
+    model_ = nullptr;
   }
   BookmarkClient::Shutdown();
 }
 
 bool ChromeBookmarkClient::PreferTouchIcon() {
 #if !defined(OS_IOS)
   return false;
 #else
   return true;
 #endif
@@ skipping 23 matching lines @@
   }
 }
 
 bool ChromeBookmarkClient::SupportsTypedCountForNodes() {
   return true;
 }
 
 void ChromeBookmarkClient::GetTypedCountForNodes(
     const NodeSet& nodes,
     NodeTypedCountPairs* node_typed_count_pairs) {
+  history::HistoryService* history_service =
+      HistoryServiceFactory::GetForProfileIfExists(
+          profile_, ServiceAccessType::EXPLICIT_ACCESS);
   history::URLDatabase* url_db =
-      history_service_ ? history_service_->InMemoryDatabase() : NULL;
+      history_service ? history_service->InMemoryDatabase() : nullptr;
   for (NodeSet::const_iterator i = nodes.begin(); i != nodes.end(); ++i) {
     int typed_count = 0;
 
     // If |url_db| is the InMemoryDatabase, it might not cache all URLRows, but
     // it guarantees to contain those with |typed_count| > 0. Thus, if we cannot
     // fetch the URLRow, it is safe to assume that its |typed_count| is 0.
     history::URLRow url;
     if (url_db && url_db->GetRowForURL((*i)->url(), &url))
       typed_count = url.typed_count();
 
@@ skipping 57 matching lines @@
 bool ChromeBookmarkClient::CanSyncNode(const BookmarkNode* node) {
   return !bookmarks::IsDescendantOf(node, managed_node_) &&
          !bookmarks::IsDescendantOf(node, supervised_node_);
 }
 
 bool ChromeBookmarkClient::CanBeEditedByUser(const BookmarkNode* node) {
   return !bookmarks::IsDescendantOf(node, managed_node_) &&
          !bookmarks::IsDescendantOf(node, supervised_node_);
 }
 
-void ChromeBookmarkClient::SetHistoryService(
-    history::HistoryService* history_service) {
-  DCHECK(history_service);
-  history_service_ = history_service;
-  favicon_changed_subscription_ = history_service_->AddFaviconChangedCallback(
-      base::Bind(&BookmarkModel::OnFaviconChanged, base::Unretained(model_)));
-}
-
 void ChromeBookmarkClient::BookmarkModelChanged() {
 }
 
-void ChromeBookmarkClient::BookmarkNodeRemoved(
-    BookmarkModel* model,
-    const BookmarkNode* parent,
-    int old_index,
-    const BookmarkNode* node,
-    const std::set<GURL>& removed_urls) {
-  if (history_service_)
-    history_service_->URLsNoLongerBookmarked(removed_urls);
-}
-
-void ChromeBookmarkClient::BookmarkAllUserNodesRemoved(
-    BookmarkModel* model,
-    const std::set<GURL>& removed_urls) {
-  if (history_service_)
-    history_service_->URLsNoLongerBookmarked(removed_urls);
-}
-
 void ChromeBookmarkClient::BookmarkModelLoaded(BookmarkModel* model,
                                                bool ids_reassigned) {
+  BaseBookmarkModelObserver::BookmarkModelLoaded(model, ids_reassigned);
   // Start tracking the managed and supervised bookmarks. This will detect any
   // changes that may have occurred while the initial managed and supervised
   // bookmarks were being loaded on the background.
   managed_bookmarks_tracker_->Init(managed_node_);
   supervised_bookmarks_tracker_->Init(supervised_node_);
 }
 
 // static
 bookmarks::BookmarkPermanentNodeList ChromeBookmarkClient::LoadExtraNodes(
     scoped_ptr<BookmarkPermanentNode> managed_node,
@@ skipping 19 matching lines @@
   return extra_nodes.Pass();
 }
 
 std::string ChromeBookmarkClient::GetManagedBookmarksDomain() {
   policy::ProfilePolicyConnector* connector =
       policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile_);
   if (connector->IsPolicyFromCloudPolicy(policy::key::kManagedBookmarks))
     return connector->GetManagementDomain();
   return std::string();
 }