Use BookmarkModelFactory::GetForBrowserContext everywhere

chrome/browser/ui/cocoa/bookmarks/bookmark_bar_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.
 
 #import <Cocoa/Cocoa.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/mac/mac_util.h"
@@ skipping 505 matching lines @@
   [[NSNotificationCenter defaultCenter]
     postNotificationName:NSViewFrameDidChangeNotification
                   object:[bar view]];
 
   EXPECT_GT([bar toggles], 0);
 }
 
 // Confirm our "no items" container goes away when we add the 1st
 // bookmark, and comes back when we delete the bookmark.
 TEST_F(BookmarkBarControllerTest, NoItemContainerGoesAway) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* bar = model->bookmark_bar_node();
 
   [bar_ loaded:model];
   BookmarkBarView* view = [bar_ buttonView];
   DCHECK(view);
   NSView* noItemContainer = [view noItemContainer];
   DCHECK(noItemContainer);
 
   EXPECT_FALSE([noItemContainer isHidden]);
   const BookmarkNode* node = model->AddURL(bar, bar->child_count(),
@@ skipping 12 matching lines @@
   // Move it from Other Bookmarks to the bar.
   model->Move(node, bar, 0);
   EXPECT_TRUE([noItemContainer isHidden]);
   // Move it back to Other Bookmarks from the bar.
   model->Move(node, otherBookmarks, 0);
   EXPECT_FALSE([noItemContainer isHidden]);
 }
 
 // Confirm off the side button only enabled when reasonable.
 TEST_F(BookmarkBarControllerTest, OffTheSideButtonHidden) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
 
   [bar_ loaded:model];
   EXPECT_TRUE([bar_ offTheSideButtonIsHidden]);
 
   for (int i = 0; i < 2; i++) {
     bookmarks::AddIfNotBookmarked(
         model, GURL("http://www.foo.com"), ASCIIToUTF16("small"));
     EXPECT_TRUE([bar_ offTheSideButtonIsHidden]);
   }
 
@@ skipping 28 matching lines @@
     } else {
       EXPECT_TRUE([bar_ folderController]);
     }
   }
 }
 
 // http://crbug.com/46175 is a crash when deleting bookmarks from the
 // off-the-side menu while it is open.  This test tries to bang hard
 // in this area to reproduce the crash.
 TEST_F(BookmarkBarControllerTest, DeleteFromOffTheSideWhileItIsOpen) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   [bar_ loaded:model];
 
   // Add a lot of bookmarks (per the bug).
   const BookmarkNode* parent = model->bookmark_bar_node();
   for (int i = 0; i < 100; i++) {
     std::ostringstream title;
     title << "super duper wide title " << i;
     model->AddURL(parent, parent->child_count(), ASCIIToUTF16(title.str()),
                   GURL("http://superfriends.hall-of-justice.edu"));
   }
@@ skipping 61 matching lines @@
   }
 
   // Confirm uniqueness.
   std::sort(tags.begin(), tags.end());
   for (unsigned int i=0; i<(tags.size()-1); i++) {
     EXPECT_NE(tags[i], tags[i+1]);
   }
 }
 
 TEST_F(BookmarkBarControllerTest, MenuForFolderNode) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
 
   // First make sure something (e.g. "(empty)" string) is always present.
   NSMenu* menu = [bar_ menuForFolderNode:model->bookmark_bar_node()];
   EXPECT_GT([menu numberOfItems], 0);
 
   // Test two bookmarks.
   GURL gurl("http://www.foo.com");
   bookmarks::AddIfNotBookmarked(model, gurl, ASCIIToUTF16("small"));
   bookmarks::AddIfNotBookmarked(
       model, GURL("http://www.cnn.com"), ASCIIToUTF16("bigger title"));
