chrome/browser/importer/in_process_importer_bridge.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/importer/in_process_importer_bridge.h"
   6
   7 #include "base/bind.h"
   8 #include "base/debug/dump_without_crashing.h"
   9 #include "base/files/file_util.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/importer/external_process_importer_host.h"
  13 #include "chrome/browser/search_engines/ui_thread_search_terms_data.h"
  14 #include "chrome/common/importer/imported_bookmark_entry.h"
  15 #include "chrome/common/importer/imported_favicon_usage.h"
  16 #include "chrome/common/importer/importer_autofill_form_data_entry.h"
  17 #include "components/autofill/core/browser/webdata/autofill_entry.h"
  18 #include "components/autofill/core/common/password_form.h"
  19 #include "components/search_engines/template_url.h"
  20 #include "components/search_engines/template_url_parser.h"
  21 #include "components/search_engines/template_url_prepopulate_data.h"
  22 #include "content/public/browser/browser_thread.h"
  23 #include "ui/base/l10n/l10n_util.h"
  24
  25 #if defined(OS_WIN)
  26 #include "components/os_crypt/ie7_password_win.h"
  27 #endif
  28
  29 #include <iterator>
  30
  31 namespace {
  32
  33 history::URLRows ConvertImporterURLRowsToHistoryURLRows(
  34     const std::vector<ImporterURLRow>& rows) {
  35   history::URLRows converted;
  36   converted.reserve(rows.size());
  37   for (std::vector<ImporterURLRow>::const_iterator it = rows.begin();
  38        it != rows.end(); ++it) {
  39     history::URLRow row(it->url);
  40     row.set_title(it->title);
  41     row.set_visit_count(it->visit_count);
  42     row.set_typed_count(it->typed_count);
  43     row.set_last_visit(it->last_visit);
  44     row.set_hidden(it->hidden);
  45     converted.push_back(row);
  46   }
  47   return converted;
  48 }
  49
  50 history::VisitSource ConvertImporterVisitSourceToHistoryVisitSource(
  51     importer::VisitSource visit_source) {
  52   switch (visit_source) {
  53     case importer::VISIT_SOURCE_BROWSED:
  54       return history::SOURCE_BROWSED;
  55     case importer::VISIT_SOURCE_FIREFOX_IMPORTED:
  56       return history::SOURCE_FIREFOX_IMPORTED;
  57     case importer::VISIT_SOURCE_IE_IMPORTED:
  58       return history::SOURCE_IE_IMPORTED;
  59     case importer::VISIT_SOURCE_SAFARI_IMPORTED:
  60       return history::SOURCE_SAFARI_IMPORTED;
  61   }
  62   NOTREACHED();
  63   return history::SOURCE_SYNCED;
  64 }
  65
  66 // http://crbug.com/404012. Let's see where the empty fields come from.
  67 void CheckForEmptyUsernameAndPassword(const autofill::PasswordForm& form) {
  68   if (form.username_value.empty() &&
  69       form.password_value.empty() &&
  70       !form.blacklisted_by_user) {
  71     base::debug::DumpWithoutCrashing();
  72   }
  73 }
  74
  75 }  // namespace
  76
  77 using content::BrowserThread;
  78
  79 namespace {
  80
  81 // FirefoxURLParameterFilter is used to remove parameter mentioning Firefox from
  82 // the search URL when importing search engines.
  83 class FirefoxURLParameterFilter : public TemplateURLParser::ParameterFilter {
  84  public:
  85   FirefoxURLParameterFilter() {}
  86   virtual ~FirefoxURLParameterFilter() {}
  87
  88   // TemplateURLParser::ParameterFilter method.
  89   virtual bool KeepParameter(const std::string& key,
  90                              const std::string& value) OVERRIDE {
  91     std::string low_value = base::StringToLowerASCII(value);
  92     if (low_value.find("mozilla") != std::string::npos ||
  93         low_value.find("firefox") != std::string::npos ||
  94         low_value.find("moz:") != std::string::npos) {
  95       return false;
  96     }
  97     return true;
  98   }
  99
 100  private:
 101   DISALLOW_COPY_AND_ASSIGN(FirefoxURLParameterFilter);
 102 };
 103
 104 // Creates a TemplateURL with the |keyword| and |url|. |title| may be empty.
 105 // This function transfers ownership of the created TemplateURL to the caller.
 106 TemplateURL* CreateTemplateURL(const base::string16& title,
 107                                const base::string16& keyword,
 108                                const GURL& url) {
 109   // Skip if the url is invalid.
 110   if (!url.is_valid())
 111     return NULL;
 112
 113   TemplateURLData data;
 114   if (keyword.empty())
 115     data.SetKeyword(TemplateURL::GenerateKeyword(url));
 116   else
 117     data.SetKeyword(keyword);
 118   // We set short name by using the title if it exists.
 119   // Otherwise, we use the shortcut.
 120   data.short_name = title.empty() ? keyword : title;
 121   data.SetURL(
 122       TemplateURLRef::DisplayURLToURLRef(base::UTF8ToUTF16(url.spec())));
 123   return new TemplateURL(data);
 124 }
 125
 126 // Parses the OpenSearch XML files in |xml_files| and populates |search_engines|
 127 // with the resulting TemplateURLs.
 128 void ParseSearchEnginesFromFirefoxXMLData(
 129     const std::vector<std::string>& xml_data,
 130     std::vector<TemplateURL*>* search_engines) {
 131   DCHECK(search_engines);
 132
 133   typedef std::map<std::string, TemplateURL*> SearchEnginesMap;
 134   SearchEnginesMap search_engine_for_url;
 135   FirefoxURLParameterFilter param_filter;
 136   // The first XML file represents the default search engine in Firefox 3, so we
 137   // need to keep it on top of the list.
 138   SearchEnginesMap::const_iterator default_turl = search_engine_for_url.end();
 139   for (std::vector<std::string>::const_iterator xml_iter =
 140            xml_data.begin(); xml_iter != xml_data.end(); ++xml_iter) {
 141     TemplateURL* template_url = TemplateURLParser::Parse(
 142         UIThreadSearchTermsData(NULL), true,
 143         xml_iter->data(), xml_iter->length(), &param_filter);
 144     if (template_url) {
 145       SearchEnginesMap::iterator iter =
 146           search_engine_for_url.find(template_url->url());
 147       if (iter == search_engine_for_url.end()) {
 148         iter = search_engine_for_url.insert(
 149             std::make_pair(template_url->url(), template_url)).first;
 150       } else {
 151         // We have already found a search engine with the same URL.  We give
 152         // priority to the latest one found, as GetSearchEnginesXMLFiles()
 153         // returns a vector with first Firefox default search engines and then
 154         // the user's ones.  We want to give priority to the user ones.
 155         delete iter->second;
 156         iter->second = template_url;
 157       }
 158       if (default_turl == search_engine_for_url.end())
 159         default_turl = iter;
 160     }
 161   }
 162
 163   // Put the results in the |search_engines| vector.
 164   for (SearchEnginesMap::iterator t_iter = search_engine_for_url.begin();
 165        t_iter != search_engine_for_url.end(); ++t_iter) {
 166     if (t_iter == default_turl)
 167       search_engines->insert(search_engines->begin(), default_turl->second);
 168     else
 169       search_engines->push_back(t_iter->second);
 170   }
 171 }
 172
 173 }  // namespace
 174
 175 InProcessImporterBridge::InProcessImporterBridge(
 176     ProfileWriter* writer,
 177     base::WeakPtr<ExternalProcessImporterHost> host) : writer_(writer),
 178                                                        host_(host) {
 179 }
 180
 181 void InProcessImporterBridge::AddBookmarks(
 182     const std::vector<ImportedBookmarkEntry>& bookmarks,
 183     const base::string16& first_folder_name) {
 184   BrowserThread::PostTask(
 185       BrowserThread::UI, FROM_HERE,
 186       base::Bind(&ProfileWriter::AddBookmarks, writer_, bookmarks,
 187                  first_folder_name));
 188 }
 189
 190 void InProcessImporterBridge::AddHomePage(const GURL& home_page) {
 191   BrowserThread::PostTask(
 192       BrowserThread::UI, FROM_HERE,
 193       base::Bind(&ProfileWriter::AddHomepage, writer_, home_page));
 194 }
 195
 196 #if defined(OS_WIN)
 197 void InProcessImporterBridge::AddIE7PasswordInfo(
 198     const importer::ImporterIE7PasswordInfo& password_info) {
 199   IE7PasswordInfo ie7_password_info;
 200   ie7_password_info.url_hash = password_info.url_hash;
 201   ie7_password_info.encrypted_data = password_info.encrypted_data;
 202   ie7_password_info.date_created = password_info.date_created;
 203
 204   BrowserThread::PostTask(
 205       BrowserThread::UI, FROM_HERE,
 206       base::Bind(&ProfileWriter::AddIE7PasswordInfo, writer_,
 207                  ie7_password_info));
 208 }
 209 #endif  // OS_WIN
 210
 211 void InProcessImporterBridge::SetFavicons(
 212     const std::vector<ImportedFaviconUsage>& favicons) {
 213   BrowserThread::PostTask(
 214       BrowserThread::UI, FROM_HERE,
 215       base::Bind(&ProfileWriter::AddFavicons, writer_, favicons));
 216 }
 217
 218 void InProcessImporterBridge::SetHistoryItems(
 219     const std::vector<ImporterURLRow>& rows,
 220     importer::VisitSource visit_source) {
 221   history::URLRows converted_rows =
 222       ConvertImporterURLRowsToHistoryURLRows(rows);
 223   history::VisitSource converted_visit_source =
 224       ConvertImporterVisitSourceToHistoryVisitSource(visit_source);
 225   BrowserThread::PostTask(BrowserThread::UI,
 226                           FROM_HERE,
 227                           base::Bind(&ProfileWriter::AddHistoryPage,
 228                                      writer_,
 229                                      converted_rows,
 230                                      converted_visit_source));
 231 }
 232
 233 void InProcessImporterBridge::SetKeywords(
 234     const std::vector<importer::URLKeywordInfo>& url_keywords,
 235     bool unique_on_host_and_path) {
 236   ScopedVector<TemplateURL> owned_template_urls;
 237   for (size_t i = 0; i < url_keywords.size(); ++i) {
 238     owned_template_urls.push_back(
 239         CreateTemplateURL(url_keywords[i].display_name,
 240                           url_keywords[i].keyword,
 241                           url_keywords[i].url));
 242   }
 243   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 244       base::Bind(&ProfileWriter::AddKeywords, writer_,
 245                  base::Passed(&owned_template_urls), unique_on_host_and_path));
 246 }
 247
 248 void InProcessImporterBridge::SetFirefoxSearchEnginesXMLData(
 249     const std::vector<std::string>& search_engine_data) {
 250   std::vector<TemplateURL*> search_engines;
 251   ParseSearchEnginesFromFirefoxXMLData(search_engine_data, &search_engines);
 252
 253   ScopedVector<TemplateURL> owned_template_urls;
 254   std::copy(search_engines.begin(), search_engines.end(),
 255             std::back_inserter(owned_template_urls));
 256
 257   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 258       base::Bind(&ProfileWriter::AddKeywords, writer_,
 259                  base::Passed(&owned_template_urls), true));
 260 }
 261
 262 void InProcessImporterBridge::SetPasswordForm(
 263     const autofill::PasswordForm& form) {
 264   CheckForEmptyUsernameAndPassword(form);
 265   BrowserThread::PostTask(
 266       BrowserThread::UI, FROM_HERE,
 267       base::Bind(&ProfileWriter::AddPasswordForm, writer_, form));
 268 }
 269
 270 void InProcessImporterBridge::SetAutofillFormData(
 271     const std::vector<ImporterAutofillFormDataEntry>& entries) {
 272   std::vector<autofill::AutofillEntry> autofill_entries;
 273   for (size_t i = 0; i < entries.size(); ++i) {
 274     autofill_entries.push_back(autofill::AutofillEntry(
 275         autofill::AutofillKey(entries[i].name, entries[i].value),
 276         entries[i].first_used,
 277         entries[i].last_used));
 278   }
 279
 280   BrowserThread::PostTask(BrowserThread::UI,
 281                           FROM_HERE,
 282                           base::Bind(&ProfileWriter::AddAutofillFormDataEntries,
 283                                      writer_,
 284                                      autofill_entries));
 285 }
 286
 287 void InProcessImporterBridge::NotifyStarted() {
 288   BrowserThread::PostTask(
 289       BrowserThread::UI, FROM_HERE,
 290       base::Bind(&ExternalProcessImporterHost::NotifyImportStarted, host_));
 291 }
 292
 293 void InProcessImporterBridge::NotifyItemStarted(importer::ImportItem item) {
 294   BrowserThread::PostTask(
 295       BrowserThread::UI, FROM_HERE,
 296       base::Bind(&ExternalProcessImporterHost::NotifyImportItemStarted,
 297                  host_, item));
 298 }
 299
 300 void InProcessImporterBridge::NotifyItemEnded(importer::ImportItem item) {
 301   BrowserThread::PostTask(
 302       BrowserThread::UI, FROM_HERE,
 303       base::Bind(&ExternalProcessImporterHost::NotifyImportItemEnded,
 304                  host_, item));
 305 }
 306
 307 void InProcessImporterBridge::NotifyEnded() {
 308   BrowserThread::PostTask(
 309       BrowserThread::UI, FROM_HERE,
 310       base::Bind(&ExternalProcessImporterHost::NotifyImportEnded, host_));
 311 }
 312
 313 base::string16 InProcessImporterBridge::GetLocalizedString(int message_id) {
 314   return l10n_util::GetStringUTF16(message_id);
 315 }
 316
 317 InProcessImporterBridge::~InProcessImporterBridge() {}