Use BookmarkModelFactory::GetForBrowserContext everywhere

chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_controller_unittest.mm

 // 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 <cmath>
 
 #include "base/mac/scoped_nsobject.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_constants.h"
@@ skipping 18 matching lines @@
 using bookmarks::BookmarkNode;
 
 namespace {
 
 const int kLotsOfNodesCount = 150;
 
 // Deletes the bookmark corresponding to |button|.
 void DeleteBookmark(BookmarkButton* button, Profile* profile) {
   const BookmarkNode* node = [button bookmarkNode];
   if (node) {
-    BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile);
+    BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile);
     model->Remove(node);
   }
 }
 
 }  // namespace
 
 // Add a redirect to make testing easier.
 @interface BookmarkBarFolderController(MakeTestingEasier)
 - (void)validateMenuSpacing;
 @end
@@ skipping 90 matching lines @@
   const BookmarkNode* longTitleNode_;  // Owned by model.
 
   void SetUp() override {
     CocoaProfileTest::SetUp();
     ASSERT_TRUE(profile());
 
     CreateModel();
   }
 
   void CreateModel() {
-    BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+    BookmarkModel* model =
+        BookmarkModelFactory::GetForBrowserContext(profile());
     const BookmarkNode* parent = model->bookmark_bar_node();
     const BookmarkNode* folderA = model->AddFolder(parent,
                                                    parent->child_count(),
                                                    ASCIIToUTF16("folder"));
     folderA_ = folderA;
     model->AddFolder(parent, parent->child_count(),
                      ASCIIToUTF16("sibbling folder"));
     const BookmarkNode* folderB = model->AddFolder(folderA,
                                                    folderA->child_count(),
                                                    ASCIIToUTF16("subfolder 1"));
@@ skipping 21 matching lines @@
                        frame.size.width, chrome::kNTPBookmarkBarHeight);
     NSView* fakeToolbarView = [[[NSView alloc] initWithFrame:frame]
                                 autorelease];
     [[test_window() contentView] addSubview:fakeToolbarView];
     [fakeToolbarView addSubview:[bar_ view]];
     [bar_ setBookmarkBarEnabled:YES];
   }
 
   // Remove the bookmark with the long title.
   void RemoveLongTitleNode() {
-    BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+    BookmarkModel* model =
+        BookmarkModelFactory::GetForBrowserContext(profile());
     model->Remove(longTitleNode_);
   }
 
   // Add LOTS of nodes to our model if needed (e.g. scrolling).
   // Returns the number of nodes added.
   int AddLotsOfNodes() {
-    BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+    BookmarkModel* model =
+        BookmarkModelFactory::GetForBrowserContext(profile());
     for (int i = 0; i < kLotsOfNodesCount; i++) {
       model->AddURL(folderA_, folderA_->child_count(),
                     ASCIIToUTF16("repeated title"),
                     GURL("http://www.google.com/repeated/url"));
     }
     return kLotsOfNodesCount;
   }
 
   // Return a simple BookmarkBarFolderController.
   BookmarkBarFolderControllerPong* SimpleBookmarkBarFolderController() {
@@ skipping 81 matching lines @@
   [bbfc2 window];
   pt = [bbfc2 windowTopLeftForWidth:0 height:100];
   // We're now overlapping the window a bit.
   EXPECT_EQ(pt.x, NSMaxX([[bbfc.get() window] frame]) -
             bookmarks::kBookmarkMenuOverlap);
 }
 
 // Confirm we grow right until end of screen, then start growing left
 // until end of screen again, then right.
 TEST_F(BookmarkBarFolderControllerTest, PositionRightLeftRight) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* parent = model->bookmark_bar_node();
   const BookmarkNode* folder = parent;
 
   const int count = 100;
   int i;
   // Make some super duper deeply nested folders.
   for (i = 0; i < count; i++) {
     folder = model->AddFolder(folder, 0, ASCIIToUTF16("nested folder"));
   }
 