@@ skipping 43 matching lines @@
   base::scoped_nsobject<BookmarkButton> button([[BookmarkButton alloc] init]);
   [button setCell:cell.get()];
   [cell setRepresentedObject:[NSValue valueWithPointer:node.get()]];
 
   [bar_ openBookmark:button];
   EXPECT_EQ(noOpenBar()->urls_[0], node->url());
   EXPECT_EQ(noOpenBar()->dispositions_[0], CURRENT_TAB);
 }
 
 TEST_F(BookmarkBarControllerTest, TestAddRemoveAndClear) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   NSView* buttonView = [bar_ buttonView];
   EXPECT_EQ(0U, [[bar_ buttons] count]);
   unsigned int initial_subview_count = [[buttonView subviews] count];
 
   // Make sure a redundant call doesn't choke
   [bar_ clearBookmarkBar];
   EXPECT_EQ(0U, [[bar_ buttons] count]);
   EXPECT_EQ(initial_subview_count, [[buttonView subviews] count]);
 
   GURL gurl1("http://superfriends.hall-of-justice.edu");
@@ skipping 29 matching lines @@
 
   // Explicit test of loaded: since this is a convenient spot
   [bar_ loaded:model];
   EXPECT_EQ(2U, [[bar_ buttons] count]);
   EXPECT_EQ(2+initial_subview_count, [[buttonView subviews] count]);
 }
 
 // Make sure we don't create too many buttons; we only really need
 // ones that will be visible.
 TEST_F(BookmarkBarControllerTest, TestButtonLimits) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   EXPECT_EQ(0U, [[bar_ buttons] count]);
   // Add one; make sure we see it.
   const BookmarkNode* parent = model->bookmark_bar_node();
   model->AddURL(parent, parent->child_count(),
                 ASCIIToUTF16("title"), GURL("http://www.google.com"));
   EXPECT_EQ(1U, [[bar_ buttons] count]);
 
   // Add 30 which we expect to be 'too many'.  Make sure we don't see
   // 30 buttons.
   model->Remove(parent->GetChild(0));
@@ skipping 39 matching lines @@
   for (unsigned int i = 0; i < arraysize(widths); i++) {
     NSRect r = [bar_ frameForBookmarkButtonFromCell:[cells objectAtIndex:i]
                                             xOffset:&x_offset];
     EXPECT_GE(r.origin.x, x_end);
     x_end = NSMaxX(r);
   }
 }
 
 TEST_F(BookmarkBarControllerTest, CheckForGrowth) {
   WithNoAnimation at_all; // Turn off Cocoa auto animation in this scope.
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   GURL gurl1("http://www.google.com");
   base::string16 title1(ASCIIToUTF16("x"));
   bookmarks::AddIfNotBookmarked(model, gurl1, title1);
 
   GURL gurl2("http://www.google.com/blah");
   base::string16 title2(ASCIIToUTF16("y"));
   bookmarks::AddIfNotBookmarked(model, gurl2, title2);
 
   EXPECT_EQ(2U, [[bar_ buttons] count]);
   CGFloat width_1 = [[[bar_ buttons] objectAtIndex:0] frame].size.width;
   CGFloat x_2 = [[[bar_ buttons] objectAtIndex:1] frame].origin.x;
 
   NSButton* first = [[bar_ buttons] objectAtIndex:0];
   [[first cell] setTitle:@"This is a really big title; watch out mom!"];
   [bar_ checkForBookmarkButtonGrowth:first];
 
   // Make sure the 1st button is now wider, the 2nd one is moved over,
   // and they don't overlap.
   NSRect frame_1 = [[[bar_ buttons] objectAtIndex:0] frame];
   NSRect frame_2 = [[[bar_ buttons] objectAtIndex:1] frame];
   EXPECT_GT(frame_1.size.width, width_1);
   EXPECT_GT(frame_2.origin.x, x_2);
   EXPECT_GE(frame_2.origin.x, frame_1.origin.x + frame_1.size.width);
 }
 
 TEST_F(BookmarkBarControllerTest, DeleteBookmark) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
 
   const char* urls[] = { "https://secret.url.com",
                          "http://super.duper.web.site.for.doodz.gov",
                          "http://www.foo-bar-baz.com/" };
   const BookmarkNode* parent = model->bookmark_bar_node();
   for (unsigned int i = 0; i < arraysize(urls); i++) {
     model->AddURL(parent, parent->child_count(),
                   ASCIIToUTF16("title"), GURL(urls[i]));
   }
   EXPECT_EQ(3, parent->child_count());
   const BookmarkNode* middle_node = parent->GetChild(1);
   model->Remove(middle_node);
 
   EXPECT_EQ(2, parent->child_count());
   EXPECT_EQ(parent->GetChild(0)->url(), GURL(urls[0]));
   // node 2 moved into spot 1
   EXPECT_EQ(parent->GetChild(1)->url(), GURL(urls[2]));
 }
 
 // TODO(jrg): write a test to confirm that nodeFaviconLoaded calls
 // checkForBookmarkButtonGrowth:.
 
 TEST_F(BookmarkBarControllerTest, Cell) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   [bar_ loaded:model];
 
   const BookmarkNode* parent = model->bookmark_bar_node();
   model->AddURL(parent, parent->child_count(),
                 ASCIIToUTF16("supertitle"),
                 GURL("http://superfriends.hall-of-justice.edu"));
   const BookmarkNode* node = parent->GetChild(0);
 
   NSCell* cell = [bar_ cellForBookmarkNode:node];
   EXPECT_TRUE(cell);
