The browser importer code which runs in the utility process should not depend on chrome\browser dat…

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/files/file_enumerator.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/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/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/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;
@@ skipping 139 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<TemplateURL*> template_urls;
+  std::vector<importer::URLKeywordInfo> url_keywords;
   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));
@@ skipping 67 matching lines @@
     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 = CreateTemplateURL(
-          item->title, UTF8ToUTF16(item->keyword), item->url);
-      if (t_url)
-        template_urls.push_back(t_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(UTF8ToUTF16(item->keyword));
+        url_keyword_info.display_name = item->title;
+        url_keywords.push_back(url_keyword_info);
+      }
     }
   }
 
   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 (!url_keywords.empty() && !cancelled()) {
+    bridge_->SetKeywords(url_keywords, false);
+  }
   if (!favicon_map.empty() && !cancelled()) {
     std::vector<ImportedFaviconUsage> favicons;
     LoadFavicons(&db, favicon_map, &favicons);
     bridge_->SetFavicons(favicons);
   }
 }
 
 void Firefox3Importer::ImportPasswords() {
   // Initializes NSS3.
   NSSDecryptor decryptor;
@@ skipping 20 matching lines @@
   }
 
   if (!cancelled()) {
     for (size_t i = 0; i < forms.size(); ++i) {
       bridge_->SetPasswordForm(forms[i]);
     }
   }
 }
 
 void Firefox3Importer::ImportSearchEngines() {
-  std::vector<base::FilePath> files;
-  GetSearchEnginesXMLFiles(&files);
+  std::vector<std::string> search_engine_data;
+  GetSearchEnginesXMLData(&search_engine_data);
 
-  std::vector<TemplateURL*> search_engines;
-  ParseSearchEnginesFromXMLFiles(files, &search_engines);
-
-  bridge_->SetKeywords(search_engines, true);
+  bridge_->SetFirefoxSearchEnginesXMLData(search_engine_data);
 }
 
 void Firefox3Importer::ImportHomepage() {
   GURL home_page = GetHomepage(source_path_);
   if (home_page.is_valid() && !IsDefaultHomepage(home_page, app_path_)) {
     bridge_->AddHomePage(home_page);
   }
 }
 
-void Firefox3Importer::GetSearchEnginesXMLFiles(
-    std::vector<base::FilePath>* files) {
+void Firefox3Importer::GetSearchEnginesXMLData(
+    std::vector<std::string>* search_engine_data) {
   base::FilePath file = source_path_.AppendASCII("search.sqlite");
   if (!file_util::PathExists(file))
     return;
 
   sql::Connection db;
   if (!db.Open(file))
     return;
 
   const char* query = "SELECT engineid FROM engine_data "
                       "WHERE engineid NOT IN "
@@ skipping 26 matching lines @@
         // Remove '[app]/'.
         file = app_path.AppendASCII(engine.substr(index + kAppPrefix.length()));
       } else if ((index = engine.find(kProfilePrefix)) != std::string::npos) {
         // Remove '[profile]/'.
           file = profile_path.AppendASCII(
               engine.substr(index + kProfilePrefix.length()));
       } else {
         // Looks like absolute path to the file.
         file = base::FilePath::FromUTF8Unsafe(engine);
       }
-      files->push_back(file);
+      std::string file_data;
+      file_util::ReadFileToString(file, &file_data);
+      search_engine_data->push_back(file_data);
     } while (s.Step() && !cancelled());
   }
 
 #if defined(OS_POSIX)
   // Ubuntu-flavored Firefox3 supports locale-specific search engines via
   // locale-named subdirectories. They fall back to en-US.
   // See http://crbug.com/53899
   // TODO(jshin): we need to make sure our locale code matches that of
   // Firefox.
   DCHECK(!locale_.empty());
   base::FilePath locale_app_path = app_path.AppendASCII(locale_);
   base::FilePath default_locale_app_path = app_path.AppendASCII("en-US");
   if (file_util::DirectoryExists(locale_app_path))
     app_path = locale_app_path;
   else if (file_util::DirectoryExists(default_locale_app_path))
     app_path = default_locale_app_path;
 #endif
 
   // Get search engine definition from file system.
   base::FileEnumerator engines(app_path, false, base::FileEnumerator::FILES);
   for (base::FilePath engine_path = engines.Next();
        !engine_path.value().empty(); engine_path = engines.Next()) {
-    files->push_back(engine_path);
+    std::string file_data;
+    file_util::ReadFileToString(file, &file_data);
+    search_engine_data->push_back(file_data);
   }
 }
 
 void Firefox3Importer::LoadRootNodeID(sql::Connection* db,
                                       int* toolbar_folder_id,
                                       int* menu_folder_id,
                                       int* unsorted_folder_id) {
   static const char* kToolbarFolderName = "toolbar";
   static const char* kMenuFolderName = "menu";
   static const char* kUnsortedFolderName = "unfiled";
@@ skipping 125 matching lines @@
 
       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);
   }
 }