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

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 "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_nsobject.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #import "chrome/browser/ui/cocoa/animation_utils.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_constants.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_window.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_unittest_helper.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_view.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_button.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_button_cell.h"
@@ skipping 309 matching lines @@
     menu_item_.reset([[NSMenuItem alloc]
                        initWithTitle:@"still_dont_care"
                               action:NULL
                        keyEquivalent:@""]);
     cell_.reset([[NSButtonCell alloc] init]);
     [menu_item_ setMenu:menu_.get()];
   }
 
   // Return a menu item that points to the given URL.
   NSMenuItem* ItemForBookmarkBarMenu(GURL& gurl) {
-    BookmarkModel* model = profile()->GetBookmarkModel();
+    BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
     const BookmarkNode* parent = model->bookmark_bar_node();
     const BookmarkNode* node = model->AddURL(parent, parent->child_count(),
                                              ASCIIToUTF16("A title"), gurl);
     [menu_ setRepresentedObject:[NSNumber numberWithLongLong:node->id()]];
     return menu_item_;
   }
 
   // Does NOT take ownership of node.
   NSMenuItem* ItemForBookmarkBarMenu(const BookmarkNode* node) {
     [menu_ setRepresentedObject:[NSNumber numberWithLongLong:node->id()]];
@@ skipping 167 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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   [bar_ setIgnoreAnimations:YES];
 
   [bar_ loaded:model];
   EXPECT_TRUE([bar_ offTheSideButtonIsHidden]);
 
   for (int i = 0; i < 2; i++) {
     bookmark_utils::AddIfNotBookmarked(
         model, GURL("http://www.foo.com"), ASCIIToUTF16("small"));
     EXPECT_TRUE([bar_ offTheSideButtonIsHidden]);
   }
@@ skipping 29 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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   [bar_ setIgnoreAnimations:YES];
   [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 70 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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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");
   bookmark_utils::AddIfNotBookmarked(model, gurl, ASCIIToUTF16("small"));
   bookmark_utils::AddIfNotBookmarked(
       model, GURL("http://www.cnn.com"), ASCIIToUTF16("bigger title"));
@@ skipping 64 matching lines @@
     GURL gurl(urls[i]);
     [bar_ performSelector:selectors[i]
                withObject:ItemForBookmarkBarMenu(gurl)];
     EXPECT_EQ(noOpenBar()->urls_[0], gurl);
     EXPECT_EQ(noOpenBar()->dispositions_[0], dispositions[i]);
     [bar_ clear];
   }
 }
 
 TEST_F(BookmarkBarControllerTest, TestAddRemoveAndClear) {
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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, 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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   GURL gurl1("http://www.google.com");
   string16 title1(ASCIIToUTF16("x"));
   bookmark_utils::AddIfNotBookmarked(model, gurl1, title1);
 
   GURL gurl2("http://www.google.com/blah");
   string16 title2(ASCIIToUTF16("y"));
   bookmark_utils::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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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);
 
   NSMenuItem* item = ItemForBookmarkBarMenu(middle_node);
   [bar_ deleteBookmark:item];
   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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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 10 matching lines @@
   // cell is autoreleased; no need to release here
 }
 
 // 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.
 TEST_F(BookmarkBarControllerTest, MiddleClick) {
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   GURL gurl1("http://www.google.com/");
   string16 title1(ASCIIToUTF16("x"));
   bookmark_utils::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)];
   EXPECT_EQ(noOpenBar()->urls_.size(), 1U);
 }
 
 TEST_F(BookmarkBarControllerTest, DisplaysHelpMessageOnEmpty) {
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   [bar_ loaded:model];
   EXPECT_FALSE([[[bar_ buttonView] noItemContainer] isHidden]);
 }
 
 TEST_F(BookmarkBarControllerTest, HidesHelpMessageWithBookmark) {
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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 20 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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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, TestButtonOrBar) {
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   GURL gurl1("http://www.google.com");
   string16 title1(ASCIIToUTF16("x"));
   bookmark_utils::AddIfNotBookmarked(model, gurl1, title1);
 
   GURL gurl2("http://www.google.com/gurl_power");
   string16 title2(ASCIIToUTF16("gurl power"));
   bookmark_utils::AddIfNotBookmarked(model, gurl2, title2);
 
   NSButton* first = [[bar_ buttons] objectAtIndex:0];
   NSButton* second = [[bar_ buttons] objectAtIndex:1];
   EXPECT_TRUE(first && second);
 
   NSMenuItem* menuItem = [[[first cell] menu] itemAtIndex:0];
   const BookmarkNode* node = [bar_ nodeFromMenuItem:menuItem];
   EXPECT_TRUE(node);
   EXPECT_EQ(node, model->bookmark_bar_node()->GetChild(0));
 
   menuItem = [[[second cell] menu] itemAtIndex:0];
   node = [bar_ nodeFromMenuItem:menuItem];
   EXPECT_TRUE(node);
   EXPECT_EQ(node, model->bookmark_bar_node()->GetChild(1));
 
   menuItem = [[[bar_ view] menu] itemAtIndex:0];
   node = [bar_ nodeFromMenuItem:menuItem];
   EXPECT_TRUE(node);
   EXPECT_EQ(node, model->bookmark_bar_node());
 }
 
 TEST_F(BookmarkBarControllerTest, TestMenuNodeAndDisable) {
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* parent = model->bookmark_bar_node();
   const BookmarkNode* folder = model->AddFolder(parent,
                                                 parent->child_count(),
                                                 ASCIIToUTF16("folder"));
   NSButton* button = [[bar_ buttons] objectAtIndex:0];
   EXPECT_TRUE(button);
 
   // Confirm the menu knows which node it is talking about
   BookmarkMenu* menu = static_cast<BookmarkMenu*>([[button cell] menu]);
   EXPECT_TRUE(menu);
   EXPECT_TRUE([menu isKindOfClass:[BookmarkMenu class]]);
   EXPECT_EQ(folder->id(), [menu id]);
 
   // Make sure "Open All" is disabled (nothing to open -- no children!)
   // (Assumes "Open All" is the 1st item)
   NSMenuItem* item = [menu itemAtIndex:0];
   EXPECT_FALSE([bar_ validateUserInterfaceItem:item]);
 
   // Now add a child and make sure the item would be enabled.
   model->AddURL(folder, folder->child_count(),
                 ASCIIToUTF16("super duper wide title"),
                 GURL("http://superfriends.hall-of-justice.edu"));
   EXPECT_TRUE([bar_ validateUserInterfaceItem:item]);
 }
 
 TEST_F(BookmarkBarControllerTest, TestDragButton) {
   WithNoAnimation at_all;
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
 
   GURL gurls[] = { GURL("http://www.google.com/a"),
                    GURL("http://www.google.com/b"),
                    GURL("http://www.google.com/c") };
   string16 titles[] = { ASCIIToUTF16("a"),
                         ASCIIToUTF16("b"),
                         ASCIIToUTF16("c") };
   for (unsigned i = 0; i < arraysize(titles); i++)
     bookmark_utils::AddIfNotBookmarked(model, gurls[i], titles[i]);
 
@@ skipping 50 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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
 
   GURL gurls[] = { GURL("http://www.google.com/a"),
                    GURL("http://www.google.com/b"),
                    GURL("http://www.google.com/c") };
   string16 titles[] = { ASCIIToUTF16("a"),
                         ASCIIToUTF16("b"),
                         ASCIIToUTF16("c") };
   for (unsigned i = 0; i < arraysize(titles); i++)
     bookmark_utils::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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   bookmark_utils::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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   GURL gurls[] = { GURL("http://www.foo.com/"),
                    GURL("http://www.bar.com/"),
                    GURL("http://www.baz.com/") };
   string16 titles[] = { ASCIIToUTF16("a"),
                         ASCIIToUTF16("b"),
                         ASCIIToUTF16("c") };
   for (size_t i = 0; i < arraysize(titles); i++)
     bookmark_utils::AddIfNotBookmarked(model, gurls[i], titles[i]);
 
   // Get and retain the buttons so we can examine them after dealloc.
@@ skipping 13 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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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(*profile()->GetBookmarkModel());
+  BookmarkModel& model(*BookmarkModelFactory::GetForProfile(profile()));
   const BookmarkNode* root = model.bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b ] 3b 4f:[ 4f1b 4f2b ] ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model and that we do not have a folder controller.
   std::string actualModelString = model_test_utils::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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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 = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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, NodeDeletedWhileMenuIsOpen) {
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   [bar_ loaded:model];
 
   const BookmarkNode* parent = model->bookmark_bar_node();
   const BookmarkNode* initialNode = model->AddURL(
       parent, parent->child_count(),
       ASCIIToUTF16("initial"),
       GURL("http://www.google.com"));
 
   NSMenuItem* item = ItemForBookmarkBarMenu(initialNode);
   EXPECT_EQ(0U, noOpenBar()->urls_.size());
@@ skipping 18 matching lines @@
   [bar_ openBookmarkInIncognitoWindow:item];
   [bar_ editBookmark:item];
   [bar_ copyBookmark:item];
   [bar_ deleteBookmark:item];
   [bar_ openAllBookmarks:item];
   [bar_ openAllBookmarksNewWindow:item];
   [bar_ openAllBookmarksIncognitoWindow:item];
 }
 
 TEST_F(BookmarkBarControllerTest, NodeDeletedWhileContextMenuIsOpen) {
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   [bar_ loaded:model];
 
   const BookmarkNode* parent = model->bookmark_bar_node();
   const BookmarkNode* folder = model->AddFolder(parent,
                                                 parent->child_count(),
                                                 ASCIIToUTF16("folder"));
   const BookmarkNode* framma = model->AddURL(folder, folder->child_count(),
                                              ASCIIToUTF16("f1"),
                                              GURL("http://framma-lamma.com"));
 
   // Mock in a menu
   id origMenu = [bar_ buttonContextMenu];
   id fakeMenu = [OCMockObject partialMockForObject:origMenu];
   [[fakeMenu expect] cancelTracking];
   [bar_ setButtonContextMenu:fakeMenu];
 
   // Force a delete which should cancelTracking on the menu.
   model->Remove(framma->parent(), framma->parent()->GetIndexOf(framma));
 
   // Restore, then confirm cancelTracking was called.
   [bar_ setButtonContextMenu:origMenu];
   EXPECT_OCMOCK_VERIFY(fakeMenu);
 }
 
 TEST_F(BookmarkBarControllerTest, CloseFolderOnAnimate) {
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   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(),
       ASCIIToUTF16("title super duper long long whoa momma title you betcha"),
@@ skipping 12 matching lines @@
                showDetachedBar:YES
                  withAnimation:YES];
   EXPECT_TRUE([bar_ isAnimationRunning]);
 
   // Now that we've closed the bookmark bar (with animation) the folder menu
   // should have been closed thus releasing the folderController.
   EXPECT_FALSE([bar_ folderController]);
 }
 
 TEST_F(BookmarkBarControllerTest, MoveRemoveAddButtons) {
-  BookmarkModel& model(*profile()->GetBookmarkModel());
+  BookmarkModel& model(*BookmarkModelFactory::GetForProfile(profile()));
   const BookmarkNode* root = model.bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b ] 3b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Remember how many buttons are showing.
   int oldDisplayedButtons = [bar_ displayedButtonCount];