@@ skipping 11 matching lines @@
 }
 
 // Test drawing, mostly to ensure nothing leaks or crashes.
 TEST_F(BookmarkBarControllerTest, Display) {
   [[bar_ view] display];
 }
 
 // Test that middle clicking on a bookmark button results in an open action,
 // except for offTheSideButton, as it just opens its folder menu.
 TEST_F(BookmarkBarControllerTest, MiddleClick) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   GURL gurl1("http://www.google.com/");
   base::string16 title1(ASCIIToUTF16("x"));
   bookmarks::AddIfNotBookmarked(model, gurl1, title1);
 
   EXPECT_EQ(1U, [[bar_ buttons] count]);
   NSButton* first = [[bar_ buttons] objectAtIndex:0];
   EXPECT_TRUE(first);
 
   [first otherMouseUp:
       cocoa_test_event_utils::MouseEventWithType(NSOtherMouseUp, 0)];
@@ skipping 25 matching lines @@
   EXPECT_TRUE([bbfc parentButton] == offTheSideButton);
 
   // Middle clicking again on it should close the folder.
   [offTheSideButton otherMouseUp:
       cocoa_test_event_utils::MouseEventWithType(NSOtherMouseUp, 0)];
   bbfc = [bar_ folderController];
   EXPECT_FALSE(bbfc);
 }
 
 TEST_F(BookmarkBarControllerTest, DisplaysHelpMessageOnEmpty) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   [bar_ loaded:model];
   EXPECT_FALSE([[[bar_ buttonView] noItemContainer] isHidden]);
 }
 
 TEST_F(BookmarkBarControllerTest, HidesHelpMessageWithBookmark) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
 
   const BookmarkNode* parent = model->bookmark_bar_node();
   model->AddURL(parent, parent->child_count(),
                 ASCIIToUTF16("title"), GURL("http://one.com"));
 
   [bar_ loaded:model];
   EXPECT_TRUE([[[bar_ buttonView] noItemContainer] isHidden]);
 }
 
 TEST_F(BookmarkBarControllerTest, BookmarkButtonSizing) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
 
   const BookmarkNode* parent = model->bookmark_bar_node();
   model->AddURL(parent, parent->child_count(),
                 ASCIIToUTF16("title"), GURL("http://one.com"));
 
   [bar_ loaded:model];
 
   // Make sure the internal bookmark button also is the correct height.
   NSArray* buttons = [bar_ buttons];
   EXPECT_GT([buttons count], 0u);