@@ skipping 428 matching lines @@
     [[test_window() contentView] addSubview:parent_view_];
 
     // Make sure it's open so certain things aren't no-ops.
     [bar updateState:BookmarkBar::SHOW
           changeType:BookmarkBar::DONT_ANIMATE_STATE_CHANGE];
   }
 };
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveBarBookmarkToFolder) {
   WithNoAnimation at_all;
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
       "2f2f3b ] 2f3b ] 3b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
@@ skipping 52 matching lines @@
   targetButton = [bar_ buttonWithTitleEqualTo:@"2f"];
   ASSERT_TRUE(targetButton);
   [bar_ dragButton:draggedButton
                 to:[targetButton left]
               copy:NO];
   EXPECT_EQ(model_string, bookmarks::test::ModelStringFromNode(root));
   // Don't check the folder window since it's not supposed to be showing.
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragCopyBarBookmarkToFolder) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
       "2f2f3b ] 2f3b ] 3b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
@@ skipping 43 matching lines @@
   [bar_ dragButton:draggedButton
                 to:[targetButton left]
               copy:YES];
   const std::string expected_2("1b 2f:[ 2f1b 1b 2f2f:[ 2f2f1b "
       "2f2f2b 2f2f3b ] 2f3b ] 3b 1b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ "
       "4f2f1b 4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
   EXPECT_EQ(expected_2, bookmarks::test::ModelStringFromNode(root));
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveBarBookmarkToSubfolder) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
       "2f2f3b ] 2f3b ] 3b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
@@ skipping 44 matching lines @@
   EXPECT_NSRECT_EQ(oldToWindowFrame, newToWindowFrame);
   NSRect newToSubwindowFrame = [toSubwindow frame];
   NSRect expectedToSubwindowFrame = oldToSubwindowFrame;
   expectedToSubwindowFrame.origin.y -= bookmarks::kBookmarkFolderButtonHeight;
   expectedToSubwindowFrame.size.height +=
       bookmarks::kBookmarkFolderButtonHeight;
   EXPECT_NSRECT_EQ(expectedToSubwindowFrame, newToSubwindowFrame);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveWithinFolder) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
       "2f2f3b ] 2f3b ] 3b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
@@ skipping 28 matching lines @@
 
   // The folder window should not have changed.
   NSRect newToWindowFrame = [toWindow frame];
   EXPECT_NSRECT_EQ(oldToWindowFrame, newToWindowFrame);
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragParentOntoChild) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
       "2f2f3b ] 2f3b ] 3b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
@@ skipping 16 matching lines @@
                             to:[targetButton top]
                           copy:NO];
   // The model should not have changed.
   EXPECT_EQ(model_string, bookmarks::test::ModelStringFromNode(root));
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveChildToParent) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
       "2f2f3b ] 2f3b ] 3b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
@@ skipping 31 matching lines @@
 
   // Check button spacing.
   [folderController validateMenuSpacing];
   // The window should not have gone away.
   EXPECT_TRUE([bar_ folderController]);
   // The subfolder should have gone away.
   EXPECT_FALSE([folderController folderController]);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragWindowResizing) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string(
       "a b:[ b1 b2 b3 ] reallyReallyLongBookmarkName c ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Pop up a folder menu.
@@ skipping 19 matching lines @@
   // Verify the model change.
   const std::string expected_string(
       "a b:[ b1 reallyReallyLongBookmarkName b2 b3 ] c ");
   EXPECT_EQ(expected_string, bookmarks::test::ModelStringFromNode(root));
   // Verify the window grew. Just test a reasonable width gain.
   CGFloat newWidth = NSWidth([toWindow frame]);
   EXPECT_LT(oldWidth + 30.0, newWidth);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, MoveRemoveAddButtons) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b 2f3b ] 3b 4b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Pop up a folder menu.
   BookmarkButton* toFolder = [bar_ buttonWithTitleEqualTo:@"2f"];
@@ skipping 42 matching lines @@
   EXPECT_NSEQ(@"3b", [[buttons objectAtIndex:0] title]);
   EXPECT_NSEQ(@"2f2b", [[buttons objectAtIndex:1] title]);
   EXPECT_NSEQ(@"2f3b", [[buttons objectAtIndex:2] title]);
   EXPECT_EQ(oldDisplayedButtons, [buttons count]);
 
   // Check button spacing.
   [folder validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, RemoveLastButtonOtherBookmarks) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* otherBookmarks = model->other_node();
 
   BookmarkButton* otherButton = [bar_ otherBookmarksButton];
   ASSERT_TRUE(otherButton);
 
   // Open the folder to get the folderController_.
   [[otherButton target] openBookmarkFolderFromButton:otherButton];
   BookmarkBarFolderController* folder = [bar_ folderController];
   EXPECT_TRUE(folder);
 
