1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// 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.
#ifndef CHROME_BROWSER_IMPORTER_EXTERNAL_PROCESS_IMPORTER_CLIENT_H_
#define CHROME_BROWSER_IMPORTER_EXTERNAL_PROCESS_IMPORTER_CLIENT_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/weak_ptr.h"
#include "base/strings/string16.h"
#include "chrome/browser/history/history_types.h"
#include "chrome/common/importer/importer_autofill_form_data_entry.h"
#include "chrome/common/importer/importer_data_types.h"
#include "chrome/common/importer/importer_url_row.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/utility_process_host_client.h"
class ExternalProcessImporterHost;
struct ImportedBookmarkEntry;
struct ImportedFaviconUsage;
class InProcessImporterBridge;
namespace autofill {
struct PasswordForm;
}
namespace content{
class UtilityProcessHost;
}
namespace importer {
#if defined(OS_WIN)
struct ImporterIE7PasswordInfo;
#endif
struct ImporterAutofillFormDataEntry;
struct URLKeywordInfo;
}
// This class is the client for the out of process profile importing. It
// collects notifications from this process host and feeds data back to the
// importer host, who actually does the writing.
class ExternalProcessImporterClient : public content::UtilityProcessHostClient {
public:
ExternalProcessImporterClient(
base::WeakPtr<ExternalProcessImporterHost> importer_host,
const importer::SourceProfile& source_profile,
uint16 items,
InProcessImporterBridge* bridge);
// Launches the task to start the external process.
void Start();
// Called by the ExternalProcessImporterHost on import cancel.
void Cancel();
// UtilityProcessHostClient implementation:
virtual void OnProcessCrashed(int exit_code) OVERRIDE;
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
// Message handlers
void OnImportStart();
void OnImportFinished(bool succeeded, const std::string& error_msg);
void OnImportItemStart(int item);
void OnImportItemFinished(int item);
void OnHistoryImportStart(size_t total_history_rows_count);
void OnHistoryImportGroup(
const std::vector<ImporterURLRow>& history_rows_group,
int visit_source);
void OnHomePageImportReady(const GURL& home_page);
void OnBookmarksImportStart(const base::string16& first_folder_name,
size_t total_bookmarks_count);
void OnBookmarksImportGroup(
const std::vector<ImportedBookmarkEntry>& bookmarks_group);
void OnFaviconsImportStart(size_t total_favicons_count);
void OnFaviconsImportGroup(
const std::vector<ImportedFaviconUsage>& favicons_group);
void OnPasswordFormImportReady(const autofill::PasswordForm& form);
void OnKeywordsImportReady(
const std::vector<importer::URLKeywordInfo>& url_keywords,
bool unique_on_host_and_path);
void OnFirefoxSearchEngineDataReceived(
const std::vector<std::string> search_engine_data);
void OnAutofillFormDataImportStart(
size_t total_autofill_form_data_entry_count);
void OnAutofillFormDataImportGroup(const std::vector<
ImporterAutofillFormDataEntry>& autofill_form_data_entry_group);
#if defined(OS_WIN)
void OnIE7PasswordReceived(
const importer::ImporterIE7PasswordInfo& importer_password_info);
#endif
protected:
virtual ~ExternalProcessImporterClient();
private:
// Notifies the importerhost that import has finished, and calls Release().
void Cleanup();
// Cancel import process on IO thread.
void CancelImportProcessOnIOThread();
// Report item completely downloaded on IO thread.
void NotifyItemFinishedOnIOThread(importer::ImportItem import_item);
// Creates a new UtilityProcessHost, which launches the import process.
void StartProcessOnIOThread(content::BrowserThread::ID thread_id);
// These variables store data being collected from the importer until the
// entire group has been collected and is ready to be written to the profile.
std::vector<ImporterURLRow> history_rows_;
std::vector<ImportedBookmarkEntry> bookmarks_;
std::vector<ImportedFaviconUsage> favicons_;
std::vector<ImporterAutofillFormDataEntry> autofill_form_data_;
// Usually some variation on IDS_BOOKMARK_GROUP_...; the name of the folder
// under which imported bookmarks will be placed.
base::string16 bookmarks_first_folder_name_;
// Total number of bookmarks to import.
size_t total_bookmarks_count_;
// Total number of history items to import.
size_t total_history_rows_count_;
// Total number of favicons to import.
size_t total_favicons_count_;
// Total number of autofill form data entries to import.
size_t total_autofill_form_data_entry_count_;
// Notifications received from the ProfileImportProcessHost are passed back
// to process_importer_host_, which calls the ProfileWriter to record the
// import data. When the import process is done, process_importer_host_
// deletes itself. This is a weak ptr so that any messages received after
// the host has deleted itself are ignored (e.g., it's possible to receive
// OnProcessCrashed() after NotifyImportEnded()).
base::WeakPtr<ExternalProcessImporterHost> process_importer_host_;
// Handles sending messages to the external process. Deletes itself when
// the external process dies (see
// BrowserChildProcessHost::OnChildDisconnected).
base::WeakPtr<content::UtilityProcessHost> utility_process_host_;
// Data to be passed from the importer host to the external importer.
importer::SourceProfile source_profile_;
uint16 items_;
// Takes import data coming over IPC and delivers it to be written by the
// ProfileWriter.
scoped_refptr<InProcessImporterBridge> bridge_;
// True if import process has been cancelled.
bool cancelled_;
DISALLOW_COPY_AND_ASSIGN(ExternalProcessImporterClient);
};
#endif // CHROME_BROWSER_IMPORTER_EXTERNAL_PROCESS_IMPORTER_CLIENT_H_
|