@@ skipping 30 matching lines @@
   };
   EXPECT_EQ(arraysize(urls), arraysize(titles));
 
   NSMutableArray* nsurls = [NSMutableArray array];
   NSMutableArray* nstitles = [NSMutableArray array];
   for (size_t i = 0; i < arraysize(urls); ++i) {
     [nsurls addObject:base::SysUTF8ToNSString(urls[i])];
     [nstitles addObject:base::SysUTF8ToNSString(titles[i])];
   }
 
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* parent = model->bookmark_bar_node();
   [bar_ addURLs:nsurls withTitles:nstitles at:NSZeroPoint];
   EXPECT_EQ(4, parent->child_count());
   for (int i = 0; i < parent->child_count(); ++i) {
     GURL gurl = parent->GetChild(i)->url();
     if (gurl.scheme() == "http" ||
         gurl.scheme() == "javascript") {
       EXPECT_EQ(parent->GetChild(i)->url(), GURL(urls[i]));
     } else {
       // Be flexible if the scheme needed to be added.
       std::string gurl_string = gurl.spec();
       std::string my_string = parent->GetChild(i)->url().spec();
       EXPECT_NE(gurl_string.find(my_string), std::string::npos);
     }
     EXPECT_EQ(parent->GetChild(i)->GetTitle(), ASCIIToUTF16(titles[i]));
   }
 }
 
 TEST_F(BookmarkBarControllerTest, TestDragButton) {
   WithNoAnimation at_all;
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
 
   GURL gurls[] = { GURL("http://www.google.com/a"),
                    GURL("http://www.google.com/b"),
                    GURL("http://www.google.com/c") };
   base::string16 titles[] = { ASCIIToUTF16("a"),
                               ASCIIToUTF16("b"),
                               ASCIIToUTF16("c") };
   for (unsigned i = 0; i < arraysize(titles); i++)
     bookmarks::AddIfNotBookmarked(model, gurls[i], titles[i]);
 
@@ skipping 51 matching lines @@
               copy:NO];
   // Gone from the bar
   EXPECT_EQ(arraysize(titles), [[bar_ buttons] count]);
   // In the folder
   EXPECT_EQ(2, folder->child_count());
   // At the end
   EXPECT_EQ(title, folder->GetChild(1)->GetTitle());
 }
 
 TEST_F(BookmarkBarControllerTest, TestCopyButton) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
 
   GURL gurls[] = { GURL("http://www.google.com/a"),
                    GURL("http://www.google.com/b"),
                    GURL("http://www.google.com/c") };
   base::string16 titles[] = { ASCIIToUTF16("a"),
                               ASCIIToUTF16("b"),
                               ASCIIToUTF16("c") };
   for (unsigned i = 0; i < arraysize(titles); i++)
     bookmarks::AddIfNotBookmarked(model, gurls[i], titles[i]);
 
   EXPECT_EQ([[bar_ buttons] count], arraysize(titles));
   EXPECT_NSEQ(@"a", [[[bar_ buttons] objectAtIndex:0] title]);
 
   // Drag 'a' between 'b' and 'c'.
   CGFloat x = NSMinX([[[bar_ buttons] objectAtIndex:2] frame]);
   x += [[bar_ view] frame].origin.x;
   [bar_ dragButton:[[bar_ buttons] objectAtIndex:0]
                 to:NSMakePoint(x, 0)
               copy:YES];
   EXPECT_NSEQ(@"a", [[[bar_ buttons] objectAtIndex:0] title]);
   EXPECT_NSEQ(@"b", [[[bar_ buttons] objectAtIndex:1] title]);
   EXPECT_NSEQ(@"a", [[[bar_ buttons] objectAtIndex:2] title]);
   EXPECT_NSEQ(@"c", [[[bar_ buttons] objectAtIndex:3] title]);
   EXPECT_EQ([[bar_ buttons] count], 4U);
 }
 
 // Fake a theme with colored text.  Apply it and make sure bookmark
 // buttons have the same colored text.  Repeat more than once.
 TEST_F(BookmarkBarControllerTest, TestThemedButton) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   bookmarks::AddIfNotBookmarked(
       model, GURL("http://www.foo.com"), ASCIIToUTF16("small"));
   BookmarkButton* button = [[bar_ buttons] objectAtIndex:0];
   EXPECT_TRUE(button);
 
   NSArray* colors = [NSArray arrayWithObjects:[NSColor redColor],
                                               [NSColor blueColor],
                                               nil];
   for (NSColor* color in colors) {
     FakeTheme theme(color);
     [bar_ updateTheme:&theme];
     NSAttributedString* astr = [button attributedTitle];
     EXPECT_TRUE(astr);
     EXPECT_NSEQ(@"small", [astr string]);
     // Pick a char in the middle to test (index 3)
     NSDictionary* attributes = [astr attributesAtIndex:3 effectiveRange:NULL];
     NSColor* newColor =
         [attributes objectForKey:NSForegroundColorAttributeName];
     EXPECT_NSEQ(newColor, color);
   }
 }
 
 // Test that delegates and targets of buttons are cleared on dealloc.
 TEST_F(BookmarkBarControllerTest, TestClearOnDealloc) {
   // Make some bookmark buttons.
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   GURL gurls[] = { GURL("http://www.foo.com/"),
                    GURL("http://www.bar.com/"),
                    GURL("http://www.baz.com/") };
   base::string16 titles[] = { ASCIIToUTF16("a"),
                               ASCIIToUTF16("b"),
                               ASCIIToUTF16("c") };
   for (size_t i = 0; i < arraysize(titles); i++)
     bookmarks::AddIfNotBookmarked(model, gurls[i], titles[i]);
 
   // Get and retain the buttons so we can examine them after dealloc.
@@ skipping 14 matching lines @@
 
   // Make sure that everything is cleared.
   for (BookmarkButton* button in buttons.get()) {
     EXPECT_FALSE([button delegate]);
     EXPECT_FALSE([button target]);
     EXPECT_FALSE([button action]);
   }
 }
 
 TEST_F(BookmarkBarControllerTest, TestFolders) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
 
   // Create some folder buttons.
   const BookmarkNode* parent = model->bookmark_bar_node();
   const BookmarkNode* folder = model->AddFolder(parent,
                                                 parent->child_count(),
                                                 ASCIIToUTF16("folder"));
   model->AddURL(folder, folder->child_count(),
                 ASCIIToUTF16("f1"), GURL("http://framma-lamma.com"));
   folder = model->AddFolder(parent, parent->child_count(),
                             ASCIIToUTF16("empty"));
