Importing certain bookmarks from firefox and HTML file as search engines.

chrome/utility/importer/firefox_importer.cc

 // Copyright 2013 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/utility/importer/firefox_importer.h"
 
 #include <set>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
@@ skipping 32 matching lines @@
 // Loads the default bookmarks in the Firefox installed at |app_path|,
 // and stores their locations in |urls|.
 void LoadDefaultBookmarks(const base::FilePath& app_path,
                           std::set<GURL>* urls) {
   base::FilePath file = app_path.AppendASCII("defaults")
       .AppendASCII("profile")
       .AppendASCII("bookmarks.html");
   urls->clear();
 
   std::vector<ImportedBookmarkEntry> bookmarks;
+  std::vector<importer::SearchEngineInfo> search_engines;
   bookmark_html_reader::ImportBookmarksFile(base::Callback<bool(void)>(),
                                             base::Callback<bool(const GURL&)>(),
                                             file,
                                             &bookmarks,
+                                            &search_engines,
                                             NULL);
   for (size_t i = 0; i < bookmarks.size(); ++i)
     urls->insert(bookmarks[i].url);
 }
 
 // Returns true if |url| has a valid scheme that we allow to import. We
 // filter out the URL with a unsupported scheme.
 bool CanImportURL(const GURL& url) {
   // The URL is not valid.
   if (!url.is_valid())
@@ skipping 151 matching lines @@
 
   BookmarkList list;
   GetTopBookmarkFolder(&db, toolbar_folder_id, &list);
   GetTopBookmarkFolder(&db, menu_folder_id, &list);
   GetTopBookmarkFolder(&db, unsorted_folder_id, &list);
   size_t count = list.size();
   for (size_t i = 0; i < count; ++i)
     GetWholeBookmarkFolder(&db, &list, i, NULL);
 
   std::vector<ImportedBookmarkEntry> bookmarks;
-  std::vector<importer::URLKeywordInfo> url_keywords;
+  std::vector<importer::SearchEngineInfo> search_engines;
   FaviconMap favicon_map;
 
   // TODO(jcampan): http://b/issue?id=1196285 we do not support POST based
   //                keywords yet.  We won't include them in the list.
   std::set<int> post_keyword_ids;
   const char query[] =
       "SELECT b.id FROM moz_bookmarks b "
       "INNER JOIN moz_items_annos ia ON ia.item_id = b.id "
       "INNER JOIN moz_anno_attributes aa ON ia.anno_attribute_id = aa.id "
       "WHERE aa.name = 'bookmarkProperties/POSTData'";
   sql::Statement s(db.GetUniqueStatement(query));
 
   if (!s.is_valid())
     return;
 
   while (s.Step() && !cancelled())
     post_keyword_ids.insert(s.ColumnInt(0));
 
   for (size_t i = 0; i < list.size(); ++i) {
     BookmarkItem* item = list[i];
 
-    if (item->type == TYPE_FOLDER) {
+    if (item->type != TYPE_BOOKMARK) {
       // Folders are added implicitly on adding children, so we only explicitly
       // add empty folders.
-      if (!item->empty_folder)
+      if ((item->type != TYPE_FOLDER) || !item->empty_folder)
         continue;
-    } else if (item->type == TYPE_BOOKMARK) {
-      // Import only valid bookmarks
-      if (!CanImportURL(item->url))
-        continue;
-    } else {
+    } else if (!CanImportURL(item->url)) {

[Peter Kasting, 2014/11/11 22:42:12]

This will only convert invalid bookmark URLs to search engines.  I'd think most
"search engines" would have valid bookmark URLs, e.g. "http://foo.com/?q=%s". 
Shouldn't we check CanImportURLAsSearchEngine() first?

[Tapu Ghose, 2014/11/15 05:22:20]

I think valid bookmark URLs are handled at line 327 (though it only looking for
URL with keywords).

[Peter Kasting, 2014/11/17 21:30:35]

It's really confusing that we add things as search engines in two different
places, and they have two different ways of constructing the SearchEngineInfo
object and two different URL validity checks.

Can we combine these into one place that handles everything, maybe by removing
the CanImportURL() check here and executing this stuff unconditionally?

[Tapu Ghose, 2014/12/07 02:49:54]

Agreed.

+      importer::SearchEngineInfo search_engine_info;
+      // Import invalid bookmark's keyword as search engine, provided that the
+      // bookmark's url is a valid search engine url.
+      if (!item->keyword.empty() &&

[Peter Kasting, 2014/11/11 22:42:12]

Shouldn't we be willing to import bookmarks with empty keywords too (and
autogenerate the keywords)?

[Tapu Ghose, 2014/11/15 05:22:20]

You are right.

+          bookmark_html_reader::CanImportURLAsSearchEngine(
+              item->url,
+              base::UTF8ToUTF16(item->keyword),
+              item->title,
+              &search_engine_info)) {
+        search_engines.push_back(search_engine_info);
+      }
       continue;
     }
 
     // Skip the default bookmarks and unwanted URLs.
     if (default_urls.find(item->url) != default_urls.end() ||
         post_keyword_ids.find(item->id) != post_keyword_ids.end())
       continue;
 
     // Find the bookmark path by tracing their links to parent folders.
     std::vector<base::string16> path;
@@ skipping 39 matching lines @@
     entry.is_folder = item->type == TYPE_FOLDER;
 
     bookmarks.push_back(entry);
 
     if (item->type == TYPE_BOOKMARK) {
       if (item->favicon)
         favicon_map[item->favicon].insert(item->url);
 
       // This bookmark has a keyword, we should import it.
       if (!item->keyword.empty() && item->url.is_valid()) {
-        importer::URLKeywordInfo url_keyword_info;
-        url_keyword_info.url = item->url;
-        url_keyword_info.keyword.assign(base::UTF8ToUTF16(item->keyword));
-        url_keyword_info.display_name = item->title;
-        url_keywords.push_back(url_keyword_info);
+        importer::SearchEngineInfo search_engine_info;
+        search_engine_info.url.assign(base::UTF8ToUTF16(item->url.spec()));
+        search_engine_info.keyword.assign(base::UTF8ToUTF16(item->keyword));
+        search_engine_info.display_name = item->title;
+        search_engines.push_back(search_engine_info);
       }
     }
   }
 
   STLDeleteElements(&list);
 
   // Write into profile.
   if (!bookmarks.empty() && !cancelled()) {
     const base::string16& first_folder_name =
         bridge_->GetLocalizedString(IDS_BOOKMARK_GROUP_FROM_FIREFOX);
     bridge_->AddBookmarks(bookmarks, first_folder_name);
   }
-  if (!url_keywords.empty() && !cancelled()) {
-    bridge_->SetKeywords(url_keywords, false);
+  if (!search_engines.empty() && !cancelled()) {
+    bridge_->SetKeywords(search_engines, false);
   }
   if (!favicon_map.empty() && !cancelled()) {
     std::vector<ImportedFaviconUsage> favicons;
     LoadFavicons(&db, favicon_map, &favicons);
     bridge_->SetFavicons(favicons);
   }
 }
 
 void FirefoxImporter::ImportPasswords() {
   // Initializes NSS3.
@@ skipping 423 matching lines @@
 
       if (!importer::ReencodeFavicon(&data[0], data.size(), &usage.png_data))
         continue;  // Unable to decode.
 
       usage.urls = i->second;
       favicons->push_back(usage);
     }
     s.Reset(true);
   }
 }