Makes canceling 'bookmark all tabs' delete the folder. Or rather,...

chrome/browser/views/bookmark_editor_view.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/views/bookmark_editor_view.h"
 
 #include "app/l10n_util.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 31 matching lines @@
 // Preferred width of the tree.
 static const int kTreeWidth = 300;
 
 // ID for various children.
 static const int kNewGroupButtonID             = 1002;
 
 // static
 void BookmarkEditor::Show(HWND parent_hwnd,
                           Profile* profile,
                           const BookmarkNode* parent,
-                          const BookmarkNode* node,
+                          const EditDetails& details,
                           Configuration configuration,
                           Handler* handler) {
   DCHECK(profile);
   BookmarkEditorView* editor =
-      new BookmarkEditorView(profile, parent, node, configuration, handler);
+      new BookmarkEditorView(profile, parent, details, configuration, handler);
   editor->Show(parent_hwnd);
 }
 
 BookmarkEditorView::BookmarkEditorView(
     Profile* profile,
     const BookmarkNode* parent,
-    const BookmarkNode* node,
+    const EditDetails& details,
     BookmarkEditor::Configuration configuration,
     BookmarkEditor::Handler* handler)
     : profile_(profile),
       tree_view_(NULL),
       new_group_button_(NULL),
       parent_(parent),