@@ skipping 23 matching lines @@
 
   // Clean up.
   [bar_ closeBookmarkFolder:nil];
 }
 
 // Verify that the folder menu presentation properly tracks mouse movements
 // over the bar. Until there is a click no folder menus should show. After a
 // click on a folder folder menus should show until another click on a folder
 // button, and a click outside the bar and its folder menus.
 TEST_F(BookmarkBarControllerTest, TestFolderButtons) {
-  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 4f:[ 4f1b 4f2b ] ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model and that we do not have a folder controller.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
   EXPECT_FALSE([bar_ folderController]);
 
   // Add a real bookmark so we can click on it.
@@ skipping 43 matching lines @@
 }
 
 // Make sure the "off the side" folder looks like a bookmark folder
 // but only contains "off the side" items.
 TEST_F(BookmarkBarControllerTest, OffTheSideFolder) {
 
   // It starts hidden.
   EXPECT_TRUE([bar_ offTheSideButtonIsHidden]);
 
   // Create some buttons.
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* parent = model->bookmark_bar_node();
   for (int x = 0; x < 30; x++) {
     model->AddURL(parent, parent->child_count(),
                   ASCIIToUTF16("medium-size-title"),
                   GURL("http://framma-lamma.com"));
   }
   // Add a couple more so we can delete one and make sure its button goes away.
   model->AddURL(parent, parent->child_count(),
                 ASCIIToUTF16("DELETE_ME"), GURL("http://ashton-tate.com"));
   model->AddURL(parent, parent->child_count(),
@@ skipping 58 matching lines @@
         charactersIgnoringModifiers:@"x"
                           isARepeat:NO
                             keyCode:87];
   EXPECT_FALSE([bar_ isEventAnExitEvent:event]);
 
   [[[bar_ view] window] removeChildWindow:folderWindow];
 }
 
 TEST_F(BookmarkBarControllerTest, DropDestination) {
   // Make some buttons.
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* parent = model->bookmark_bar_node();
   model->AddFolder(parent, parent->child_count(), ASCIIToUTF16("folder 1"));
   model->AddFolder(parent, parent->child_count(), ASCIIToUTF16("folder 2"));
   EXPECT_EQ([[bar_ buttons] count], 2U);
 
   // Confirm "off to left" and "off to right" match nothing.
   NSPoint p = NSMakePoint(-1, 2);
   EXPECT_FALSE([bar_ buttonForDroppingOnAtPoint:p]);
   EXPECT_TRUE([bar_ shouldShowIndicatorShownForPoint:p]);
   p = NSMakePoint(50000, 10);
@@ skipping 17 matching lines @@
     x = NSMinX([button frame]) + viewFrameXOffset;
     EXPECT_NE(button,
               [bar_ buttonForDroppingOnAtPoint:NSMakePoint(x, 9)]);
     x = NSMaxX([button frame]) + viewFrameXOffset;
     EXPECT_NE(button,
               [bar_ buttonForDroppingOnAtPoint:NSMakePoint(x, 11)]);
   }
 }
 
 TEST_F(BookmarkBarControllerTest, CloseFolderOnAnimate) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   [bar_ setStateAnimationsEnabled:YES];
   const BookmarkNode* parent = model->bookmark_bar_node();
   const BookmarkNode* folder = model->AddFolder(parent,
                                                 parent->child_count(),
                                                 ASCIIToUTF16("folder"));
   model->AddFolder(parent, parent->child_count(),
                   ASCIIToUTF16("sibbling folder"));
   model->AddURL(folder, folder->child_count(), ASCIIToUTF16("title a"),
                 GURL("http://www.google.com/a"));
   model->AddURL(folder, folder->child_count(),
@@ skipping 17 matching lines @@
   // should have been closed thus releasing the folderController.
   EXPECT_FALSE([bar_ folderController]);
 
   // Stop the pending animation to tear down cleanly.
   [bar_ updateState:BookmarkBar::DETACHED
          changeType:BookmarkBar::DONT_ANIMATE_STATE_CHANGE];
   EXPECT_FALSE([bar_ isAnimationRunning]);
 }
 
 TEST_F(BookmarkBarControllerTest, 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 ] 3b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Remember how many buttons are showing.
   int oldDisplayedButtons = [bar_ displayedButtonCount];
