Adds import/export of bookmarks to bookmarks.html file....

chrome/browser/importer/importer.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/importer/importer.h"
 
 #include <map>
+#include <set>
 
 #include "base/file_util.h"
 #include "base/gfx/image_operations.h"
 #include "base/gfx/png_encoder.h"
 #include "base/string_util.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/first_run.h"
@@ skipping 56 matching lines @@
   DCHECK(profile_);
 
   PrefService* prefs = profile_->GetPrefs();
   // NOTE: We set the kHomePage value, but keep the NewTab page as the homepage.
   prefs->SetString(prefs::kHomePage, ASCIIToWide(home_page.spec()));
   prefs->ScheduleSavePersistentPrefs(g_browser_process->file_thread());
 }
 
 void ProfileWriter::AddBookmarkEntry(
     const std::vector<BookmarkEntry>& bookmark,
-    bool check_uniqueness) {
+    const std::wstring& first_folder_name,
+    int options) {
   BookmarkModel* model = profile_->GetBookmarkModel();
   DCHECK(model->IsLoaded());
 
+  bool first_run = (options & FIRST_RUN) != 0;
+  std::wstring real_first_folder = first_run ? first_folder_name :
+      GenerateUniqueFolderName(model, first_folder_name);
+
   bool show_bookmark_toolbar = false;
   std::set<BookmarkNode*> groups_added_to;
   for (std::vector<BookmarkEntry>::const_iterator it = bookmark.begin();
        it != bookmark.end(); ++it) {
     // Don't insert this url if it isn't valid.
     if (!it->url.is_valid())
       continue;
-      
+
     // We suppose that bookmarks are unique by Title, URL, and Folder.  Since
     // checking for uniqueness may not be always the user's intention we have
     // this as an option.
-    if (check_uniqueness) {
-      std::vector<BookmarkModel::TitleMatch> matches;
-      model->GetBookmarksMatchingText((*it).title, 32, &matches); // 32 enough?
-      if (!matches.empty()) {
-        bool found_match = false;
-        for (std::vector<BookmarkModel::TitleMatch>::iterator match_it =
-                matches.begin();
-             match_it != matches.end() && !found_match;
-             ++match_it) {
-          if ((*it).title != (*match_it).node->GetTitle())
-            continue;
-          if ((*it).url != (*match_it).node->GetURL())
-            continue;
-
-          // Check the folder path for uniqueness as well
-          found_match = true;
-          BookmarkNode* node = (*match_it).node->GetParent();
-          for(std::vector<std::wstring>::const_reverse_iterator path_it =
-                  (*it).path.rbegin();
-              (path_it != (*it).path.rend()) && found_match;
-              ++path_it) {
-            if (NULL == node || (*path_it != node->GetTitle()))
-              found_match = false;
-            if (found_match)
-              node = node->GetParent();
-          }
-
-          // We need a post test to differentiate checks such as
-          // /home/hello and /hello.  Note that here the current parent
-          // should be the "Other bookmarks" node, its parent should be the
-          // root with title "", and it's parent is finally NULL.
-          if (NULL == node->GetParent() ||
-              NULL != node->GetParent()->GetParent())
-            found_match = false;
-        }
-
-        if (found_match)
-          continue;
-      }      
+    if (options & ADD_IF_UNIQUE &&
+        DoesBookmarkExist(model, *it, real_first_folder, first_run)) {
+      continue;
     }
 
     // Set up groups in BookmarkModel in such a way that path[i] is
     // the subgroup of path[i-1]. Finally they construct a path in the
     // model:
     //   path[0] \ path[1] \ ... \ path[size() - 1]
     BookmarkNode* parent =
         (it->in_toolbar ? model->GetBookmarkBarNode() : model->other_node());
     for (std::vector<std::wstring>::const_iterator i = it->path.begin();
          i != it->path.end(); ++i) {
       BookmarkNode* child = NULL;
+      const std::wstring& folder_name =
+          (!first_run && !it->in_toolbar && (i == it->path.begin())) ?
+          real_first_folder : *i;
+
       for (int index = 0; index < parent->GetChildCount(); ++index) {
         BookmarkNode* node = parent->GetChild(index);
         if ((node->GetType() == history::StarredEntry::BOOKMARK_BAR ||
              node->GetType() == history::StarredEntry::USER_GROUP) &&
-            node->GetTitle() == *i) {
+            node->GetTitle() == folder_name) {
           child = node;
           break;
         }
       }
       if (child == NULL)
-        child = model->AddGroup(parent, parent->GetChildCount(), *i);
+        child = model->AddGroup(parent, parent->GetChildCount(), folder_name);
       parent = child;
     }
     groups_added_to.insert(parent);
     model->AddURLWithCreationTime(parent, parent->GetChildCount(),
         it->title, it->url, it->creation_time);
 
     // If some items are put into toolbar, it looks like the user was using
     // it in their last browser. We turn on the bookmarks toolbar.
     if (it->in_toolbar)
       show_bookmark_toolbar = true;
@@ skipping 144 matching lines @@
     // Set the pref and notify the notification service.
     prefs->SetBoolean(prefs::kShowBookmarkBar, true);
     prefs->ScheduleSavePersistentPrefs(g_browser_process->file_thread());
     Source<Profile> source(profile_);
     NotificationService::current()->Notify(
         NOTIFY_BOOKMARK_BAR_VISIBILITY_PREF_CHANGED, source,
         NotificationService::NoDetails());
   }
 }
 
+std::wstring ProfileWriter::GenerateUniqueFolderName(
+    BookmarkModel* model,
+    const std::wstring& folder_name) {
+  // Build a set containing the folder names of the other folder.
+  std::set<std::wstring> other_folder_names;
+  BookmarkNode* other = model->other_node();
+  for (int i = 0; i < other->GetChildCount(); ++i) {
+    BookmarkNode* node = other->GetChild(i);
+    if (node->is_folder())
+      other_folder_names.insert(node->GetTitle());
+  }
+
+  if (other_folder_names.find(folder_name) == other_folder_names.end())
+    return folder_name;  // Name is unique, use it.
+
+  // Otherwise iterate until we find a unique name.
+  for (int i = 1; i < 100; ++i) {
+    std::wstring name = folder_name + StringPrintf(L" (%d)", i);
+    if (other_folder_names.find(name) == other_folder_names.end())
+      return name;
+  }
+
+  return folder_name;
+}
+
+bool ProfileWriter::DoesBookmarkExist(
+    BookmarkModel* model,
+    const BookmarkEntry& entry,
+    const std::wstring& first_folder_name,
+    bool first_run) {
+  std::vector<BookmarkNode*> nodes_with_same_url;
+  model->GetNodesByURL(entry.url, &nodes_with_same_url);
+  if (nodes_with_same_url.empty())
+    return false;
+  
+  for (size_t i = 0; i < nodes_with_same_url.size(); ++i) {
+    BookmarkNode* node = nodes_with_same_url[i];
+    if (entry.title != node->GetTitle())
+      continue;
+
+    // Does the path match?
+    bool found_match = true;
+    BookmarkNode* parent = node->GetParent();
+    for (std::vector<std::wstring>::const_reverse_iterator path_it =
+             entry.path.rbegin();
+         (path_it != entry.path.rend()) && found_match; ++path_it) {
+      const std::wstring& folder_name =
+          (!first_run && path_it + 1 == entry.path.rend()) ?
+          first_folder_name : *path_it;
+      if (NULL == parent || *path_it != folder_name)
+        found_match = false;
+      else
+        parent = parent->GetParent();
+    }
+
+    // We need a post test to differentiate checks such as
+    // /home/hello and /hello. The parent should either by the other folder
+    // node, or the bookmarks bar, depending upon first_run and
+    // entry.in_toolbar.
+    if (found_match &&
+        ((first_run && entry.in_toolbar && parent !=
+          model->GetBookmarkBarNode()) ||
+         ((!first_run || !entry.in_toolbar) &&
+           parent != model->other_node()))) {
+      found_match = false;
+    }
+
+    if (found_match)
+      return true;  // Found a match with the same url path and title.
+  }
+  return false;
+}
+
 // Importer.
 
 // static
 bool Importer::ReencodeFavicon(const unsigned char* src_data, size_t src_len,
                                std::vector<unsigned char>* png_data) {
   // Decode the favicon using WebKit's image decoder.
   webkit_glue::ImageDecoder decoder(gfx::Size(kFavIconSize, kFavIconSize));
   SkBitmap decoded = decoder.Decode(src_data, src_len);
   if (decoded.empty())
     return false;  // Unable to decode.
@@ skipping 198 matching lines @@
   firefox_lock_.reset();  // Release the Firefox profile lock.
   if (observer_)
     observer_->ImportEnded();
   Release();
 }
 
 Importer* ImporterHost::CreateImporterByType(ProfileType type) {
   switch (type) {
     case MS_IE:
       return new IEImporter();
+    case BOOKMARKS_HTML:
     case FIREFOX2:
       return new Firefox2Importer();
     case FIREFOX3:
       return new Firefox3Importer();
     case GOOGLE_TOOLBAR5:
       return new Toolbar5Importer();
   }
   NOTREACHED();
   return NULL;
 }
@@ skipping 109 matching lines @@
     ProfileInfo* google_toolbar = new ProfileInfo();
     google_toolbar->browser_type = GOOGLE_TOOLBAR5;
     google_toolbar->description = l10n_util::GetString(
                                   IDS_IMPORT_FROM_GOOGLE_TOOLBAR);
     google_toolbar->source_path.clear();
     google_toolbar->app_path.clear();
     google_toolbar->services_supported = FAVORITES;
     source_profiles_.push_back(google_toolbar);
   }
 }