Introduce BookmarkClient interface to abstract embedder

chrome/browser/bookmarks/bookmark_model.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 "chrome/browser/bookmarks/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/i18n/string_compare.h"
-#include "base/prefs/pref_service.h"
-#include "base/sequenced_task_runner.h"
+#include "base/logging.h"
+#include "base/strings/string_util.h"
 #include "chrome/browser/bookmarks/bookmark_expanded_state_tracker.h"
 #include "chrome/browser/bookmarks/bookmark_index.h"
 #include "chrome/browser/bookmarks/bookmark_model_observer.h"
+#include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "chrome/browser/bookmarks/bookmark_storage.h"
 #include "chrome/browser/bookmarks/bookmark_utils.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/profiles/profile.h"
-#include "chrome/common/pref_names.h"
 #include "components/bookmarks/core/browser/bookmark_match.h"
 #include "components/favicon_base/favicon_types.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_source.h"
 #include "grit/component_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/favicon_size.h"
-#include "ui/gfx/image/image_util.h"
 
 using base::Time;
 
 namespace {
 
 // Helper to get a mutable bookmark node.
 BookmarkNode* AsMutable(const BookmarkNode* node) {
   return const_cast<BookmarkNode*>(node);
 }
 
@@ skipping 19 matching lines @@
   }
 
  private:
   icu::Collator* collator_;
 };
 
 }  // namespace
 
 // BookmarkModel --------------------------------------------------------------
 
-BookmarkModel::BookmarkModel(Profile* profile,
-                             bool index_urls)
-    : profile_(profile),
+BookmarkModel::BookmarkModel(BookmarkClient* client, bool index_urls)
+    : client_(client),
       loaded_(false),
       root_(GURL()),
       bookmark_bar_node_(NULL),
       other_node_(NULL),
       mobile_node_(NULL),
       next_node_id_(1),
       observers_(ObserverList<BookmarkModelObserver>::NOTIFY_EXISTING_ONLY),
       index_urls_(index_urls),
       loaded_signal_(true, false),
       extensive_changes_(0) {
-  if (!profile_) {
-    // Profile is null during testing.
-    DoneLoading(CreateLoadDetails());
-  }
+  DCHECK(client_);
 }
 
 BookmarkModel::~BookmarkModel() {
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkModelBeingDeleted(this));
 
   if (store_.get()) {
     // The store maintains a reference back to us. We need to tell it we're gone
     // so that it doesn't try and invoke a method back on us again.
     store_->BookmarkModelDeleted();
   }
 }
 
 void BookmarkModel::Shutdown() {
   if (loaded_)
     return;
 
   // See comment in HistoryService::ShutdownOnUIThread where this is invoked for
   // details. It is also called when the BookmarkModel is deleted.
   loaded_signal_.Signal();
 }
 
 void BookmarkModel::Load(
-    const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
+    PrefService* pref_service,
+    const std::string& accept_languages,
+    const base::FilePath& profile_path,
+    const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& ui_task_runner) {
   if (store_.get()) {
     // If the store is non-null, it means Load was already invoked. Load should
     // only be invoked once.
     NOTREACHED();
     return;
   }
 
   expanded_state_tracker_.reset(
-      new BookmarkExpandedStateTracker(this, profile_->GetPrefs()));
-
-  // 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_));
+      new BookmarkExpandedStateTracker(this, pref_service));
 
   // Load the bookmarks. BookmarkStorage notifies us when done.
-  store_ = new BookmarkStorage(profile_, this, task_runner.get());
-  store_->LoadBookmarks(CreateLoadDetails());
+  store_ = new BookmarkStorage(this, profile_path, io_task_runner.get());
+  store_->LoadBookmarks(CreateLoadDetails(accept_languages), ui_task_runner);
 }
 
 const BookmarkNode* BookmarkModel::GetParentForNewNodes() {
   std::vector<const BookmarkNode*> nodes =
       bookmark_utils::GetMostRecentlyModifiedFolders(this, 1);
   DCHECK(!nodes.empty());  // This list is always padded with default folders.
   return nodes[0];
 }
 
 void BookmarkModel::AddObserver(BookmarkModelObserver* observer) {
@@ skipping 57 matching lines @@
         BookmarkNode* child_node = permanent_node->GetChild(j);
         removed_nodes.push_back(child_node);
         RemoveNodeAndGetRemovedUrls(child_node, &removed_urls);
       }
     }
   }
   EndExtensiveChanges();
   if (store_.get())
     store_->ScheduleSave();
 