@@ skipping 61 matching lines @@
 // Simiulate browser window width change and ensure that the bookmark buttons
 // that should be visible are visible.
 // Appears to fail on Mac 10.11 bot on the waterfall; http://crbug.com/612640.
 TEST_F(BookmarkBarControllerTest, DISABLED_LastBookmarkResizeBehavior) {
   // Hide the apps shortcut.
   profile()->GetPrefs()->SetBoolean(
       bookmarks::prefs::kShowAppsShortcutInBookmarkBar, false);
   ASSERT_TRUE([bar_ appsPageShortcutButtonIsHidden]);
 
   // Add three buttons to the bookmark bar.
-  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);
   [bar_ frameDidChange];
 
   // Step through simulated window resizings. In resizing from the first width
   // to the second, the bookmark bar should transition from displaying one
   // button to two. Of the next 5 widths, the third transitions the bar from
   // displaying two buttons to three. The next width (200.0) resizes the bar to
   // a large width that does not change the number of visible buttons, and the
@@ skipping 58 matching lines @@
     NSRect frame = [[bar_ view] frame];
     frame.size.width = view_widths[i] + bookmarks::BookmarkRightMargin();
     [[bar_ view] setFrame:frame];
     EXPECT_EQ(off_the_side_button_is_hidden_results[i],
               [bar_ offTheSideButtonIsHidden]);
     EXPECT_EQ(displayed_button_count_results[i], [bar_ displayedButtonCount]);
   }
 }
 
 TEST_F(BookmarkBarControllerTest, BookmarksWithAppsPageShortcut) {
-  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);
   [bar_ frameDidChange];
 
   // Apps page shortcut button should be visible.
   ASSERT_FALSE([bar_ appsPageShortcutButtonIsHidden]);
 
   // Bookmarks should be to the right of the Apps page shortcut button.
   CGFloat apps_button_right = NSMaxX([[bar_ appsPageShortcutButton] frame]);
