Use BookmarkModelFactory::GetForBrowserContext everywhere

chrome/browser/extensions/api/bookmarks/bookmarks_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/extensions/api/bookmarks/bookmarks_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 78 matching lines @@
   base::i18n::ReplaceIllegalCharactersInPath(&filename, '_');
 
   base::FilePath default_path;
   PathService::Get(chrome::DIR_USER_DOCUMENTS, &default_path);
   return default_path.Append(filename);
 }
 
 }  // namespace
 
 bool BookmarksFunction::RunAsync() {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   if (!model->loaded()) {
     // Bookmarks are not ready yet.  We'll wait.
     model->AddObserver(this);
     AddRef();  // Balanced in Loaded().
     return true;
   }
 
   RunAndSendResponse();
   return true;
 }
 
 BookmarkModel* BookmarksFunction::GetBookmarkModel() {
-  return BookmarkModelFactory::GetForProfile(GetProfile());
+  return BookmarkModelFactory::GetForBrowserContext(GetProfile());
 }
 
 ManagedBookmarkService* BookmarksFunction::GetManagedBookmarkService() {
   return ManagedBookmarkServiceFactory::GetForProfile(GetProfile());
 }
 
 bool BookmarksFunction::GetBookmarkIdAsInt64(const std::string& id_string,
                                              int64_t* id) {
   if (base::StringToInt64(id_string, id))
     return true;
 
   error_ = keys::kInvalidIdError;
   return false;
 }
 
 const BookmarkNode* BookmarksFunction::GetBookmarkNodeFromId(
     const std::string& id_string) {
   int64_t id;
   if (!GetBookmarkIdAsInt64(id_string, &id))
     return NULL;
 
   const BookmarkNode* node = ::bookmarks::GetBookmarkNodeByID(
-      BookmarkModelFactory::GetForProfile(GetProfile()), id);
+      BookmarkModelFactory::GetForBrowserContext(GetProfile()), id);
   if (!node)
     error_ = keys::kNoNodeError;
 
   return node;
 }
 
 const BookmarkNode* BookmarksFunction::CreateBookmarkNode(
     BookmarkModel* model,
     const CreateDetails& details,
     const BookmarkNode::MetaInfoMap* meta_info) {
@@ skipping 92 matching lines @@
     content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_BOOKMARKS_API_INVOKED,
       content::Source<const Extension>(extension()),
       content::Details<const BookmarksFunction>(this));
   }
   SendResponse(success);
 }
 
 BookmarkEventRouter::BookmarkEventRouter(Profile* profile)
     : browser_context_(profile),
-      model_(BookmarkModelFactory::GetForProfile(profile)),
+      model_(BookmarkModelFactory::GetForBrowserContext(profile)),
       managed_(ManagedBookmarkServiceFactory::GetForProfile(profile)) {
   model_->AddObserver(this);
 }
 
 BookmarkEventRouter::~BookmarkEventRouter() {
   if (model_) {
     model_->RemoveObserver(this);
   }
 }
 
