1// Copyright 2013 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// Multiply-included message file, no traditonal include guard.
6#include <string>
7#include <vector>
8
9#include "base/basictypes.h"
10#include "base/strings/string16.h"
11#include "base/values.h"
12#include "chrome/common/common_param_traits_macros.h"
13#include "chrome/common/importer/imported_bookmark_entry.h"
14#include "chrome/common/importer/imported_favicon_usage.h"
15#include "chrome/common/importer/importer_data_types.h"
16#include "chrome/common/importer/importer_url_row.h"
17#include "components/autofill/content/common/autofill_param_traits_macros.h"
18#include "components/autofill/core/common/password_form.h"
19#include "content/public/common/common_param_traits.h"
20#include "ipc/ipc_message_macros.h"
21#include "ipc/ipc_message_utils.h"
22
23#ifndef CHROME_COMMON_IMPORTER_PROFILE_IMPORT_PROCESS_MESSAGES_H_
24#define CHROME_COMMON_IMPORTER_PROFILE_IMPORT_PROCESS_MESSAGES_H_
25
26namespace IPC {
27
28// Traits for importer::SourceProfile struct to pack/unpack.
29template <>
30struct ParamTraits<importer::SourceProfile> {
31  typedef importer::SourceProfile param_type;
32  static void Write(Message* m, const param_type& p) {
33    WriteParam(m, p.importer_name);
34    WriteParam(m, static_cast<int>(p.importer_type));
35    WriteParam(m, p.source_path);
36    WriteParam(m, p.app_path);
37    WriteParam(m, static_cast<int>(p.services_supported));
38    WriteParam(m, p.locale);
39  }
40  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
41    if (!ReadParam(m, iter, &p->importer_name))
42      return false;
43
44    int importer_type = 0;
45    if (!ReadParam(m, iter, &importer_type))
46      return false;
47    p->importer_type = static_cast<importer::ImporterType>(importer_type);
48
49    if (!ReadParam(m, iter, &p->source_path) ||
50        !ReadParam(m, iter, &p->app_path)) {
51        return false;
52    }
53
54    int services_supported = 0;
55    if (!ReadParam(m, iter, &services_supported))
56      return false;
57    p->services_supported = static_cast<uint16>(services_supported);
58
59    if (!ReadParam(m, iter, &p->locale))
60      return false;
61
62    return true;
63  }
64  static void Log(const param_type& p, std::string* l) {
65    l->append("(");
66    LogParam(p.importer_name, l);
67    l->append(", ");
68    LogParam(static_cast<int>(p.importer_type), l);
69    l->append(", ");
70    LogParam(p.source_path, l);
71    l->append(", ");
72    LogParam(p.app_path, l);
73    l->append(", ");
74    LogParam(static_cast<int>(p.services_supported), l);
75    l->append(", ");
76    LogParam(p.locale, l);
77    l->append(")");
78  }
79};  // ParamTraits<importer::SourceProfile>
80
81// Traits for ImporterURLRow to pack/unpack.
82template <>
83struct ParamTraits<ImporterURLRow> {
84  typedef ImporterURLRow param_type;
85  static void Write(Message* m, const param_type& p) {
86    WriteParam(m, p.url);
87    WriteParam(m, p.title);
88    WriteParam(m, p.visit_count);
89    WriteParam(m, p.typed_count);
90    WriteParam(m, p.last_visit);
91    WriteParam(m, p.hidden);
92  }
93  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
94    GURL url;
95    base::string16 title;
96    int visit_count, typed_count;
97    base::Time last_visit;
98    bool hidden;
99    if (!ReadParam(m, iter, &url) ||
100        !ReadParam(m, iter, &title) ||
101        !ReadParam(m, iter, &visit_count) ||
102        !ReadParam(m, iter, &typed_count) ||
103        !ReadParam(m, iter, &last_visit) ||
104        !ReadParam(m, iter, &hidden))
105      return false;
106    *p = ImporterURLRow(url);
107    p->title = title;
108    p->visit_count = visit_count;
109    p->typed_count = typed_count;
110    p->last_visit = last_visit;
111    p->hidden = hidden;
112    return true;
113  }
114  static void Log(const param_type& p, std::string* l) {
115    l->append("(");
116    LogParam(p.url, l);
117    l->append(", ");
118    LogParam(p.title, l);
119    l->append(", ");
120    LogParam(p.visit_count, l);
121    l->append(", ");
122    LogParam(p.typed_count, l);
123    l->append(", ");
124    LogParam(p.last_visit, l);
125    l->append(", ");
126    LogParam(p.hidden, l);
127    l->append(")");
128  }
129};  // ParamTraits<ImporterURLRow>
130
131// Traits for ImportedBookmarkEntry to pack/unpack.
132template <>
133struct ParamTraits<ImportedBookmarkEntry> {
134  typedef ImportedBookmarkEntry param_type;
135  static void Write(Message* m, const param_type& p) {
136    WriteParam(m, p.in_toolbar);
137    WriteParam(m, p.is_folder);
138    WriteParam(m, p.url);
139    WriteParam(m, p.path);
140    WriteParam(m, p.title);
141    WriteParam(m, p.creation_time);
142  }
143  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
144    return
145        (ReadParam(m, iter, &p->in_toolbar)) &&
146        (ReadParam(m, iter, &p->is_folder)) &&
147        (ReadParam(m, iter, &p->url)) &&
148        (ReadParam(m, iter, &p->path)) &&
149        (ReadParam(m, iter, &p->title)) &&
150        (ReadParam(m, iter, &p->creation_time));
151  }
152  static void Log(const param_type& p, std::string* l) {
153    l->append("(");
154    LogParam(p.in_toolbar, l);
155    l->append(", ");
156    LogParam(p.is_folder, l);
157    l->append(", ");
158    LogParam(p.url, l);
159    l->append(", ");
160    LogParam(p.path, l);
161    l->append(", ");
162    LogParam(p.title, l);
163    l->append(", ");
164    LogParam(p.creation_time, l);
165    l->append(")");
166  }
167};  // ParamTraits<ImportedBookmarkEntry>
168
169// Traits for ImportedFaviconUsage.
170template <>
171struct ParamTraits<ImportedFaviconUsage> {
172  typedef ImportedFaviconUsage param_type;
173  static void Write(Message* m, const param_type& p) {
174    WriteParam(m, p.favicon_url);
175    WriteParam(m, p.png_data);
176    WriteParam(m, p.urls);
177  }
178  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
179    return
180        ReadParam(m, iter, &p->favicon_url) &&
181        ReadParam(m, iter, &p->png_data) &&
182        ReadParam(m, iter, &p->urls);
183  }
184  static void Log(const param_type& p, std::string* l) {
185    l->append("(");
186    LogParam(p.favicon_url, l);
187    l->append(", ");
188    LogParam(p.png_data, l);
189    l->append(", ");
190    LogParam(p.urls, l);
191    l->append(")");
192  }
193};  // ParamTraits<ImportedFaviconUsage>
194
195// Traits for importer::URLKeywordInfo
196template <>
197struct ParamTraits<importer::URLKeywordInfo> {
198  typedef importer::URLKeywordInfo param_type;
199  static void Write(Message* m, const param_type& p) {
200    WriteParam(m, p.url);
201    WriteParam(m, p.keyword);
202    WriteParam(m, p.display_name);
203  }
204
205  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
206    return
207        ReadParam(m, iter, &p->url) &&
208        ReadParam(m, iter, &p->keyword) &&
209        ReadParam(m, iter, &p->display_name);
210  }
211
212  static void Log(const param_type& p, std::string* l) {
213    l->append("(");
214    LogParam(p.url, l);
215    l->append(", ");
216    LogParam(p.keyword, l);
217    l->append(", ");
218    LogParam(p.display_name, l);
219    l->append(")");
220  }
221};  // ParamTraits<importer::URLKeywordInfo>
222
223#if defined(OS_WIN)
224// Traits for importer::ImporterIE7PasswordInfo
225template <>
226struct ParamTraits<importer::ImporterIE7PasswordInfo> {
227  typedef importer::ImporterIE7PasswordInfo param_type;
228  static void Write(Message* m, const param_type& p) {
229    WriteParam(m, p.url_hash);
230    WriteParam(m, p.encrypted_data);
231    WriteParam(m, p.date_created);
232  }
233
234  static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
235    return
236        ReadParam(m, iter, &p->url_hash) &&
237        ReadParam(m, iter, &p->encrypted_data) &&
238        ReadParam(m, iter, &p->date_created);
239  }
240
241  static void Log(const param_type& p, std::string* l) {
242    l->append("(");
243    LogParam(p.url_hash, l);
244    l->append(", ");
245    LogParam(p.encrypted_data, l);
246    l->append(", ");
247    LogParam(p.date_created, l);
248    l->append(")");
249  }
250};  // ParamTraits<importer::ImporterIE7PasswordInfo>
251#endif
252
253}  // namespace IPC
254
255#endif  // CHROME_COMMON_IMPORTER_PROFILE_IMPORT_PROCESS_MESSAGES_H_
256
257#define IPC_MESSAGE_START ProfileImportMsgStart
258
259//-----------------------------------------------------------------------------
260// ProfileImportProcess messages
261// These are messages sent from the browser to the profile import process.
262IPC_MESSAGE_CONTROL3(ProfileImportProcessMsg_StartImport,
263                     importer::SourceProfile,
264                     int                     /* Bitmask of items to import. */,
265                     base::DictionaryValue   /* Localized strings. */)
266
267IPC_MESSAGE_CONTROL0(ProfileImportProcessMsg_CancelImport)
268
269IPC_MESSAGE_CONTROL1(ProfileImportProcessMsg_ReportImportItemFinished,
270                     int  /* ImportItem */)
271
272//---------------------------------------------------------------------------
273// ProfileImportProcessHost messages
274// These are messages sent from the profile import process to the browser.
275// These messages send information about the status of the import and
276// individual import tasks.
277IPC_MESSAGE_CONTROL0(ProfileImportProcessHostMsg_Import_Started)
278
279IPC_MESSAGE_CONTROL2(ProfileImportProcessHostMsg_Import_Finished,
280                     bool         /* was import successful? */,
281                     std::string  /* error message, if any */)
282
283IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_ImportItem_Started,
284                     int  /* ImportItem */)
285
286IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_ImportItem_Finished,
287                     int  /* ImportItem */)
288
289// These messages send data from the external importer process back to
290// the process host so it can be written to the profile.
291IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyHistoryImportStart,
292                     int  /* total number of ImporterURLRow items */)
293
294IPC_MESSAGE_CONTROL2(ProfileImportProcessHostMsg_NotifyHistoryImportGroup,
295                     std::vector<ImporterURLRow>,
296                     int  /* the source of URLs as in history::VisitSource.*/
297                          /* To simplify IPC call, pass as an integer */)
298
299IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyHomePageImportReady,
300                     GURL  /* GURL of home page */)
301
302IPC_MESSAGE_CONTROL2(ProfileImportProcessHostMsg_NotifyBookmarksImportStart,
303                     base::string16  /* first folder name */,
304                     int             /* total number of bookmarks */)
305
306IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyBookmarksImportGroup,
307                     std::vector<ImportedBookmarkEntry>)
308
309IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyFaviconsImportStart,
310                     int  /* total number of favicons */)
311
312IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyFaviconsImportGroup,
313                     std::vector<ImportedFaviconUsage>)
314
315IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyPasswordFormReady,
316                     autofill::PasswordForm)
317
318IPC_MESSAGE_CONTROL2(ProfileImportProcessHostMsg_NotifyKeywordsReady,
319                     std::vector<importer::URLKeywordInfo>, // url_keywords
320                     bool  /* unique on host and path */)
321
322IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyFirefoxSearchEngData,
323                     std::vector<std::string>) // search_engine_data
324
325#if defined(OS_WIN)
326IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyIE7PasswordInfo,
327                     importer::ImporterIE7PasswordInfo) // password_info
328#endif
329