@@ skipping 66 matching lines @@
            initialWidth:NSWidth(parent_frame)
                delegate:nil]);
     // Forces loading of the nib.
     [[bar_ controlledView] setResizeDelegate:resizeDelegate_];
     // Awkwardness to look like we've been installed.
     [parent_view_ addSubview:[bar_ view]];
     NSRect frame = [[[bar_ view] superview] frame];
     frame.origin.y = 100;
     [[[bar_ view] superview] setFrame:frame];
 
-    BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+    BookmarkModel* model =
+        BookmarkModelFactory::GetForBrowserContext(profile());
     parent_ = model->bookmark_bar_node();
     // { one, { two-one, two-two }, three }
     model->AddURL(parent_, parent_->child_count(), ASCIIToUTF16("title"),
                   GURL("http://one.com"));
     folder_ = model->AddFolder(parent_, parent_->child_count(),
                                ASCIIToUTF16("folder"));
     model->AddURL(folder_, folder_->child_count(),
                   ASCIIToUTF16("title"), GURL("http://two-one.com"));
     model->AddURL(folder_, folder_->child_count(),
                   ASCIIToUTF16("title"), GURL("http://two-two.com"));
@@ skipping 104 matching lines @@
 
     bar_.reset([[BookmarkBarControllerDragData alloc]
         initWithBrowser:browser()
            initialWidth:NSWidth([parent_view_ frame])
                delegate:nil]);
     InstallAndToggleBar(bar_.get());
   }
 };
 
 TEST_F(BookmarkBarControllerDragDropTest, DragMoveBarBookmarkToOffTheSide) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1bWithLongName 2fWithLongName:[ "
       "2f1bWithLongName 2f2fWithLongName:[ 2f2f1bWithLongName "
       "2f2f2bWithLongName 2f2f3bWithLongName 2f4b ] 2f3bWithLongName ] "
       "3bWithLongName 4bWithLongName 5bWithLongName 6bWithLongName "
       "7bWithLongName 8bWithLongName 9bWithLongName 10bWithLongName "
       "11bWithLongName 12bWithLongName 13b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
@@ skipping 31 matching lines @@
   int newDisplayedButtons = [bar_ displayedButtonCount];
   int newChildCount = root->child_count();
   int newOTSCount = (int)[[otsController buttons] count];
   EXPECT_EQ(oldDisplayedButtons, newDisplayedButtons);
   EXPECT_EQ(oldChildCount + 1, newChildCount);
   EXPECT_EQ(oldOTSCount + 1, newOTSCount);
   EXPECT_EQ(newOTSCount, newChildCount - newDisplayedButtons);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, DragOffTheSideToOther) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1bWithLongName 2bWithLongName "
       "3bWithLongName 4bWithLongName 5bWithLongName 6bWithLongName "
       "7bWithLongName 8bWithLongName 9bWithLongName 10bWithLongName "
       "11bWithLongName 12bWithLongName 13bWithLongName 14bWithLongName "
       "15bWithLongName 16bWithLongName 17bWithLongName 18bWithLongName "
       "19bWithLongName 20bWithLongName ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   const BookmarkNode* other = model->other_node();
