Use BookmarkModelFactory::GetForBrowserContext everywhere

chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_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/bookmark_manager_private/bookmark_manager_private_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 140 matching lines @@
 bookmark_manager_private::BookmarkNodeData CreateApiBookmarkNodeData(
     Profile* profile,
     const BookmarkNodeData& data) {
   const base::FilePath& profile_path = profile->GetPath();
 
   bookmark_manager_private::BookmarkNodeData node_data;
   node_data.same_profile = data.IsFromProfilePath(profile_path);
 
   if (node_data.same_profile) {
     std::vector<const BookmarkNode*> nodes = data.GetNodes(
-        BookmarkModelFactory::GetForProfile(profile), profile_path);
+        BookmarkModelFactory::GetForBrowserContext(profile), profile_path);
     for (size_t i = 0; i < nodes.size(); ++i) {
       node_data.elements.push_back(
           CreateNodeDataElementFromBookmarkNode(*nodes[i]));
     }
   } else {
     // We do not have a node IDs when the data comes from a different profile.
     for (size_t i = 0; i < data.size(); ++i)
       node_data.elements.push_back(CreateApiNodeDataElement(data.elements[i]));
   }
   return node_data;
@@ skipping 101 matching lines @@
 BrowserContextKeyedAPIFactory<BookmarkManagerPrivateAPI>*
 BookmarkManagerPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void BookmarkManagerPrivateAPI::OnListenerAdded(
     const EventListenerInfo& details) {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
   event_router_.reset(new BookmarkManagerPrivateEventRouter(
       browser_context_,
-      BookmarkModelFactory::GetForProfile(
-          Profile::FromBrowserContext(browser_context_))));
+      BookmarkModelFactory::GetForBrowserContext(browser_context_)));
 }
 
 BookmarkManagerPrivateDragEventRouter::BookmarkManagerPrivateDragEventRouter(
     Profile* profile,
     content::WebContents* web_contents)
     : profile_(profile), web_contents_(web_contents) {
   BookmarkTabHelper* bookmark_tab_helper =
       BookmarkTabHelper::FromWebContents(web_contents_);
   bookmark_tab_helper->set_bookmark_drag_delegate(this);
 }
