Change BrowserList::GetLastActive to respect the profile for which it's launched in the bookmark ...

chrome/browser/bookmarks/bookmark_utils.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
@@ skipping 108 matching lines @@
 
 // Implementation of OpenAll. Opens all nodes of type URL and any children of
 // |node| that are of type URL. |navigator| is the PageNavigator used to open
 // URLs. After the first url is opened |opened_url| is set to true and
 // |navigator| is set to the PageNavigator of the last active tab. This is done
 // to handle a window disposition of new window, in which case we want
 // subsequent tabs to open in that window.
 void OpenAllImpl(const BookmarkNode* node,
                  WindowOpenDisposition initial_disposition,
                  PageNavigator** navigator,
+                 Profile* profile,
                  bool* opened_url) {
   if (node->is_url()) {
     WindowOpenDisposition disposition;
     if (*opened_url)
       disposition = NEW_BACKGROUND_TAB;
     else
       disposition = initial_disposition;
     (*navigator)->OpenURL(node->GetURL(), GURL(), disposition,
                           PageTransition::AUTO_BOOKMARK);
     if (!*opened_url) {
       *opened_url = true;
       // We opened the first URL which may have opened a new window or clobbered
       // the current page, reset the navigator just to be sure.
-      Browser* new_browser = BrowserList::GetLastActive();
+      Browser* new_browser = BrowserList::GetLastActiveWithProfile(profile);
       if (new_browser) {
         TabContents* current_tab = new_browser->GetSelectedTabContents();
         DCHECK(new_browser && current_tab);
         if (new_browser && current_tab)
           *navigator = current_tab;
       }  // else, new_browser == NULL, which happens during testing.
     }
   } else {
     // For folders only open direct children.
     for (int i = 0; i < node->child_count(); ++i) {
       const BookmarkNode* child_node = node->GetChild(i);
       if (child_node->is_url())
-        OpenAllImpl(child_node, initial_disposition, navigator, opened_url);
+        OpenAllImpl(child_node, initial_disposition, navigator, profile,
+                    opened_url);
     }
   }
 }
 
 bool ShouldOpenAll(gfx::NativeWindow parent,
                    const std::vector<const BookmarkNode*>& nodes) {
   int child_count = 0;
   for (size_t i = 0; i < nodes.size(); ++i)
     child_count += ChildURLCount(nodes[i]);
   if (child_count < bookmark_utils::num_urls_before_prompting)
@@ skipping 210 matching lines @@
       if (initial_disposition != NEW_WINDOW &&
           initial_disposition != OFF_THE_RECORD) {
         browser->window()->Activate();
       }
       navigator = browser->GetSelectedTabContents();
     }
   }
 
   bool opened_url = false;
   for (size_t i = 0; i < nodes.size(); ++i)
-    OpenAllImpl(nodes[i], initial_disposition, &navigator, &opened_url);
+    OpenAllImpl(nodes[i], initial_disposition, &navigator, profile,
+                &opened_url);
 }
 
 void OpenAll(gfx::NativeWindow parent,
              Profile* profile,
              PageNavigator* navigator,
              const BookmarkNode* node,
              WindowOpenDisposition initial_disposition) {
   std::vector<const BookmarkNode*> nodes;
   nodes.push_back(node);
   OpenAll(parent, profile, navigator, nodes, initial_disposition);
@@ skipping 288 matching lines @@
     return true;
 
   for (int i = 0; i < node->child_count(); ++i) {
     if (NodeHasURLs(node->GetChild(i)))
       return true;
   }
   return false;
 }
 
 }  // namespace bookmark_utils