-  NotifyHistoryAboutRemovedBookmarks(removed_urls);
+  client_->NotifyHistoryAboutRemovedBookmarks(removed_urls);
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkAllNodesRemoved(this));
 }
 
 void BookmarkModel::Move(const BookmarkNode* node,
                          const BookmarkNode* new_parent,
                          int index) {
   if (!loaded_ || !node || !IsValidIndex(new_parent, index, true) ||
       is_root_node(new_parent) || is_permanent_node(node)) {
@@ skipping 60 matching lines @@
 const gfx::Image& BookmarkModel::GetFavicon(const BookmarkNode* node) {
   DCHECK(node);
   if (node->favicon_state() == BookmarkNode::INVALID_FAVICON) {
     BookmarkNode* mutable_node = AsMutable(node);
     mutable_node->set_favicon_state(BookmarkNode::LOADING_FAVICON);
     LoadFavicon(mutable_node);
   }
   return node->favicon();
 }
 
-void BookmarkModel::SetTitle(const BookmarkNode* node, const base::string16& title) {
+void BookmarkModel::SetTitle(const BookmarkNode* node,
+                             const base::string16& title) {
   if (!node) {
     NOTREACHED();
     return;
   }
   if (node->GetTitle() == title)
     return;
 
   if (is_permanent_node(node)) {
     NOTREACHED();
     return;
@@ skipping 107 matching lines @@
     const BookmarkNode* node,
     int64 sync_transaction_version) {
   if (sync_transaction_version == node->sync_transaction_version())
     return;
 
   AsMutable(node)->set_sync_transaction_version(sync_transaction_version);
   if (store_.get())
     store_->ScheduleSave();
 }
 
+void BookmarkModel::OnFaviconChanged(const std::set<GURL>& urls) {
+  // Ignore events if |Load| has not been called yet.
+  if (!store_)
+    return;
+
+  // Prevent the observers from getting confused for multiple favicon loads.
+  for (std::set<GURL>::const_iterator i = urls.begin(); i != urls.end(); ++i) {
+    std::vector<const BookmarkNode*> nodes;
+    GetNodesByURL(*i, &nodes);
+    for (size_t i = 0; i < nodes.size(); ++i) {
+      // Got an updated favicon, for a URL, do a new request.
+      BookmarkNode* node = AsMutable(nodes[i]);
+      node->InvalidateFavicon();
+      CancelPendingFaviconLoadRequests(node);
+      FOR_EACH_OBSERVER(BookmarkModelObserver,
+                        observers_,
+                        BookmarkNodeFaviconChanged(this, node));
+    }
+  }
+}
+
 void BookmarkModel::SetDateAdded(const BookmarkNode* node,
                                  base::Time date_added) {
   if (!node) {
     NOTREACHED();
     return;
   }
 
   if (node->date_added() == date_added)
     return;
 
@@ skipping 187 matching lines @@
     const base::string16& text,
     size_t max_count,
     std::vector<BookmarkMatch>* matches) {
   if (!loaded_)
     return;
 
   index_->GetBookmarksMatching(text, max_count, matches);
 }
 
 void BookmarkModel::ClearStore() {
-  registrar_.RemoveAll();
   store_ = NULL;
 }
 
 void BookmarkModel::SetPermanentNodeVisible(BookmarkNode::Type type,
                                             bool value) {
   DCHECK(loaded_);
   switch (type) {
     case BookmarkNode::BOOKMARK_BAR:
       bookmark_bar_node_->set_visible(value);
       break;
@@ skipping 95 matching lines @@
 
   std::set<GURL> removed_urls;
   {
     base::AutoLock url_lock(url_lock_);
     RemoveNodeAndGetRemovedUrls(node.get(), &removed_urls);
   }
 
   if (store_.get())
     store_->ScheduleSave();
 
-  NotifyHistoryAboutRemovedBookmarks(removed_urls);
+  client_->NotifyHistoryAboutRemovedBookmarks(removed_urls);

[sky, 2014/04/23 20:32:07]

I don't think this needs to be on the client. The chrome side can add an
observer to detect this and cleanup history. If you want to do this later, add a
TODO for now.

[sdefresne, 2014/04/24 12:30:15]

Make sense. I was also considering doing it. I'll do it in a followup CL, added
a TODO.

 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkNodeRemoved(this, parent, index, node.get()));
 }
 
 void BookmarkModel::RemoveNodeFromURLSet(BookmarkNode* node) {
   // NOTE: this is called in such a way that url_lock_ is already held. As
   // such, this doesn't explicitly grab the lock.
   NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(node);
   DCHECK(i != nodes_ordered_by_url_set_.end());
@@ skipping 23 matching lines @@
       // invalidated, so using i++ here within the "erase" call is
       // important as it advances the iterator before passing the
       // old value through to erase.
       removed_urls->erase(i++);
     } else {
       ++i;
     }
   }
 }
 
-void BookmarkModel::NotifyHistoryAboutRemovedBookmarks(
-    const std::set<GURL>& removed_bookmark_urls) const {
-  if (removed_bookmark_urls.empty()) {
-    // No point in sending out notification if the starred state didn't change.
-    return;
-  }
-
-  if (profile_) {
-    HistoryService* history =
-        HistoryServiceFactory::GetForProfile(profile_,
-                                             Profile::EXPLICIT_ACCESS);
-    if (history)
-      history->URLsNoLongerBookmarked(removed_bookmark_urls);
-  }
-}
-
 BookmarkNode* BookmarkModel::AddNode(BookmarkNode* parent,
                                      int index,
                                      BookmarkNode* node) {
   parent->Add(node, index);
 
   if (store_.get())
     store_->ScheduleSave();
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkNodeAdded(this, parent, index));
@@ skipping 53 matching lines @@
     node->set_icon_url(image_result.icon_url);
     FaviconLoaded(node);
   }
 }
 
 void BookmarkModel::LoadFavicon(BookmarkNode* node) {
   if (node->is_folder())
     return;
 
   DCHECK(node->url().is_valid());
-  FaviconService* favicon_service = FaviconServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
-  if (!favicon_service)
-    return;
-  base::CancelableTaskTracker::TaskId taskId =
-      favicon_service->GetFaviconImageForURL(
-          FaviconService::FaviconForURLParams(
-              node->url(), favicon_base::FAVICON, gfx::kFaviconSize),
-          base::Bind(&BookmarkModel::OnFaviconDataAvailable,
-                     base::Unretained(this),
-                     node),
-          &cancelable_task_tracker_);
-  node->set_favicon_load_task_id(taskId);
+  base::CancelableTaskTracker::TaskId taskId = client_->GetFaviconImageForURL(
+      node->url(),
+      favicon_base::FAVICON,
+      gfx::kFaviconSize,
+      base::Bind(
+          &BookmarkModel::OnFaviconDataAvailable, base::Unretained(this), node),
+      &cancelable_task_tracker_);
+  if (taskId != base::CancelableTaskTracker::kBadTaskId)
+    node->set_favicon_load_task_id(taskId);
 }
 
 void BookmarkModel::FaviconLoaded(const BookmarkNode* node) {
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkNodeFaviconChanged(this, node));
 }
 
 void BookmarkModel::CancelPendingFaviconLoadRequests(BookmarkNode* node) {
   if (node->favicon_load_task_id() != base::CancelableTaskTracker::kBadTaskId) {
     cancelable_task_tracker_.TryCancel(node->favicon_load_task_id());
     node->set_favicon_load_task_id(base::CancelableTaskTracker::kBadTaskId);
   }
 }
 
