Extract BookmarksFileImporter from Firefox2Importer.

chrome/browser/importer/firefox3_importer.cc

 // Copyright (c) 2012 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/firefox3_importer.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/bookmarks/bookmark_html_reader.h"
+#include "chrome/browser/bookmarks/imported_bookmark_entry.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/history/history_types.h"
-#include "chrome/browser/importer/firefox2_importer.h"
+#include "chrome/browser/favicon/favicon_util.h"
+#include "chrome/browser/favicon/imported_favicon_usage.h"
 #include "chrome/browser/importer/firefox_importer_utils.h"
 #include "chrome/browser/importer/importer_bridge.h"
-#include "chrome/browser/importer/importer_util.h"
 #include "chrome/browser/importer/nss_decryptor.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/common/time_format.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/password_form.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Original definition is in http://mxr.mozilla.org/firefox/source/toolkit/
 //  components/places/public/nsINavBookmarksService.idl
 enum BookmarkItemType {
   TYPE_BOOKMARK = 1,
   TYPE_FOLDER = 2,
   TYPE_SEPARATOR = 3,
   TYPE_DYNAMIC_CONTAINER = 4
 };
 
+// Creates a TemplateURL with the |keyword| and |url|. |title| may be empty.
+// This function transfers ownership of the created TemplateURL to the caller.
+TemplateURL* CreateTemplateURL(const string16& title,
+                               const string16& keyword,
+                               const GURL& url) {
+  // Skip if the keyword or url is invalid.
+  if (keyword.empty() || !url.is_valid())
+    return NULL;
+
+  TemplateURLData data;
+  // We set short name by using the title if it exists.
+  // Otherwise, we use the shortcut.
+  data.short_name = title.empty() ? keyword : title;
+  data.SetKeyword(keyword);
+  data.SetURL(TemplateURLRef::DisplayURLToURLRef(UTF8ToUTF16(url.spec())));
+  return new TemplateURL(NULL, data);
+}
+
+// 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;
+  bookmark_html_reader::ImportBookmarksFile(base::Callback<bool(void)>(),
+                                            base::Callback<bool(const GURL&)>(),
+                                            file,
+                                            &bookmarks,
+                                            NULL);
+  for (size_t i = 0; i < bookmarks.size(); ++i)
+    urls->insert(bookmarks[i].url);
+}
+
 }  // namespace
 
 struct Firefox3Importer::BookmarkItem {
   int parent;
   int id;
   GURL url;
   string16 title;
   BookmarkItemType type;
   std::string keyword;
   base::Time date_added;
@@ skipping 110 matching lines @@
   // Get the bookmark folders that we are interested in.
   int toolbar_folder_id = -1;
   int menu_folder_id = -1;
   int unsorted_folder_id = -1;
   LoadRootNodeID(&db, &toolbar_folder_id, &menu_folder_id, &unsorted_folder_id);
 
   // Load livemark IDs.
   std::set<int> livemark_id;
   LoadLivemarkIDs(&db, &livemark_id);
 
-  // Load the default bookmarks. Its storage is the same as Firefox 2.
+  // Load the default bookmarks.
   std::set<GURL> default_urls;
-  Firefox2Importer::LoadDefaultBookmarks(app_path_, &default_urls);
+  LoadDefaultBookmarks(app_path_, &default_urls);
 
   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<ProfileWriter::BookmarkEntry> bookmarks;
+  std::vector<ImportedBookmarkEntry> bookmarks;
   std::vector<TemplateURL*> template_urls;
   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'";
@@ skipping 54 matching lines @@
         found_path = true;
         break;
       }
 
       child = parent;
     }
 
     if (!found_path)
       continue;
 
-    ProfileWriter::BookmarkEntry entry;
+    ImportedBookmarkEntry entry;
     entry.creation_time = item->date_added;
     entry.title = item->title;
     entry.url = item->url;
     entry.path = path;
     entry.in_toolbar = is_in_toolbar;
     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 import it to our TemplateURL model.
-      TemplateURL* t_url = Firefox2Importer::CreateTemplateURL(
+      TemplateURL* t_url = CreateTemplateURL(
           item->title, UTF8ToUTF16(item->keyword), item->url);
       if (t_url)
         template_urls.push_back(t_url);
     }
   }
 
   STLDeleteElements(&list);
 
   // Write into profile.
   if (!bookmarks.empty() && !cancelled()) {
     const string16& first_folder_name =
         bridge_->GetLocalizedString(IDS_BOOKMARK_GROUP_FROM_FIREFOX);
     bridge_->AddBookmarks(bookmarks, first_folder_name);
   }
   if (!template_urls.empty() && !cancelled())
     bridge_->SetKeywords(template_urls, false);
   else
     STLDeleteElements(&template_urls);
   if (!favicon_map.empty() && !cancelled()) {
-    std::vector<history::ImportedFaviconUsage> favicons;
+    std::vector<ImportedFaviconUsage> favicons;
     LoadFavicons(&db, favicon_map, &favicons);
     bridge_->SetFavicons(favicons);
   }
 }
 
 void Firefox3Importer::ImportPasswords() {
   // Initializes NSS3.
   NSSDecryptor decryptor;
   if (!decryptor.Init(source_path_, source_path_) &&
       !decryptor.Init(app_path_, source_path_)) {
@@ skipping 224 matching lines @@
     list->push_back(*i);
     // Recursive add bookmarks in sub-folders.
     if ((*i)->type == TYPE_FOLDER)
       GetWholeBookmarkFolder(db, list, list->size() - 1, &(*i)->empty_folder);
   }
 }
 
 void Firefox3Importer::LoadFavicons(
     sql::Connection* db,
     const FaviconMap& favicon_map,
-    std::vector<history::ImportedFaviconUsage>* favicons) {
+    std::vector<ImportedFaviconUsage>* favicons) {
   const char* query = "SELECT url, data FROM moz_favicons WHERE id=?";
   sql::Statement s(db->GetUniqueStatement(query));
 
   if (!s.is_valid())
     return;
 
   for (FaviconMap::const_iterator i = favicon_map.begin();
        i != favicon_map.end(); ++i) {
     s.BindInt64(0, i->first);
     if (s.Step()) {
-      history::ImportedFaviconUsage usage;
+      ImportedFaviconUsage usage;
 
       usage.favicon_url = GURL(s.ColumnString(0));
       if (!usage.favicon_url.is_valid())
         continue;  // Don't bother importing favicons with invalid URLs.
 
       std::vector<unsigned char> data;
       s.ColumnBlobAsVector(1, &data);
       if (data.empty())
         continue;  // Data definitely invalid.
 
-      if (!importer::ReencodeFavicon(&data[0], data.size(), &usage.png_data))
+      if (!FaviconUtil::ReencodeFavicon(&data[0], data.size(), &usage.png_data))
         continue;  // Unable to decode.
 
       usage.urls = i->second;
       favicons->push_back(usage);
     }
     s.Reset(true);
   }
 }