@@ skipping 98 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params);
   return CopyOrCut(true, params->id_list);
 }
 
 bool BookmarkManagerPrivatePasteFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
   std::unique_ptr<Paste::Params> params(Paste::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   const BookmarkNode* parent_node = GetNodeFromString(model, params->parent_id);
   if (!CanBeModified(parent_node))
     return false;
   bool can_paste = bookmarks::CanPasteFromClipboard(model, parent_node);
   if (!can_paste)
     return false;
 
   // We want to use the highest index of the selected nodes as a destination.
   std::vector<const BookmarkNode*> nodes;
   // No need to test return value, if we got an empty list, we insert at end.
@@ skipping 14 matching lines @@
 bool BookmarkManagerPrivateCanPasteFunction::RunOnReady() {
   std::unique_ptr<CanPaste::Params> params(CanPaste::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   PrefService* prefs = user_prefs::UserPrefs::Get(GetProfile());
   if (!prefs->GetBoolean(bookmarks::prefs::kEditBookmarksEnabled)) {
     SetResult(base::MakeUnique<base::FundamentalValue>(false));
     return true;
   }
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   const BookmarkNode* parent_node = GetNodeFromString(model, params->parent_id);
   if (!parent_node) {
     error_ = bookmark_keys::kNoParentError;
     return false;
   }
   bool can_paste = bookmarks::CanPasteFromClipboard(model, parent_node);
   SetResult(base::MakeUnique<base::FundamentalValue>(can_paste));
   return true;
 }
 
 bool BookmarkManagerPrivateSortChildrenFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
   std::unique_ptr<SortChildren::Params> params(
       SortChildren::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   const BookmarkNode* parent_node = GetNodeFromString(model, params->parent_id);
   if (!CanBeModified(parent_node))
     return false;
   model->SortChildren(parent_node);
   return true;
 }
 
 ExtensionFunction::ResponseAction
 BookmarkManagerPrivateGetStringsFunction::Run() {
   std::unique_ptr<base::DictionaryValue> localized_strings(
@@ skipping 77 matching lines @@
     return false;
 
   if (GetViewType(GetSenderWebContents()) != VIEW_TYPE_TAB_CONTENTS) {
     NOTREACHED();
     return false;
   }
 
   std::unique_ptr<StartDrag::Params> params(StartDrag::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   std::vector<const BookmarkNode*> nodes;
   EXTENSION_FUNCTION_VALIDATE(
       GetNodesFromVector(model, params->id_list, &nodes));
 
   content::WebContents* web_contents = GetAssociatedWebContents();
   CHECK(web_contents);
 
   ui::DragDropTypes::DragEventSource source =
       ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
   if (params->is_from_touch)
     source = ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
 
   chrome::DragBookmarks(
       GetProfile(), nodes, web_contents->GetNativeView(), source);
 
   return true;
 }
 
 bool BookmarkManagerPrivateDropFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
   std::unique_ptr<Drop::Params> params(Drop::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
 
   const BookmarkNode* drop_parent = GetNodeFromString(model, params->parent_id);
   if (!CanBeModified(drop_parent))
     return false;
 
   if (GetViewType(GetSenderWebContents()) != VIEW_TYPE_TAB_CONTENTS) {
     NOTREACHED();
     return false;
   }
 
@@ skipping 26 matching lines @@
 }
 
 bool BookmarkManagerPrivateGetSubtreeFunction::RunOnReady() {
   std::unique_ptr<GetSubtree::Params> params(
       GetSubtree::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const BookmarkNode* node = NULL;
 
   if (params->id.empty()) {
-    BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+    BookmarkModel* model =
+        BookmarkModelFactory::GetForBrowserContext(GetProfile());
     node = model->root_node();
   } else {
     node = GetBookmarkNodeFromId(params->id);
     if (!node)
       return false;
   }
 
   std::vector<api::bookmarks::BookmarkTreeNode> nodes;
   bookmarks::ManagedBookmarkService* managed = GetManagedBookmarkService();
   if (params->folders_only)
@@ skipping 17 matching lines @@
 }
 
 bool BookmarkManagerPrivateCreateWithMetaInfoFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
   std::unique_ptr<CreateWithMetaInfo::Params> params(
       CreateWithMetaInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   const BookmarkNode* node = CreateBookmarkNode(
       model, params->bookmark, &params->meta_info.additional_properties);
   if (!node)
     return false;
 
   api::bookmarks::BookmarkTreeNode result_node =
       bookmark_api_helpers::GetBookmarkTreeNode(GetManagedBookmarkService(),
                                                 node, false, false);
   results_ = CreateWithMetaInfo::Results::Create(result_node);
 
@@ skipping 30 matching lines @@
         }
       }
       results_ = GetMetaInfo::Results::Create(result);
     }
   } else {
     if (params->key) {
       error_ = bookmark_api_constants::kInvalidParamError;
       return true;
     }
 
-    BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+    BookmarkModel* model =
+        BookmarkModelFactory::GetForBrowserContext(GetProfile());
     const BookmarkNode* node = model->root_node();
 
     GetMetaInfo::Results::Value result;
     result.as_object.reset(new GetMetaInfo::Results::Value::Object);
 
     bookmark_api_helpers::GetMetaInfo(*node,
         &result.as_object->additional_properties);
 
     results_ = GetMetaInfo::Results::Create(result);
   }
 
   return true;
 }
 
 bool BookmarkManagerPrivateSetMetaInfoFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
   std::unique_ptr<SetMetaInfo::Params> params(
       SetMetaInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
   if (!node)
     return false;
 
   if (!CanBeModified(node))
     return false;
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   if (model->is_permanent_node(node)) {
     error_ = bookmark_keys::kModifySpecialError;
     return false;
   }
 
   model->SetNodeMetaInfo(node, params->key, params->value);
   return true;
 }
 
 bool BookmarkManagerPrivateUpdateMetaInfoFunction::RunOnReady() {
   if (!EditBookmarksEnabled())
     return false;
 
   std::unique_ptr<UpdateMetaInfo::Params> params(
       UpdateMetaInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const BookmarkNode* node = GetBookmarkNodeFromId(params->id);
   if (!node)
     return false;
 
   if (!CanBeModified(node))
     return false;
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(GetProfile());
+  BookmarkModel* model =
+      BookmarkModelFactory::GetForBrowserContext(GetProfile());
   if (model->is_permanent_node(node)) {
     error_ = bookmark_keys::kModifySpecialError;
     return false;
   }
 
   BookmarkNode::MetaInfoMap new_meta_info(
       params->meta_info_changes.additional_properties);
   if (node->GetMetaInfoMap()) {
     new_meta_info.insert(node->GetMetaInfoMap()->begin(),
                          node->GetMetaInfoMap()->end());
@@ skipping 67 matching lines @@
 
   RedoInfo::Results::Result result;
   result.enabled = undo_manager->redo_count() > 0;
   result.label = base::UTF16ToUTF8(undo_manager->GetRedoLabel());
 
   results_ = RedoInfo::Results::Create(result);
   return true;
 }
 
 }  // namespace extensions