@@ skipping 210 matching lines @@
 
 bool BookmarksGetRecentFunction::RunOnReady() {
   std::unique_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;
   ::bookmarks::GetMostRecentlyAddedEntries(
-      BookmarkModelFactory::GetForProfile(GetProfile()),
-      params->number_of_items,
-      &nodes);
+      BookmarkModelFactory::GetForBrowserContext(GetProfile()),
+      params->number_of_items, &nodes);
 
   std::vector<BookmarkTreeNode> tree_nodes;
   for (const BookmarkNode* node : nodes) {
     bookmark_api_helpers::AddNode(GetManagedBookmarkService(), node,
                                   &tree_nodes, false);
   }
 
   results_ = bookmarks::GetRecent::Results::Create(tree_nodes);
   return true;
 }
 
 bool BookmarksGetTreeFunction::RunOnReady() {
   std::vector<BookmarkTreeNode> nodes;
   const BookmarkNode* node =
-      BookmarkModelFactory::GetForProfile(GetProfile())->root_node();
+      BookmarkModelFactory::GetForBrowserContext(GetProfile())->root_node();
   bookmark_api_helpers::AddNode(GetManagedBookmarkService(), node, &nodes,
                                 true);
   results_ = bookmarks::GetTree::Results::Create(nodes);
   return true;
 }
 
 bool BookmarksGetSubTreeFunction::RunOnReady() {
   std::unique_ptr<bookmarks::GetSubTree::Params> params(
       bookmarks::GetSubTree::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
@@ skipping 13 matching lines @@
   std::unique_ptr<bookmarks::Search::Params> params(
       bookmarks::Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::vector<const BookmarkNode*> nodes;
   if (params->query.as_string) {
     ::bookmarks::QueryFields query;
     query.word_phrase_query.reset(
         new base::string16(base::UTF8ToUTF16(*params->query.as_string)));
     ::bookmarks::GetBookmarksMatchingProperties(
-        BookmarkModelFactory::GetForProfile(GetProfile()),
-        query,
-        std::numeric_limits<int>::max(),
-        &nodes);
+        BookmarkModelFactory::GetForBrowserContext(GetProfile()), query,
+        std::numeric_limits<int>::max(), &nodes);
   } else {
     DCHECK(params->query.as_object);
     const bookmarks::Search::Params::Query::Object& object =
         *params->query.as_object;
     ::bookmarks::QueryFields query;
     if (object.query) {
       query.word_phrase_query.reset(
           new base::string16(base::UTF8ToUTF16(*object.query)));
     }
     if (object.url)
       query.url.reset(new base::string16(base::UTF8ToUTF16(*object.url)));
     if (object.title)
       query.title.reset(new base::string16(base::UTF8ToUTF16(*object.title)));
     ::bookmarks::GetBookmarksMatchingProperties(
-        BookmarkModelFactory::GetForProfile(GetProfile()),
-        query,
-        std::numeric_limits<int>::max(),
-        &nodes);
+        BookmarkModelFactory::GetForBrowserContext(GetProfile()), query,
+        std::numeric_limits<int>::max(), &nodes);
   }
 
   std::vector<BookmarkTreeNode> tree_nodes;
   ManagedBookmarkService* managed = GetManagedBookmarkService();
   for (const BookmarkNode* node : nodes)
     bookmark_api_helpers::AddNode(managed, node, &tree_nodes, false);
 
   results_ = bookmarks::Search::Results::Create(tree_nodes);
   return true;
 }
@@ skipping 38 matching lines @@
 }
 
 bool BookmarksCreateFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
   std::unique_ptr<bookmarks::Create::Params> params(
       bookmarks::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   const BookmarkNode* node = CreateBookmarkNode(model, params->bookmark, NULL);
   if (!node)
     return false;
 
   BookmarkTreeNode ret = bookmark_api_helpers::GetBookmarkTreeNode(
       GetManagedBookmarkService(), node, false, false);
   results_ = bookmarks::Create::Results::Create(ret);
 
   return true;
 }
@@ skipping 11 matching lines @@
     return false;
 
   std::unique_ptr<bookmarks::Move::Params> params(
       bookmarks::Move::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
   if (!node)
     return false;
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   if (model->is_permanent_node(node)) {
     error_ = keys::kModifySpecialError;
     return false;
   }
 
   const BookmarkNode* parent = NULL;
   if (!params->destination.parent_id.get()) {
     // Optional, defaults to current parent.
     parent = node->parent();
   } else {
@@ skipping 57 matching lines @@
   GURL url(url_string);
   if (!url_string.empty() && !url.is_valid()) {
     error_ = keys::kInvalidUrlError;
     return false;
   }
 
   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
   if (!CanBeModified(node))
     return false;
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   if (model->is_permanent_node(node)) {
     error_ = keys::kModifySpecialError;
     return false;
   }
   if (has_title)
     model->SetTitle(node, title);
   if (!url.is_empty())
     model->SetURL(node, url);
 
   BookmarkTreeNode tree_node = bookmark_api_helpers::GetBookmarkTreeNode(
@@ skipping 108 matching lines @@
 }
 
 void BookmarksExportFunction::FileSelected(const base::FilePath& path,
                                            int index,
                                            void* params) {
   bookmark_html_writer::WriteBookmarks(GetProfile(), path, NULL);
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }
 
 }  // namespace extensions