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/sequenced_task_runner.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_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/history/url_database.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/bookmarks/core/browser/bookmark_title_match.h"
 #include "components/favicon_base/favicon_types.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
+#include "content/public/browser/user_metrics.h"
 #include "grit/generated_resources.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.
@@ skipping 61 matching lines @@
 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) {
+    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_));
 
   // Load the bookmarks. BookmarkStorage notifies us when done.
-  store_ = new BookmarkStorage(profile_, this, task_runner.get());
-  store_->LoadBookmarks(CreateLoadDetails());
+  store_ = new BookmarkStorage(this, profile_->GetPath(), io_task_runner.get());
+  store_->LoadBookmarks(CreateLoadDetails(), 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 474 matching lines @@
   SetDateFolderModified(node, Time());
 }
 
 void BookmarkModel::GetBookmarksWithTitlesMatching(
     const base::string16& text,
     size_t max_count,
     std::vector<BookmarkTitleMatch>* matches) {
   if (!loaded_)
     return;
 
-  index_->GetBookmarksWithTitlesMatching(text, max_count, matches);
+  index_->GetBookmarksWithTitlesMatching(this, text, max_count, matches);
 }
 
 void BookmarkModel::ClearStore() {
   registrar_.RemoveAll();
   store_ = NULL;
 }
 
 void BookmarkModel::SetPermanentNodeVisible(BookmarkNode::Type type,
                                             bool value) {
   DCHECK(loaded_);
@@ skipping 245 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 = 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());
@@ skipping 43 matching lines @@
   return next_node_id_++;
 }
 
 BookmarkLoadDetails* BookmarkModel::CreateLoadDetails() {
   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_),
-                                 next_node_id_);
+  return new BookmarkLoadDetails(
+      bb_node, other_node, mobile_node, new BookmarkIndex(), next_node_id_);
 }
+
+base::CancelableTaskTracker::TaskId BookmarkModel::GetFaviconImageForURL(

[sky, 2014/04/18 17:05:04]

Style guide says declaration order and definition order should match. So, move
these to match position in header.

[sdefresne, 2014/04/18 22:25:49]

Done.

+    const GURL& page_url,
+    int icon_types,
+    int desired_size_in_dip,
+    const FaviconImageCallback& callback,
+    base::CancelableTaskTracker* tracker) {
+  FaviconService* favicon_service =
+      FaviconServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  if (!favicon_service)
+    return base::CancelableTaskTracker::kBadTaskId;
+  return favicon_service->GetFaviconImageForURL(
+      FaviconService::FaviconForURLParams(
+          page_url, icon_types, desired_size_in_dip),
+      callback,
+      tracker);
+}
+
+void BookmarkModel::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;
+  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();
+
+    NodeTypedCountPair pair(*i, typed_count);
+    node_typed_count_pairs->push_back(pair);
+  }
+}
+
+void BookmarkModel::RecordAction(const base::UserMetricsAction& action) {
+  content::RecordAction(action);
+}