Changes 'Open all' bookmarks to not recurse through nested folders.

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"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
-#if defined(OS_MACOSX)
-#include "chrome/browser/bookmarks/bookmark_pasteboard_helper_mac.h"
-#endif
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/history/query_parser.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/tab_contents/page_navigator.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_service.h"
 #include "grit/app_strings.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/base/net_util.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/tree_node_iterator.h"
 
+#if defined(OS_MACOSX)
+#include "chrome/browser/bookmarks/bookmark_pasteboard_helper_mac.h"
+#endif
+
 #if defined(TOOLKIT_VIEWS)
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "views/drag_utils.h"
 #include "views/events/event.h"
 #include "views/widget/native_widget.h"
 #include "views/widget/widget.h"
-#elif defined(TOOLKIT_GTK)
+#endif
+
+#if defined(TOOLKIT_GTK)
 #include "chrome/browser/ui/gtk/custom_drag.h"
 #endif
 
 using base::Time;
 
 namespace {
 
 // A PageNavigator implementation that creates a new Browser. This is used when
 // opening a url and there is no Browser open. The Browser is created the first
 // time the PageNavigator method is invoked.
 class NewBrowserPageNavigator : public PageNavigator {
  public:
   explicit NewBrowserPageNavigator(Profile* profile)
       : profile_(profile),
         browser_(NULL) {}
 
   virtual ~NewBrowserPageNavigator() {
     if (browser_)
       browser_->window()->Show();
   }
 
   Browser* browser() const { return browser_; }
 
   virtual void OpenURL(const GURL& url,
                        const GURL& referrer,
                        WindowOpenDisposition disposition,
-                       PageTransition::Type transition) {
+                       PageTransition::Type transition) OVERRIDE {
     if (!browser_) {
       Profile* profile = (disposition == OFF_THE_RECORD) ?
           profile_->GetOffTheRecordProfile() : profile_;
       browser_ = Browser::Create(profile);
       // Always open the first tab in the foreground.
       disposition = NEW_FOREGROUND_TAB;
     }
     browser_->OpenURL(url, referrer, NEW_FOREGROUND_TAB, transition);
   }
 
@@ skipping 12 matching lines @@
     model->AddURL(parent, index_to_add_at, element.title, element.url);
   } else {
     const BookmarkNode* new_folder = model->AddFolder(parent,
                                                       index_to_add_at,
                                                       element.title);
     for (int i = 0; i < static_cast<int>(element.children.size()); ++i)
       CloneBookmarkNodeImpl(model, element.children[i], new_folder, i);
   }
 }
 
-// Returns the number of descendants of node that are of type url.
-int DescendantURLCount(const BookmarkNode* node) {
+// Returns the number of children of |node| that are of type url.
+int ChildURLCount(const BookmarkNode* node) {
   int result = 0;
   for (int i = 0; i < node->child_count(); ++i) {
     const BookmarkNode* child = node->GetChild(i);
     if (child->is_url())
       result++;
-    else
-      result += DescendantURLCount(child);
   }
   return result;
 }
 
-// Implementation of OpenAll. Opens all nodes of type URL and recurses for
-// folders. |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.
+// 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,
                  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();
       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 {
-    // Folder, recurse through children.
+    // For folders only open direct children.
     for (int i = 0; i < node->child_count(); ++i) {
-      OpenAllImpl(node->GetChild(i), initial_disposition, navigator,
-                  opened_url);
+      const BookmarkNode* child_node = node->GetChild(i);
+      if (child_node->is_url())
+        OpenAllImpl(child_node, initial_disposition, navigator, opened_url);
     }
   }
 }
 
 bool ShouldOpenAll(gfx::NativeWindow parent,
                    const std::vector<const BookmarkNode*>& nodes) {
-  int descendant_count = 0;
+  int child_count = 0;
   for (size_t i = 0; i < nodes.size(); ++i)
-    descendant_count += DescendantURLCount(nodes[i]);
-  if (descendant_count < bookmark_utils::num_urls_before_prompting)
+    child_count += ChildURLCount(nodes[i]);
+  if (child_count < bookmark_utils::num_urls_before_prompting)
     return true;
 
   string16 message = l10n_util::GetStringFUTF16(
       IDS_BOOKMARK_BAR_SHOULD_OPEN_ALL,
-      base::IntToString16(descendant_count));
+      base::IntToString16(child_count));
   string16 title = l10n_util::GetStringUTF16(IDS_PRODUCT_NAME);
   return platform_util::SimpleYesNoBox(parent, title, message);
 }
 
 // Comparison function that compares based on date modified of the two nodes.
 bool MoreRecentlyModified(const BookmarkNode* n1, const BookmarkNode* n2) {
   return n1->date_folder_modified() > n2->date_folder_modified();
 }
 
 // Returns true if |text| contains each string in |words|. This is used when
@@ skipping 493 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