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