@@ skipping 72 matching lines @@
                    initialWidth:NSWidth(parent_frame)
                        delegate:nil
                  resizeDelegate:resizeDelegate_.get()]);
     [bar_ view];
     // 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 = profile()->GetBookmarkModel();
+    BookmarkModel* model = BookmarkModelFactory::GetForProfile(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 147 matching lines @@
                [[BookmarkBarControllerDragData alloc]
                 initWithBrowser:browser()
                    initialWidth:NSWidth([parent_view_ frame])
                        delegate:nil
                  resizeDelegate:resizeDelegate_.get()]);
     InstallAndToggleBar(bar_.get());
   }
 };
 
 TEST_F(BookmarkBarControllerDragDropTest, DragMoveBarBookmarkToOffTheSide) {
-  BookmarkModel& model(*profile()->GetBookmarkModel());
+  BookmarkModel& model(*BookmarkModelFactory::GetForProfile(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 ");
   model_test_utils::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(*profile()->GetBookmarkModel());
+  BookmarkModel& model(*BookmarkModelFactory::GetForProfile(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 ");
   model_test_utils::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(*profile()->GetBookmarkModel());
+  BookmarkModel& model(*BookmarkModelFactory::GetForProfile(profile()));
   const BookmarkNode* root = model.bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                                   "2f3b ] 3b 4b ");
   model_test_utils::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 ");
   model_test_utils::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 = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(expected1, actual);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, AddURLs) {
-  BookmarkModel& model(*profile()->GetBookmarkModel());
+  BookmarkModel& model(*BookmarkModelFactory::GetForProfile(profile()));
   const BookmarkNode* root = model.bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                                  "2f3b ] 3b 4b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actual = model_test_utils::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 = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, ControllerForNode) {
-  BookmarkModel& model(*profile()->GetBookmarkModel());
+  BookmarkModel& model(*BookmarkModelFactory::GetForProfile(profile()));
   const BookmarkNode* root = model.bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b ] 3b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModelString = model_test_utils::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(*profile()->GetBookmarkModel());
+  BookmarkModel& model(*BookmarkModelFactory::GetForProfile(profile()));
   const BookmarkNode* root = model.bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b 2f3b ] 3b 4b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actualModel = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModel);
 
   // Test a series of points starting at the right edge of the bar.
   BookmarkButton* targetButton = [bar_ buttonWithTitleEqualTo:@"1b"];
@@ skipping 11 matching lines @@
   EXPECT_CGFLOAT_EQ(expected, actual);
   targetButton = [bar_ buttonWithTitleEqualTo:@"4b"];
   targetPoint = [targetButton right];
   targetPoint.x += 100;  // Somewhere off to the right.
   expected = NSMaxX([targetButton frame]) + xDelta;
   actual = [bar_ indicatorPosForDragToPoint:targetPoint];
   EXPECT_CGFLOAT_EQ(expected, actual);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, PulseButton) {
-  BookmarkModel* model = profile()->GetBookmarkModel();
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(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]);
 
   NSValue *value = [NSValue valueWithPointer:node];
   NSDictionary *dict = [NSDictionary
@@ skipping 14 matching lines @@
                        bookmark_button::kBookmarkPulseFlagKey,
                        nil];
   [[NSNotificationCenter defaultCenter]
         postNotificationName:bookmark_button::kPulseBookmarkButtonNotification
                       object:nil
                     userInfo:dict];
   EXPECT_FALSE([button isContinuousPulsing]);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, DragBookmarkDataToTrash) {
-  BookmarkModel& model(*profile()->GetBookmarkModel());
+  BookmarkModel& model(*BookmarkModelFactory::GetForProfile(profile()));
   const BookmarkNode* root = model.bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                                   "2f3b ] 3b 4b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
   std::string actual = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actual);
 
   int oldChildCount = root->child_count();
@@ skipping 12 matching lines @@
                              "2f3b ] 4b ");
   actual = model_test_utils::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