Fixes a couple of bookmark bar bugs:...

chrome/browser/bookmark_bar_context_menu_controller.cc

 // Copyright (c) 2006-2008 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/bookmark_bar_context_menu_controller.h"
 
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/page_navigator.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents.h"
 #include "chrome/browser/user_metrics.h"
 #include "chrome/browser/views/bookmark_editor_view.h"
 #include "chrome/browser/views/input_window.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/views/view_container.h"
 #include "chrome/views/window.h"
 
+#include "chromium_strings.h"
 #include "generated_resources.h"
 
 namespace {
 
+// Number of bookmarks we'll open before prompting the user to see if they
+// really want to open all.
+const int kNumURLsBeforePrompting = 15;
+
 // Returns true if the specified node is of type URL, or has a descendant
 // of type URL.
 bool NodeHasURLs(BookmarkNode* node) {
   if (node->GetType() == history::StarredEntry::URL)
     return true;
 
   for (int i = 0; i < node->GetChildCount(); ++i) {
     if (NodeHasURLs(node->GetChild(i)))
       return true;
   }
   return false;
 }
 
-// Opens a tab/window for node and recursively opens all descendants.
-// If open_first_in_new_window is true, the first opened node is opened
-// in a new window. navigator indicates the PageNavigator to use for
-// new tabs. It is reset if open_first_in_new_window is true.
-// opened_url is set to true the first time a new tab is opened.
-void OpenAll(BookmarkNode* node,
-             bool open_first_in_new_window,
-             PageNavigator** navigator,
-             bool* opened_url) {
+// Implementation of OpenAll. Opens all nodes of type URL and recurses for
+// groups.
+void OpenAll0(BookmarkNode* node,
+              WindowOpenDisposition initial_disposition,
+              PageNavigator** navigator,
+              bool* opened_url) {
   if (node->GetType() == history::StarredEntry::URL) {
     WindowOpenDisposition disposition;
     if (*opened_url)
       disposition = NEW_BACKGROUND_TAB;
-    else if (open_first_in_new_window)
-      disposition = NEW_WINDOW;
-    else  // Open in current window.
-      disposition = CURRENT_TAB;
+    else
+      disposition = initial_disposition;
     (*navigator)->OpenURL(node->GetURL(), disposition,
                           PageTransition::AUTO_BOOKMARK);
     if (!*opened_url) {
       *opened_url = true;
-      if (open_first_in_new_window || disposition == CURRENT_TAB) {
-        // We opened the tab in a new window or in the current tab which
-        // likely reset the navigator. Need to reset the page navigator
-        // appropriately.
-        Browser* new_browser = BrowserList::GetLastActive();
-        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.
-      }
+      // 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();
+      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 {
     // Group, recurse through children.
-    for (int i = 0; i < node->GetChildCount(); ++i) {
-      OpenAll(node->GetChild(i), open_first_in_new_window, navigator,
-              opened_url);
-    }
+    for (int i = 0; i < node->GetChildCount(); ++i)
+      OpenAll0(node->GetChild(i), initial_disposition, navigator, opened_url);
   }
 }
 
+// Returns the number of descendants of node that are of type url.
+int DescendantURLCount(BookmarkNode* node) {
+  int result = 0;
+  for (int i = 0; i < node->GetChildCount(); ++i) {
+    BookmarkNode* child = node->GetChild(i);
+    if (child->is_url())
+      result++;
+    else
+      result += DescendantURLCount(child);
+  }
+  return result;
+}
+
+bool ShouldOpenAll(HWND parent, BookmarkNode* node) {
+  int descendant_count = DescendantURLCount(node);
+  if (descendant_count < kNumURLsBeforePrompting)
+    return true;
+
+  std::wstring message =
+      l10n_util::GetStringF(IDS_BOOKMARK_BAR_SHOULD_OPEN_ALL,
+                            IntToWString(descendant_count));
+  return (MessageBox(parent, message.c_str(),
+                     l10n_util::GetString(IDS_PRODUCT_NAME).c_str(),
+                     MB_YESNO | MB_ICONWARNING | MB_TOPMOST) == IDYES);
+}
+
 // EditFolderController -------------------------------------------------------
 
 // EditFolderController manages the editing and/or creation of a folder. If the
 // user presses ok, the name change is committed to the database.
 //
 // EditFolderController deletes itself when the window is closed.
 //
 class EditFolderController : public InputWindowDelegate,
                              public BookmarkBarView::ModelChangedListener {
  public:
@@ skipping 83 matching lines @@
 const int BookmarkBarContextMenuController::open_bookmark_in_new_window_id = 3;
 const int BookmarkBarContextMenuController::open_bookmark_in_new_tab_id = 4;
 const int BookmarkBarContextMenuController::open_all_bookmarks_id = 5;
 const int
     BookmarkBarContextMenuController::open_all_bookmarks_in_new_window_id = 6;
 const int BookmarkBarContextMenuController::edit_bookmark_id = 7;
 const int BookmarkBarContextMenuController::delete_bookmark_id = 8;
 const int BookmarkBarContextMenuController::add_bookmark_id = 9;
 const int BookmarkBarContextMenuController::new_folder_id = 10;
 
+// static
+void BookmarkBarContextMenuController::OpenAll(
+    HWND parent,
+    PageNavigator* navigator,
+    BookmarkNode* node,
+    WindowOpenDisposition initial_disposition) {
+  if (!ShouldOpenAll(parent, node))
+    return;
+
+  PageNavigator* nav = navigator;
+  bool opened_url = false;
+  OpenAll0(node, initial_disposition, &nav, &opened_url);
+}
+
 BookmarkBarContextMenuController::BookmarkBarContextMenuController(
     BookmarkBarView* view,
     BookmarkNode* node)
     : view_(view),
       node_(node),
       menu_(this) {
   if (node->GetType() == history::StarredEntry::URL) {
     menu_.AppendMenuItemWithLabel(
         open_bookmark_id,
         l10n_util::GetString(IDS_BOOMARK_BAR_OPEN));
@@ skipping 83 matching lines @@
     case open_all_bookmarks_id:
     case open_all_bookmarks_in_new_window_id: {
       if (id == open_all_bookmarks_id) {
         UserMetrics::RecordAction(L"BookmarkBar_ContextMenu_OpenAll",
                                   profile);
       } else {
         UserMetrics::RecordAction(
             L"BookmarkBar_ContextMenu_OpenAllInNewWindow", profile);
       }
 
-      BookmarkNode* node = node_;
-      PageNavigator* navigator = view_->GetPageNavigator();
-      bool opened_url = false;
-      OpenAll(node, (id == open_all_bookmarks_in_new_window_id), &navigator,
-              &opened_url);
+      WindowOpenDisposition initial_disposition;
+      if (id == open_all_bookmarks_in_new_window_id)
+        initial_disposition = NEW_WINDOW;
+      else
+        initial_disposition = CURRENT_TAB;
+
+      OpenAll(view_->GetViewContainer()->GetHWND(), view_->GetPageNavigator(),
+              node_, initial_disposition);
       break;
     }
 
     case edit_bookmark_id:
       UserMetrics::RecordAction(L"BookmarkBar_ContextMenu_Edit", profile);
 
       if (node_->GetType() == history::StarredEntry::URL) {
         BookmarkEditorView::Show(view_->GetViewContainer()->GetHWND(),
                                  view_->GetProfile(), NULL, node_);
       } else {
@@ skipping 63 matching lines @@
   if (node_->GetType() != history::StarredEntry::URL) {
     // Adding to a group always adds to the end.
     *visual_order = node_->GetChildCount();
     return node_;
   } else {
     DCHECK(node_->GetParent());
     *visual_order = node_->GetParent()->IndexOfChild(node_) + 1;
     return node_->GetParent();
   }
 }