Refactor HistoryService to not send NOTIFICATION_FAVICON_CHANGED

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/chrome_notification_types.h"
-#include "chrome/browser/favicon/favicon_changed_details.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history_service.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/history/core/browser/url_database.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/components_strings.h"
 #include "policy/policy_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
-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);
-}
-
 void RunCallbackWithImage(
     const favicon_base::FaviconImageCallback& callback,
     const favicon_base::FaviconRawBitmapResult& bitmap_result) {
   favicon_base::FaviconImageResult result;
   if (bitmap_result.is_valid()) {
     result.image = gfx::Image::CreateFrom1xPNGBytes(
         bitmap_result.bitmap_data->front(), bitmap_result.bitmap_data->size());
     result.icon_url = bitmap_result.icon_url;
     callback.Run(result);
     return;
   }
   callback.Run(result);
 }
 
 }  // namespace
 
 ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile)
-    : profile_(profile), model_(NULL), managed_node_(NULL) {
+    : profile_(profile),
+      history_service_(NULL),
+      model_(NULL),
+      managed_node_(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_));
 }
 
 void ChromeBookmarkClient::Shutdown() {
+  favicon_changed_subscription_.reset();
   if (model_) {
-    registrar_.RemoveAll();
-
     model_->RemoveObserver(this);
     model_ = NULL;
   }
   BookmarkClient::Shutdown();
 }
 
 bool ChromeBookmarkClient::IsDescendantOfManagedNode(const BookmarkNode* node) {
   return node && node->HasAncestor(managed_node_);
 }
 
@@ skipping 37 matching lines @@
   }
 }
 
 bool ChromeBookmarkClient::SupportsTypedCountForNodes() {
   return true;
 }
 
 void ChromeBookmarkClient::GetTypedCountForNodes(
     const NodeSet& nodes,
     NodeTypedCountPairs* node_typed_count_pairs) {
-  HistoryService* history_service =
-      HistoryServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
   history::URLDatabase* url_db =
-      history_service ? history_service->InMemoryDatabase() : NULL;
+      history_service_ ? history_service_->InMemoryDatabase() : NULL;
   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 44 matching lines @@
 }
 
 bool ChromeBookmarkClient::CanSyncNode(const BookmarkNode* node) {
   return !IsDescendantOfManagedNode(node);
 }
 
 bool ChromeBookmarkClient::CanBeEditedByUser(const BookmarkNode* node) {
   return !IsDescendantOfManagedNode(node);
 }
 
-void ChromeBookmarkClient::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  switch (type) {
-    case chrome::NOTIFICATION_FAVICON_CHANGED: {
-      content::Details<FaviconChangedDetails> favicon_details(details);
-      model_->OnFaviconChanged(favicon_details->urls);
-      break;
-    }
-
-    default:
-      NOTREACHED();
-      break;
-  }
+void ChromeBookmarkClient::SetHistoryService(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) {
-  NotifyHistoryOfRemovedURLs(profile_, removed_urls);
+  if (history_service_)
+    history_service_->URLsNoLongerBookmarked(removed_urls);
 }
 
 void ChromeBookmarkClient::BookmarkAllUserNodesRemoved(
     BookmarkModel* model,
     const std::set<GURL>& removed_urls) {
-  NotifyHistoryOfRemovedURLs(profile_, removed_urls);
+  if (history_service_)
+    history_service_->URLsNoLongerBookmarked(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_);
 }
 
@@ skipping 19 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();
 }