-void BookmarkModel::Observe(int type,
-                            const content::NotificationSource& source,
-                            const content::NotificationDetails& details) {
-  switch (type) {
-    case chrome::NOTIFICATION_FAVICON_CHANGED: {
-      // Prevent the observers from getting confused for multiple favicon loads.
-      content::Details<FaviconChangedDetails> favicon_details(details);
-      for (std::set<GURL>::const_iterator i = favicon_details->urls.begin();
-           i != favicon_details->urls.end(); ++i) {
-        std::vector<const BookmarkNode*> nodes;
-        GetNodesByURL(*i, &nodes);
-        for (size_t i = 0; i < nodes.size(); ++i) {
-          // Got an updated favicon, for a URL, do a new request.
-          BookmarkNode* node = AsMutable(nodes[i]);
-          node->InvalidateFavicon();
-          CancelPendingFaviconLoadRequests(node);
-          FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                            BookmarkNodeFaviconChanged(this, node));
-        }
-      }
-      break;
-    }
-
-    default:
-      NOTREACHED();
-      break;
-  }
-}
-
 void BookmarkModel::PopulateNodesByURL(BookmarkNode* node) {
   // NOTE: this is called with url_lock_ already held. As such, this doesn't
   // explicitly grab the lock.
   if (node->is_url())
     nodes_ordered_by_url_set_.insert(node);
   for (int i = 0; i < node->child_count(); ++i)
     PopulateNodesByURL(node->GetChild(i));
 }
 
 int64 BookmarkModel::generate_next_node_id() {
   return next_node_id_++;
 }
 
-BookmarkLoadDetails* BookmarkModel::CreateLoadDetails() {
+BookmarkLoadDetails* BookmarkModel::CreateLoadDetails(
+    const std::string& accept_languages) {
   BookmarkPermanentNode* bb_node =
       CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
   BookmarkPermanentNode* other_node =
       CreatePermanentNode(BookmarkNode::OTHER_NODE);
   BookmarkPermanentNode* mobile_node =
       CreatePermanentNode(BookmarkNode::MOBILE);
   return new BookmarkLoadDetails(
-      bb_node, other_node, mobile_node,
-      new BookmarkIndex(
-          profile_,
-          index_urls_,
-          profile_ ?
-              profile_->GetPrefs()->GetString(prefs::kAcceptLanguages) :
-              std::string()),
+      bb_node,
+      other_node,
+      mobile_node,
+      new BookmarkIndex(client_, index_urls_, accept_languages),
       next_node_id_);
 }