Removing instances of profile_->GetBookmarkModel() as part of converting BookmarkModel to a PKS.

chrome/browser/bookmarks/bookmark_extension_api.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_extension_api.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/time_formatting.h"
@@ skipping 279 matching lines @@
                 keys::kOnBookmarkImportEnded,
                 json_args);
 }
 
 bool GetBookmarksFunction::RunImpl() {
   scoped_ptr<bookmarks::Get::Params> params(
       bookmarks::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   if (params->id_or_id_list_type ==
       bookmarks::Get::Params::ID_OR_ID_LIST_ARRAY) {
     std::vector<std::string>* ids = params->id_or_id_list_array.get();
     size_t count = ids->size();
     EXTENSION_FUNCTION_VALIDATE(count > 0);
     for (size_t i = 0; i < count; ++i) {
       int64 id;
       if (!GetBookmarkIdAsInt64(ids->at(i), &id))
         return false;
       const BookmarkNode* node = model->GetNodeByID(id);
@@ skipping 23 matching lines @@
 bool GetBookmarkChildrenFunction::RunImpl() {
   scoped_ptr<bookmarks::GetChildren::Params> params(
       bookmarks::GetChildren::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int64 id;
   if (!GetBookmarkIdAsInt64(params->id, &id))
     return false;
 
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
-  const BookmarkNode* node = profile()->GetBookmarkModel()->GetNodeByID(id);
+  const BookmarkNode* node =
+      BookmarkModelFactory::GetForProfile(profile())->GetNodeByID(id);
   if (!node) {
     error_ = keys::kNoNodeError;
     return false;
   }
   int child_count = node->child_count();
   for (int i = 0; i < child_count; ++i) {
     const BookmarkNode* child = node->GetChild(i);
     bookmark_extension_helpers::AddNode(child, &nodes, false);
   }
 
   results_ = bookmarks::GetChildren::Results::Create(nodes);
   return true;
 }
 
 bool GetBookmarkRecentFunction::RunImpl() {
   scoped_ptr<bookmarks::GetRecent::Params> params(
       bookmarks::GetRecent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   if (params->number_of_items < 1)
     return false;
 
   std::vector<const BookmarkNode*> nodes;
-  bookmark_utils::GetMostRecentlyAddedEntries(profile()->GetBookmarkModel(),
-                                              params->number_of_items,
-                                              &nodes);
+  bookmark_utils::GetMostRecentlyAddedEntries(
+      BookmarkModelFactory::GetForProfile(profile()),
+      params->number_of_items,
+      &nodes);
 
   std::vector<linked_ptr<BookmarkTreeNode> > tree_nodes;
   std::vector<const BookmarkNode*>::iterator i = nodes.begin();
   for (; i != nodes.end(); ++i) {
     const BookmarkNode* node = *i;
     bookmark_extension_helpers::AddNode(node, &tree_nodes, false);
   }
 
   results_ = bookmarks::GetRecent::Results::Create(tree_nodes);
   return true;
 }
 
 bool GetBookmarkTreeFunction::RunImpl() {
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
-  const BookmarkNode* node = profile()->GetBookmarkModel()->root_node();
+  const BookmarkNode* node =
+      BookmarkModelFactory::GetForProfile(profile())->root_node();
   bookmark_extension_helpers::AddNode(node, &nodes, true);
   results_ = bookmarks::GetTree::Results::Create(nodes);
   return true;
 }
 
 bool GetBookmarkSubTreeFunction::RunImpl() {
   scoped_ptr<bookmarks::GetSubTree::Params> params(
       bookmarks::GetSubTree::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int64 id;
   if (!GetBookmarkIdAsInt64(params->id, &id))
     return false;
 
-  const BookmarkNode* node = profile()->GetBookmarkModel()->GetNodeByID(id);
+  const BookmarkNode* node =
+      BookmarkModelFactory::GetForProfile(profile())->GetNodeByID(id);
   if (!node) {
     error_ = keys::kNoNodeError;
     return false;
   }
 
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
   bookmark_extension_helpers::AddNode(node, &nodes, true);
   results_ = bookmarks::GetSubTree::Results::Create(nodes);
   return true;
 }
 
 bool SearchBookmarksFunction::RunImpl() {
   scoped_ptr<bookmarks::Search::Params> params(
       bookmarks::Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string lang = profile()->GetPrefs()->GetString(prefs::kAcceptLanguages);
   std::vector<const BookmarkNode*> nodes;
-  bookmark_utils::GetBookmarksContainingText(profile()->GetBookmarkModel(),
-                                             UTF8ToUTF16(params->query),
-                                             std::numeric_limits<int>::max(),
-                                             lang,
-                                             &nodes);
+  bookmark_utils::GetBookmarksContainingText(
+      BookmarkModelFactory::GetForProfile(profile()),
+      UTF8ToUTF16(params->query),
+      std::numeric_limits<int>::max(),
+      lang,
+      &nodes);
 
   std::vector<linked_ptr<BookmarkTreeNode> > tree_nodes;
   for (std::vector<const BookmarkNode*>::iterator node_iter = nodes.begin();
        node_iter != nodes.end(); ++node_iter) {
     bookmark_extension_helpers::AddNode(*node_iter, &tree_nodes, false);
   }
 
   results_ = bookmarks::Search::Results::Create(tree_nodes);
   return true;
 }
@@ skipping 39 matching lines @@
 }
 
 bool CreateBookmarkFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
 
   scoped_ptr<bookmarks::Create::Params> params(
       bookmarks::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   int64 parentId;
 
   if (!params->bookmark.parent_id.get()) {
     // Optional, default to "other bookmarks".
     parentId = model->other_node()->id();
   } else {
     if (!GetBookmarkIdAsInt64(*params->bookmark.parent_id, &parentId))
       return false;
   }
   const BookmarkNode* parent = model->GetNodeByID(parentId);
@@ skipping 138 matching lines @@
   scoped_ptr<bookmarks::Update::Params> params(
       bookmarks::Update::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int64 id;
   if (!base::StringToInt64(params->id, &id)) {
     error_ = keys::kInvalidIdError;
     return false;
   }
 
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
 
   // Optional but we need to distinguish non present from an empty title.
   string16 title;
   bool has_title = false;
   if (params->changes.title.get()) {
     title = UTF8ToUTF16(*params->changes.title);
     has_title = true;
   }
 
   // Optional.
@@ skipping 307 matching lines @@
                                            int index,
                                            void* params) {
 #if !defined(OS_ANDROID)
   // Android does not have support for the standard exporter.
   // TODO(jgreenwald): remove ifdef once extensions are no longer built on
   // Android.
   bookmark_html_writer::WriteBookmarks(profile(), path, NULL);
 #endif
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }