Home | History | Annotate | Download | only in options 
      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/ui/webui/options/import_data_handler.h"
      6 
      7 #include <string>
      8 
      9 #include "base/basictypes.h"
     10 #include "base/bind.h"
     11 #include "base/bind_helpers.h"
     12 #include "base/memory/scoped_ptr.h"
     13 #include "base/strings/string16.h"
     14 #include "base/strings/string_number_conversions.h"
     15 #include "base/strings/string_util.h"
     16 #include "base/strings/utf_string_conversions.h"
     17 #include "base/threading/thread_restrictions.h"
     18 #include "base/values.h"
     19 #include "chrome/browser/browser_process.h"
     20 #include "chrome/browser/importer/external_process_importer_host.h"
     21 #include "chrome/browser/importer/importer_list.h"
     22 #include "chrome/browser/importer/importer_uma.h"
     23 #include "chrome/browser/profiles/profile.h"
     24 #include "chrome/browser/ui/browser_finder.h"
     25 #include "chrome/browser/ui/browser_window.h"
     26 #include "chrome/browser/ui/chrome_select_file_policy.h"
     27 #include "chrome/grit/chromium_strings.h"
     28 #include "chrome/grit/generated_resources.h"
     29 #include "content/public/browser/browser_thread.h"
     30 #include "content/public/browser/web_ui.h"
     31 
     32 using content::BrowserThread;
     33 
     34 namespace options {
     35 
     36 ImportDataHandler::ImportDataHandler()
     37     : importer_host_(NULL),
     38       import_did_succeed_(false) {
     39   DCHECK_CURRENTLY_ON(BrowserThread::UI);
     40 }
     41 
     42 ImportDataHandler::~ImportDataHandler() {
     43   DCHECK_CURRENTLY_ON(BrowserThread::UI);
     44 
     45   if (importer_host_)
     46     importer_host_->set_observer(NULL);
     47 
     48   if (select_file_dialog_.get())
     49     select_file_dialog_->ListenerDestroyed();
     50 }
     51 
     52 void ImportDataHandler::GetLocalizedValues(
     53     base::DictionaryValue* localized_strings) {
     54   DCHECK_CURRENTLY_ON(BrowserThread::UI);
     55   DCHECK(localized_strings);
     56 
     57   static OptionsStringResource resources[] = {
     58     {"importFromLabel", IDS_IMPORT_FROM_LABEL},
     59     {"importLoading", IDS_IMPORT_LOADING_PROFILES},
     60     {"importDescription", IDS_IMPORT_ITEMS_LABEL},
     61     {"importHistory", IDS_IMPORT_HISTORY_CHKBOX},
     62     {"importFavorites", IDS_IMPORT_FAVORITES_CHKBOX},
     63     {"importSearch", IDS_IMPORT_SEARCH_ENGINES_CHKBOX},
     64     {"importPasswords", IDS_IMPORT_PASSWORDS_CHKBOX},
     65     {"importAutofillFormData", IDS_IMPORT_AUTOFILL_FORM_DATA_CHKBOX},
     66     {"importChooseFile", IDS_IMPORT_CHOOSE_FILE},
     67     {"importCommit", IDS_IMPORT_COMMIT},
     68     {"noProfileFound", IDS_IMPORT_NO_PROFILE_FOUND},
     69     {"importSucceeded", IDS_IMPORT_SUCCEEDED},
     70     {"findYourImportedBookmarks", IDS_IMPORT_FIND_YOUR_BOOKMARKS},
     71 #if defined(OS_MACOSX)
     72     {"macPasswordKeychain", IDS_IMPORT_PASSWORD_KEYCHAIN_WARNING},
     73 #endif
     74   };
     75 
     76   RegisterStrings(localized_strings, resources, arraysize(resources));
     77   RegisterTitle(localized_strings, "importDataOverlay",
     78                 IDS_IMPORT_SETTINGS_TITLE);
     79 }
     80 
     81 void ImportDataHandler::InitializeHandler() {
     82   DCHECK_CURRENTLY_ON(BrowserThread::UI);
     83 
     84   importer_list_.reset(new ImporterList());
     85   importer_list_->DetectSourceProfiles(
     86       g_browser_process->GetApplicationLocale(),
     87       true,  // include_interactive_profiles?
     88       base::Bind(&ImportDataHandler::InitializePage, base::Unretained(this)));
     89 }
     90 
     91 void ImportDataHandler::RegisterMessages() {
     92   DCHECK_CURRENTLY_ON(BrowserThread::UI);
     93 
     94   web_ui()->RegisterMessageCallback(
     95       "importData",
     96       base::Bind(&ImportDataHandler::ImportData, base::Unretained(this)));
     97   web_ui()->RegisterMessageCallback(
     98       "chooseBookmarksFile",
     99       base::Bind(&ImportDataHandler::HandleChooseBookmarksFile,
    100                  base::Unretained(this)));
    101 }
    102 
    103 void ImportDataHandler::StartImport(
    104     const importer::SourceProfile& source_profile,
    105     uint16 imported_items) {
    106   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    107 
    108   if (!imported_items)
    109     return;
    110 
    111   // If another import is already ongoing, let it finish silently.
    112   if (importer_host_)
    113     importer_host_->set_observer(NULL);
    114 
    115   base::FundamentalValue importing(true);
    116   web_ui()->CallJavascriptFunction("ImportDataOverlay.setImportingState",
    117                                    importing);
    118   import_did_succeed_ = false;
    119 
    120   importer_host_ = new ExternalProcessImporterHost();
    121   importer_host_->set_observer(this);
    122   Profile* profile = Profile::FromWebUI(web_ui());
    123   importer_host_->StartImportSettings(source_profile, profile,
    124                                       imported_items,
    125                                       new ProfileWriter(profile));
    126 
    127   importer::LogImporterUseToMetrics("ImportDataHandler",
    128                                     source_profile.importer_type);
    129 }
    130 
    131 void ImportDataHandler::ImportData(const base::ListValue* args) {
    132   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    133 
    134   std::string string_value;
    135 
    136   int browser_index;
    137   if (!args->GetString(0, &string_value) ||
    138       !base::StringToInt(string_value, &browser_index)) {
    139     NOTREACHED();
    140     return;
    141   }
    142 
    143   uint16 selected_items = importer::NONE;
    144   if (args->GetString(1, &string_value) && string_value == "true") {
    145     selected_items |= importer::HISTORY;
    146   }
    147   if (args->GetString(2, &string_value) && string_value == "true") {
    148     selected_items |= importer::FAVORITES;
    149   }
    150   if (args->GetString(3, &string_value) && string_value == "true") {
    151     selected_items |= importer::PASSWORDS;
    152   }
    153   if (args->GetString(4, &string_value) && string_value == "true") {
    154     selected_items |= importer::SEARCH_ENGINES;
    155   }
    156   if (args->GetString(5, &string_value) && string_value == "true") {
    157     selected_items |= importer::AUTOFILL_FORM_DATA;
    158   }
    159 
    160   const importer::SourceProfile& source_profile =
    161       importer_list_->GetSourceProfileAt(browser_index);
    162   uint16 supported_items = source_profile.services_supported;
    163 
    164   uint16 imported_items = (selected_items & supported_items);
    165   if (imported_items) {
    166     StartImport(source_profile, imported_items);
    167   } else {
    168     LOG(WARNING) << "There were no settings to import from '"
    169         << source_profile.importer_name << "'.";
    170   }
    171 }
    172 
    173 void ImportDataHandler::InitializePage() {
    174   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    175 
    176   base::ListValue browser_profiles;
    177   for (size_t i = 0; i < importer_list_->count(); ++i) {
    178     const importer::SourceProfile& source_profile =
    179         importer_list_->GetSourceProfileAt(i);
    180     uint16 browser_services = source_profile.services_supported;
    181 
    182     base::DictionaryValue* browser_profile = new base::DictionaryValue();
    183     browser_profile->SetString("name", source_profile.importer_name);
    184     browser_profile->SetInteger("index", i);
    185     browser_profile->SetBoolean("history",
    186         (browser_services & importer::HISTORY) != 0);
    187     browser_profile->SetBoolean("favorites",
    188         (browser_services & importer::FAVORITES) != 0);
    189     browser_profile->SetBoolean("passwords",
    190         (browser_services & importer::PASSWORDS) != 0);
    191     browser_profile->SetBoolean("search",
    192         (browser_services & importer::SEARCH_ENGINES) != 0);
    193     browser_profile->SetBoolean("autofill-form-data",
    194         (browser_services & importer::AUTOFILL_FORM_DATA) != 0);
    195 
    196     browser_profile->SetBoolean("show_bottom_bar",
    197 #if defined(OS_MACOSX)
    198         source_profile.importer_type == importer::TYPE_SAFARI);
    199 #else
    200         false);
    201 #endif
    202 
    203     browser_profiles.Append(browser_profile);
    204   }
    205 
    206   web_ui()->CallJavascriptFunction("ImportDataOverlay.updateSupportedBrowsers",
    207                                    browser_profiles);
    208 }
    209 
    210 void ImportDataHandler::ImportStarted() {
    211   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    212 }
    213 
    214 void ImportDataHandler::ImportItemStarted(importer::ImportItem item) {
    215   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    216 
    217   // TODO(csilv): show progress detail in the web view.
    218 }
    219 
    220 void ImportDataHandler::ImportItemEnded(importer::ImportItem item) {
    221   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    222 
    223   // TODO(csilv): show progress detail in the web view.
    224   import_did_succeed_ = true;
    225 }
    226 
    227 void ImportDataHandler::ImportEnded() {
    228   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    229 
    230   importer_host_->set_observer(NULL);
    231   importer_host_ = NULL;
    232 
    233   if (import_did_succeed_) {
    234     web_ui()->CallJavascriptFunction("ImportDataOverlay.confirmSuccess");
    235   } else {
    236     base::FundamentalValue state(false);
    237     web_ui()->CallJavascriptFunction("ImportDataOverlay.setImportingState",
    238                                      state);
    239     web_ui()->CallJavascriptFunction("ImportDataOverlay.dismiss");
    240   }
    241 }
    242 
    243 void ImportDataHandler::FileSelected(const base::FilePath& path,
    244                                      int /*index*/,
    245                                      void* /*params*/) {
    246   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    247 
    248   importer::SourceProfile source_profile;
    249   source_profile.importer_type = importer::TYPE_BOOKMARKS_FILE;
    250   source_profile.source_path = path;
    251 
    252   StartImport(source_profile, importer::FAVORITES);
    253 }
    254 
    255 void ImportDataHandler::HandleChooseBookmarksFile(const base::ListValue* args) {
    256   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    257 
    258   DCHECK(args && args->empty());
    259   select_file_dialog_ = ui::SelectFileDialog::Create(
    260       this, new ChromeSelectFilePolicy(web_ui()->GetWebContents()));
    261 
    262   ui::SelectFileDialog::FileTypeInfo file_type_info;
    263   file_type_info.extensions.resize(1);
    264   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("html"));
    265 
    266   Browser* browser =
    267       chrome::FindBrowserWithWebContents(web_ui()->GetWebContents());
    268 
    269   select_file_dialog_->SelectFile(ui::SelectFileDialog::SELECT_OPEN_FILE,
    270                                   base::string16(),
    271                                   base::FilePath(),
    272                                   &file_type_info,
    273                                   0,
    274                                   base::FilePath::StringType(),
    275                                   browser->window()->GetNativeWindow(),
    276                                   NULL);
    277 }
    278 
    279 }  // namespace options
    280