@@ skipping 36 matching lines @@
   // and one more in other bookmarks.
   int newRootCount = root->child_count();
   int newOTSCount = (int)[[otsController buttons] count];
   int newOtherCount = other->child_count();
   EXPECT_EQ(oldRootCount - 1, newRootCount);
   EXPECT_EQ(oldOTSCount - 1, newOTSCount);
   EXPECT_EQ(oldOtherCount + 1, newOtherCount);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, 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 39 matching lines @@
   EXPECT_EQ(oldChildCount, newChildCount);
   // Verify the model.
   const std::string expected1("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                               "2f3b O4f:[ O4f1b O4f2f ] ] O3f:[ O3f1b O3f2f ] "
                               "3b 4b ");
   actual = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(expected1, actual);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, 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);
 
   // Remember the children.
@@ skipping 11 matching lines @@
   int newChildCount = root->child_count();
   EXPECT_EQ(oldChildCount + 2, newChildCount);
   // Verify the model.
   const std::string expected("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                              "2f3b ] SiteA SiteB 3b 4b ");
   actual = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, 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_;
   const void* actualController = [bar_ controllerForNode:root];
   EXPECT_EQ(expectedController, actualController);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, 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 2f2b 2f3b ] 3b 4b ");
   bookmarks::test::AddNodesFromModelString(model, root, model_string);
 
   // Hide the apps shortcut.
   profile()->GetPrefs()->SetBoolean(
       bookmarks::prefs::kShowAppsShortcutInBookmarkBar, false);
   ASSERT_TRUE([bar_ appsPageShortcutButtonIsHidden]);
 
   // Validate initial model.
@@ skipping 18 matching lines @@
   targetButton = [bar_ buttonWithTitleEqualTo:@"4b"];
   targetPoint = [targetButton right];
   targetPoint.x += 100;  // Somewhere off to the right.
   CGFloat xDelta = 0.5 * bookmarks::BookmarkHorizontalPadding();
   expected = NSMaxX([targetButton frame]) + xDelta;
   actual = [bar_ indicatorPosForDragToPoint:targetPoint];
   EXPECT_CGFLOAT_EQ(expected, actual);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, PulseButton) {
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
+  BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   GURL gurl("http://www.google.com");
   const BookmarkNode* node = model->AddURL(root, root->child_count(),
                                            ASCIIToUTF16("title"), gurl);
 
   BookmarkButton* button = [[bar_ buttons] objectAtIndex:0];
   EXPECT_FALSE([button isContinuousPulsing]);
   [bar_ startPulsingBookmarkNode:node];
   EXPECT_TRUE([button isContinuousPulsing]);
   [bar_ stopPulsingBookmarkNode];
@@ skipping 23 matching lines @@
   // Removing a pulsing folder is allowed.
   [bar_ startPulsingBookmarkNode:inner];
   BookmarkButton* folder2_button = [[bar_ buttons] objectAtIndex:2];
   EXPECT_TRUE([folder2_button isContinuousPulsing]);
   model->Remove(folder2);
   EXPECT_FALSE([folder2_button isContinuousPulsing]);
   [bar_ stopPulsingBookmarkNode];  // Should not crash.
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, 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);
 
   int oldChildCount = root->child_count();
@@ skipping 12 matching lines @@
                              "2f3b ] 4b ");
   actual = bookmarks::test::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 
   // Verify that the other bookmark folder can't be deleted.
   BookmarkButton *otherButton = [bar_ otherBookmarksButton];
   EXPECT_FALSE([bar_ canDragBookmarkButtonToTrash:otherButton]);
 }
 
 }  // namespace