@@ skipping 16 matching lines @@
   // is hidden.
   [folder removeButton:0 animate:NO];
   EXPECT_EQ(0U, [buttons count]);
 
   // 'Other bookmarks' folder gets closed once we remove the last button. Hence
   // folderController_ should be NULL.
   EXPECT_FALSE([bar_ folderController]);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, ControllerForNode) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b ] 3b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Find the main bar controller.
   const void* expectedController = bar_;
@@ skipping 14 matching lines @@
   expectedController = folder;
   actualController = [bar_ controllerForNode:targetNode];
   EXPECT_EQ(expectedController, actualController);
 
   // Find the folder controller from the bar.
   actualController = [folder controllerForNode:targetNode];
   EXPECT_EQ(expectedController, actualController);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, MenuSizingAndScrollArrows) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2b 3b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   const BookmarkNode* parent = model->bookmark_bar_node();
   const BookmarkNode* folder = model->AddFolder(parent,
@@ skipping 76 matching lines @@
   // Check the size. It should have reduced.
   EXPECT_GT(scrollerWidth, NSWidth([folderView frame]));
   EXPECT_GT(buttonWidth, NSWidth([button frame]));
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 // See http://crbug.com/46101
 TEST_F(BookmarkBarFolderControllerMenuTest, HoverThenDeleteBookmark) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const BookmarkNode* folder = model->AddFolder(root,
                                                 root->child_count(),
                                                 ASCIIToUTF16("BIG"));
   for (int i = 0; i < kLotsOfNodesCount; i++)
     model->AddURL(folder, folder->child_count(), ASCIIToUTF16("kid"),
                   GURL("http://kid.com/smile"));
 
   // Pop open the new folder window and hover one of its kids.
   BookmarkButton* button = [bar_ buttonWithTitleEqualTo:@"BIG"];
@@ skipping 47 matching lines @@
   std::vector<const BookmarkNode*> dragDataNodes;
   if(dragDataNode_) {
     dragDataNodes.push_back(dragDataNode_);
   }
   return dragDataNodes;
 }
 
 @end
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragBookmarkData) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                                  "2f3b ] 3b 4b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
   const BookmarkNode* other = model->other_node();
   const std::string other_string("O1b O2b O3f:[ O3f1b O3f2f ] "
                                  "O4f:[ O4f1b O4f2f ] 05b ");
   bookmarks::test::AddNodesFromModelString(model, other, other_string);
 
   // Validate initial model.
@@ skipping 41 matching lines @@
                               "2f2f1b 2f2f2b 2f2f3b O4f:[ O4f1b O4f2f ] ] "
                               "2f3b ] 3b 4b ");
   actual = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(expectedA, actual);
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragBookmarkDataToTrash) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                                  "2f3b ] 3b 4b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actual = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actual);
 
   const BookmarkNode* folderNode = root->GetChild(1);
@@ skipping 22 matching lines @@
   const std::string expected("1b 2f:[ 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                              "2f3b ] 3b 4b ");
   actual = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, AddURLs) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                                  "2f3b ] 3b 4b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actual = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actual);
 
   // Pop open a folder.
@@ skipping 24 matching lines @@
   const std::string expected("1b 2f:[ SiteA SiteB 2f1b 2f2f:[ 2f2f1b 2f2f2b "
                              "2f2f3b ] 2f3b ] 3b 4b ");
   actual = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DropPositionIndicator) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                                  "2f3b ] 3b 4b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actual = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actual);
 
   // Pop open the folder.
@@ skipping 39 matching lines @@
 
     bar_.reset([[BookmarkBarControllerNoDelete alloc]
         initWithBrowser:browser()
            initialWidth:NSWidth([parent_view_ frame])
                delegate:nil]);
     InstallAndToggleBar(bar_.get());
   }
 };
 
 TEST_F(BookmarkBarFolderControllerClosingTest, DeleteClosesFolder) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b ] "
                                  "2f3b ] 3b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Open the folder menu and submenu.
@@ skipping 15 matching lines @@
   DeleteBookmark([folder parentButton], profile());
   EXPECT_FALSE([folder folderController]);
 }
 
 // TODO(jrg): draggingEntered: and draggingExited: trigger timers so
 // they are hard to test.  Factor out "fire timers" into routines
 // which can be overridden to fire immediately to make behavior
 // confirmable.
 // There is a similar problem with mouseEnteredButton: and
 // mouseExitedButton:.