-      node_(node),
+      details_(details),
       running_menu_for_root_(false),
       show_tree_(configuration == SHOW_TREE),
       handler_(handler) {
   DCHECK(profile);
   Init();
 }
 
 BookmarkEditorView::~BookmarkEditorView() {
   // The tree model is deleted before the view. Reset the model otherwise the
   // tree will reference a deleted model.
   if (tree_view_)
     tree_view_->SetModel(NULL);
   bb_model_->RemoveObserver(this);
 }
 
 bool BookmarkEditorView::IsDialogButtonEnabled(
     MessageBoxFlags::DialogButton button) const {
   if (button == MessageBoxFlags::DIALOGBUTTON_OK) {
-    if (IsEditingFolder())
+    if (details_.type == EditDetails::NEW_FOLDER)
       return !title_tf_.text().empty();
 
     const GURL url(GetInputURL());
     return bb_model_->IsLoaded() && url.is_valid();
   }
   return true;
 }
 
 bool BookmarkEditorView::IsModal() const {
   return true;
@@ skipping 155 matching lines @@
 }
 
 void BookmarkEditorView::Init() {
   bb_model_ = profile_->GetBookmarkModel();
   DCHECK(bb_model_);
   bb_model_->AddObserver(this);
 
   url_tf_.SetParentOwned(false);
   title_tf_.SetParentOwned(false);
 
-  title_tf_.SetText(node_ ? node_->GetTitle() : std::wstring());
+  std::wstring title;
+  if (details_.type == EditDetails::EXISTING_NODE)
+    title = details_.existing_node->GetTitle();
+  else if (details_.type == EditDetails::NEW_FOLDER)
+    title = l10n_util::GetString(IDS_BOOMARK_EDITOR_NEW_FOLDER_NAME);
+  title_tf_.SetText(title);
   title_tf_.SetController(this);
 
   std::wstring url_text;
-  if (node_ && !IsEditingFolder()) {
+  if (details_.type == EditDetails::EXISTING_NODE) {
     std::wstring languages = profile_
         ? profile_->GetPrefs()->GetString(prefs::kAcceptLanguages)
         : std::wstring();
     // The following URL is user-editable.  We specify omit_username_password=
     // false and unescape=false to show the original URL except IDN.
     url_text =
-        net::FormatUrl(node_->GetURL(), languages, false, UnescapeRule::NONE,
-                       NULL, NULL);
+        net::FormatUrl(details_.existing_node->GetURL(), languages, false,
+                       UnescapeRule::NONE, NULL, NULL);
   }
   url_tf_.SetText(url_text);
   url_tf_.SetController(this);
 
   if (show_tree_) {
     tree_view_ = new views::TreeView();
     new_group_button_.reset(new views::NativeButton(
         this, l10n_util::GetString(IDS_BOOMARK_EDITOR_NEW_FOLDER_BUTTON)));
     new_group_button_->SetParentOwned(false);
     tree_view_->SetContextMenuController(this);
@@ skipping 31 matching lines @@
   column_set->AddPaddingColumn(0, kRelatedControlHorizontalSpacing);
   column_set->AddColumn(GridLayout::FILL, GridLayout::LEADING, 0,
                         GridLayout::USE_PREF, 0, 0);
   column_set->LinkColumnSizes(0, 2, 4, -1);
 
   layout->StartRow(0, labels_column_set_id);
   layout->AddView(
       new Label(l10n_util::GetString(IDS_BOOMARK_EDITOR_NAME_LABEL)));
   layout->AddView(&title_tf_);
 
-  if (!IsEditingFolder()) {
+  if (details_.type != EditDetails::NEW_FOLDER) {
     layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
 
     layout->StartRow(0, labels_column_set_id);
     layout->AddView(
         new Label(l10n_util::GetString(IDS_BOOMARK_EDITOR_URL_LABEL)));
     layout->AddView(&url_tf_);
   }
 
   if (show_tree_) {
     layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
@@ skipping 18 matching lines @@
 void BookmarkEditorView::BookmarkNodeAdded(BookmarkModel* model,
                                            const BookmarkNode* parent,
                                            int index) {
   Reset();
 }
 
 void BookmarkEditorView::BookmarkNodeRemoved(BookmarkModel* model,
                                              const BookmarkNode* parent,
                                              int index,
                                              const BookmarkNode* node) {
-  if ((node_ && node_->HasAncestor(node)) ||
+  if ((details_.type == EditDetails::EXISTING_NODE &&
+       details_.existing_node->HasAncestor(node)) ||
       (parent_ && parent_->HasAncestor(node))) {
     // The node, or its parent was removed. Close the dialog.
     window()->Close();
   } else {
     Reset();
   }
 }
 
 void BookmarkEditorView::BookmarkNodeChildrenReordered(
     BookmarkModel* model, const BookmarkNode* node) {
@@ skipping 60 matching lines @@
 BookmarkEditorView::EditorNode* BookmarkEditorView::AddNewGroup(
     EditorNode* parent) {
   EditorNode* new_node = new EditorNode();
   new_node->SetTitle(l10n_util::GetString(IDS_BOOMARK_EDITOR_NEW_FOLDER_NAME));
   new_node->value = 0;
   // new_node is now owned by parent.
   tree_model_->Add(parent, parent->GetChildCount(), new_node);
   return new_node;
 }
 
-bool BookmarkEditorView::IsEditingFolder() const {
-  return node_ && node_->is_folder();
-}
-
 void BookmarkEditorView::ExpandAndSelect() {
   tree_view_->ExpandAll();
 
-  const BookmarkNode* to_select = node_ ? node_->GetParent() : parent_;
+  const BookmarkNode* to_select = parent_;
+  if (details_.type == EditDetails::EXISTING_NODE)
+    to_select = details_.existing_node->GetParent();
   int64 group_id_to_select = to_select->id();
   EditorNode* b_node =
       FindNodeWithID(tree_model_->GetRoot(), group_id_to_select);
   if (!b_node)
     b_node = tree_model_->GetRoot()->GetChild(0);  // Bookmark bar node.
 
   tree_view_->SetSelectedNode(b_node);
 }
 
 BookmarkEditorView::EditorNode* BookmarkEditorView::CreateRootNode() {
   EditorNode* root_node = new EditorNode(std::wstring(), 0);
   const BookmarkNode* bb_root_node = bb_model_->root_node();
   CreateNodes(bb_root_node, root_node);
   DCHECK(root_node->GetChildCount() == 2);
   DCHECK(bb_root_node->GetChild(0)->GetType() == BookmarkNode::BOOKMARK_BAR);
   DCHECK(bb_root_node->GetChild(1)->GetType() == BookmarkNode::OTHER_NODE);
   return root_node;
 }
 
 void BookmarkEditorView::CreateNodes(const BookmarkNode* bb_node,
                                      BookmarkEditorView::EditorNode* b_node) {
   for (int i = 0; i < bb_node->GetChildCount(); ++i) {
     const BookmarkNode* child_bb_node = bb_node->GetChild(i);
-    if (child_bb_node->is_folder() &&
-        (!IsEditingFolder() || child_bb_node != node_)) {
+    if (child_bb_node->is_folder()) {
       EditorNode* new_b_node = new EditorNode(child_bb_node->GetTitle(),
                                               child_bb_node->id());
       b_node->Add(b_node->GetChildCount(), new_b_node);
       CreateNodes(child_bb_node, new_b_node);
     }
   }
 }
 
 BookmarkEditorView::EditorNode* BookmarkEditorView::FindNodeWithID(
     BookmarkEditorView::EditorNode* node,
@@ skipping 26 matching lines @@
   // We're going to apply edits to the bookmark bar model, which will call us
   // back. Normally when a structural edit occurs we reset the tree model.
   // We don't want to do that here, so we remove ourselves as an observer.
   bb_model_->RemoveObserver(this);
 
   GURL new_url(GetInputURL());
   std::wstring new_title(GetInputTitle());
 
   if (!show_tree_) {
     bookmark_utils::ApplyEditsWithNoGroupChange(
-        bb_model_, parent_, node_, new_title, new_url, handler_.get());
+        bb_model_, parent_, details_, new_title, new_url, handler_.get());
     return;
   }
 
   // Create the new groups and update the titles.
   const BookmarkNode* new_parent = NULL;
   ApplyNameChangesAndCreateNewGroups(
       bb_model_->root_node(), tree_model_->GetRoot(), parent, &new_parent);
 
   bookmark_utils::ApplyEditsWithPossibleGroupChange(
-      bb_model_, new_parent, node_, new_title, new_url, handler_.get());
+      bb_model_, new_parent, details_, new_title, new_url, handler_.get());
 }
 
 void BookmarkEditorView::ApplyNameChangesAndCreateNewGroups(
     const BookmarkNode* bb_node,
     BookmarkEditorView::EditorNode* b_node,
     BookmarkEditorView::EditorNode* parent_b_node,
     const BookmarkNode** parent_bb_node) {
   if (parent_b_node == b_node)
     *parent_bb_node = bb_node;
   for (int i = 0; i < b_node->GetChildCount(); ++i) {
@@ skipping 13 matching lines @@
           break;
         }
       }
       DCHECK(child_bb_node);
       bb_model_->SetTitle(child_bb_node, child_b_node->GetTitle());
     }
     ApplyNameChangesAndCreateNewGroups(child_bb_node, child_b_node,
                                        parent_b_node, parent_bb_node);
   }
 }