• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2011 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/string16.h"
11 #include "base/values.h"
12 #include "chrome/browser/history/history_types.h"
13 #include "chrome/browser/importer/importer_data_types.h"
14 #include "chrome/browser/importer/profile_writer.h"
15 #include "chrome/browser/search_engines/template_url.h"
16 #include "content/common/common_param_traits.h"
17 #include "content/common/webkit_param_traits.h"
18 #include "ipc/ipc_message_macros.h"
19 #include "ipc/ipc_message_utils.h"
20 #include "webkit/glue/password_form.h"
21 
22 #ifndef CHROME_BROWSER_IMPORTER_PROFILE_IMPORT_PROCESS_MESSAGES_H_
23 #define CHROME_BROWSER_IMPORTER_PROFILE_IMPORT_PROCESS_MESSAGES_H_
24 
25 namespace IPC {
26 
27 // Traits for importer::SourceProfile struct to pack/unpack.
28 template <>
29 struct ParamTraits<importer::SourceProfile> {
30   typedef importer::SourceProfile param_type;
31   static void Write(Message* m, const param_type& p) {
32     WriteParam(m, p.importer_name);
33     WriteParam(m, static_cast<int>(p.importer_type));
34     WriteParam(m, p.source_path);
35     WriteParam(m, p.app_path);
36     WriteParam(m, static_cast<int>(p.services_supported));
37   }
38   static bool Read(const Message* m, void** iter, param_type* p) {
39     if (!ReadParam(m, iter, &p->importer_name))
40       return false;
41 
42     int importer_type = 0;
43     if (!ReadParam(m, iter, &importer_type))
44       return false;
45     p->importer_type = static_cast<importer::ImporterType>(importer_type);
46 
47     if (!ReadParam(m, iter, &p->source_path) ||
48         !ReadParam(m, iter, &p->app_path))
49         return false;
50 
51     int services_supported = 0;
52     if (!ReadParam(m, iter, &services_supported))
53       return false;
54     p->services_supported = static_cast<uint16>(services_supported);
55 
56     return true;
57   }
58   static void Log(const param_type& p, std::string* l) {
59     l->append("(");
60     LogParam(p.importer_name, l);
61     l->append(", ");
62     LogParam(static_cast<int>(p.importer_type), l);
63     l->append(", ");
64     LogParam(p.source_path, l);
65     l->append(", ");
66     LogParam(p.app_path, l);
67     l->append(", ");
68     LogParam(static_cast<int>(p.services_supported), l);
69     l->append(")");
70   }
71 };  // ParamTraits<importer::SourceProfile>
72 
73 // Traits for history::URLRow to pack/unpack.
74 template <>
75 struct ParamTraits<history::URLRow> {
76   typedef history::URLRow param_type;
77   static void Write(Message* m, const param_type& p) {
78     WriteParam(m, p.id());
79     WriteParam(m, p.url());
80     WriteParam(m, p.title());
81     WriteParam(m, p.visit_count());
82     WriteParam(m, p.typed_count());
83     WriteParam(m, p.last_visit());
84     WriteParam(m, p.hidden());
85   }
86   static bool Read(const Message* m, void** iter, param_type* p) {
87     history::URLID id;
88     GURL url;
89     string16 title;
90     int visit_count, typed_count;
91     base::Time last_visit;
92     bool hidden;
93     if (!ReadParam(m, iter, &id) ||
94         !ReadParam(m, iter, &url) ||
95         !ReadParam(m, iter, &title) ||
96         !ReadParam(m, iter, &visit_count) ||
97         !ReadParam(m, iter, &typed_count) ||
98         !ReadParam(m, iter, &last_visit) ||
99         !ReadParam(m, iter, &hidden))
100       return false;
101     *p = history::URLRow(url, id);
102     p->set_title(title);
103     p->set_visit_count(visit_count);
104     p->set_typed_count(typed_count);
105     p->set_last_visit(last_visit);
106     p->set_hidden(hidden);
107     return true;
108   }
109   static void Log(const param_type& p, std::string* l) {
110     l->append("(");
111     LogParam(p.id(), l);
112     l->append(", ");
113     LogParam(p.url(), l);
114     l->append(", ");
115     LogParam(p.title(), l);
116     l->append(", ");
117     LogParam(p.visit_count(), l);
118     l->append(", ");
119     LogParam(p.typed_count(), l);
120     l->append(", ");
121     LogParam(p.last_visit(), l);
122     l->append(", ");
123     LogParam(p.hidden(), l);
124     l->append(")");
125   }
126 };  // ParamTraits<history::URLRow>
127 
128 // Traits for ProfileWriter::BookmarkEntry to pack/unpack.
129 template <>
130 struct ParamTraits<ProfileWriter::BookmarkEntry> {
131   typedef ProfileWriter::BookmarkEntry param_type;
132   static void Write(Message* m, const param_type& p) {
133     WriteParam(m, p.in_toolbar);
134     WriteParam(m, p.is_folder);
135     WriteParam(m, p.url);
136     WriteParam(m, p.path);
137     WriteParam(m, p.title);
138     WriteParam(m, p.creation_time);
139   }
140   static bool Read(const Message* m, void** iter, param_type* p) {
141     return
142         (ReadParam(m, iter, &p->in_toolbar)) &&
143         (ReadParam(m, iter, &p->is_folder)) &&
144         (ReadParam(m, iter, &p->url)) &&
145         (ReadParam(m, iter, &p->path)) &&
146         (ReadParam(m, iter, &p->title)) &&
147         (ReadParam(m, iter, &p->creation_time));
148   }
149   static void Log(const param_type& p, std::string* l) {
150     l->append("(");
151     LogParam(p.in_toolbar, l);
152     l->append(", ");
153     LogParam(p.is_folder, l);
154     l->append(", ");
155     LogParam(p.url, l);
156     l->append(", ");
157     LogParam(p.path, l);
158     l->append(", ");
159     LogParam(p.title, l);
160     l->append(", ");
161     LogParam(p.creation_time, l);
162     l->append(")");
163   }
164 };  // ParamTraits<ProfileWriter::BookmarkEntry>
165 
166 // Traits for history::ImportedFaviconUsage.
167 template <>
168 struct ParamTraits<history::ImportedFaviconUsage> {
169   typedef history::ImportedFaviconUsage param_type;
170   static void Write(Message* m, const param_type& p) {
171     WriteParam(m, p.favicon_url);
172     WriteParam(m, p.png_data);
173     WriteParam(m, p.urls);
174   }
175   static bool Read(const Message* m, void** iter, param_type* p) {
176     return
177         ReadParam(m, iter, &p->favicon_url) &&
178         ReadParam(m, iter, &p->png_data) &&
179         ReadParam(m, iter, &p->urls);
180   }
181   static void Log(const param_type& p, std::string* l) {
182     l->append("(");
183     LogParam(p.favicon_url, l);
184     l->append(", ");
185     LogParam(p.png_data, l);
186     l->append(", ");
187     LogParam(p.urls, l);
188     l->append(")");
189   }
190 };  // ParamTraits<history::ImportedFaviconUsage
191 
192 // Traits for TemplateURLRef
193 template <>
194 struct ParamTraits<TemplateURLRef> {
195   typedef TemplateURLRef param_type;
196   static void Write(Message* m, const param_type& p) {
197     WriteParam(m, p.url());
198     WriteParam(m, p.index_offset());
199     WriteParam(m, p.page_offset());
200   }
201   static bool Read(const Message* m, void** iter, param_type* p) {
202     std::string url;
203     int index_offset;
204     int page_offset;
205     if (!ReadParam(m, iter, &url) ||
206         !ReadParam(m, iter, &index_offset) ||
207         !ReadParam(m, iter, &page_offset))
208       return false;
209     *p = TemplateURLRef(url, index_offset, page_offset);
210     return true;
211   }
212   static void Log(const param_type& p, std::string* l) {
213     l->append("<TemplateURLRef>");
214   }
215 };
216 
217 // Traits for TemplateURL::ImageRef
218 template <>
219 struct ParamTraits<TemplateURL::ImageRef> {
220   typedef TemplateURL::ImageRef param_type;
221   static void Write(Message* m, const param_type& p) {
222     WriteParam(m, p.type);
223     WriteParam(m, p.width);
224     WriteParam(m, p.height);
225     WriteParam(m, p.url);
226   }
227   static bool Read(const Message* m, void** iter, param_type* p) {
228     std::string type;
229     int width;
230     int height;
231     GURL url;
232     if (!ReadParam(m, iter, &type) ||
233         !ReadParam(m, iter, &width) ||
234         !ReadParam(m, iter, &height) ||
235         !ReadParam(m, iter, &url))
236       return false;
237     *p = TemplateURL::ImageRef(type, width, height, url);  // here in
238     return true;
239   }
240   static void Log(const param_type& p, std::string* l) {
241     l->append("<TemplateURL::ImageRef>");
242   }
243 };
244 
245 // Traits for TemplateURL
246 template <>
247 struct ParamTraits<TemplateURL> {
248   typedef TemplateURL param_type;
249   static void Write(Message* m, const param_type& p) {
250     WriteParam(m, p.short_name());
251     WriteParam(m, p.description());
252     if (p.suggestions_url()) {
253       WriteParam(m, true);
254       WriteParam(m, *p.suggestions_url());
255     } else {
256       WriteParam(m, false);
257     }
258     WriteParam(m, *p.url());
259     WriteParam(m, p.originating_url());
260     WriteParam(m, p.keyword());
261     WriteParam(m, p.autogenerate_keyword());
262     WriteParam(m, p.show_in_default_list());
263     WriteParam(m, p.safe_for_autoreplace());
264     WriteParam(m, p.image_refs().size());
265 
266     std::vector<TemplateURL::ImageRef>::const_iterator iter;
267     for (iter = p.image_refs().begin(); iter != p.image_refs().end(); ++iter) {
268       WriteParam(m, iter->type);
269       WriteParam(m, iter->width);
270       WriteParam(m, iter->height);
271       WriteParam(m, iter->url);
272     }
273 
274     WriteParam(m, p.languages());
275     WriteParam(m, p.input_encodings());
276     WriteParam(m, p.date_created());
277     WriteParam(m, p.usage_count());
278     WriteParam(m, p.prepopulate_id());
279   }
280   static bool Read(const Message* m, void** iter, param_type* p) {
281     string16 short_name;
282     string16 description;
283     bool includes_suggestions_url;
284     TemplateURLRef suggestions_url;
285     TemplateURLRef url;
286     GURL originating_url;
287     string16 keyword;
288     bool autogenerate_keyword;
289     bool show_in_default_list;
290     bool safe_for_autoreplace;
291     std::vector<string16> languages;
292     std::vector<std::string> input_encodings;
293     base::Time date_created;
294     int usage_count;
295     int prepopulate_id;
296 
297     if (!ReadParam(m, iter, &short_name) ||
298         !ReadParam(m, iter, &description))
299       return false;
300 
301     if (!ReadParam(m, iter, &includes_suggestions_url))
302       return false;
303     if (includes_suggestions_url) {
304         if (!ReadParam(m, iter, &suggestions_url))
305           return false;
306     }
307 
308     size_t image_refs_size = 0;
309     if (!ReadParam(m, iter, &url) ||
310         !ReadParam(m, iter, &originating_url) ||
311         !ReadParam(m, iter, &keyword) ||
312         !ReadParam(m, iter, &autogenerate_keyword) ||
313         !ReadParam(m, iter, &show_in_default_list) ||
314         !ReadParam(m, iter, &safe_for_autoreplace) ||
315         !ReadParam(m, iter, &image_refs_size))
316       return false;
317 
318     *p = TemplateURL();
319     for (size_t i = 0; i < image_refs_size; ++i) {
320       std::string type;
321       int width;
322       int height;
323       GURL url;
324       if (!ReadParam(m, iter, &type) ||
325           !ReadParam(m, iter, &width) ||
326           !ReadParam(m, iter, &height) ||
327           !ReadParam(m, iter, &url))
328         return false;
329       p->add_image_ref(TemplateURL::ImageRef(type, width, height, url));
330     }
331 
332     if (!ReadParam(m, iter, &languages) ||
333         !ReadParam(m, iter, &input_encodings) ||
334         !ReadParam(m, iter, &date_created) ||
335         !ReadParam(m, iter, &usage_count) ||
336         !ReadParam(m, iter, &prepopulate_id))
337       return false;
338 
339     p->set_short_name(short_name);
340     p->set_description(description);
341     p->SetSuggestionsURL(suggestions_url.url(), suggestions_url.index_offset(),
342                          suggestions_url.page_offset());
343     p->SetURL(url.url(), url.index_offset(), url.page_offset());
344     p->set_originating_url(originating_url);
345     p->set_keyword(keyword);
346     p->set_autogenerate_keyword(autogenerate_keyword);
347     p->set_show_in_default_list(show_in_default_list);
348     p->set_safe_for_autoreplace(safe_for_autoreplace);
349 
350     std::vector<string16>::const_iterator lang_iter;
351     for (lang_iter = languages.begin();
352          lang_iter != languages.end();
353          ++lang_iter) {
354       p->add_language(*lang_iter);
355     }
356     p->set_input_encodings(input_encodings);
357     p->set_date_created(date_created);
358     p->set_usage_count(usage_count);
359     p->set_prepopulate_id(prepopulate_id);
360     return true;
361   }
362   static void Log(const param_type& p, std::string* l) {
363     l->append("<TemplateURL>");
364   }
365 };
366 
367 }  // namespace IPC
368 
369 #endif  // CHROME_BROWSER_IMPORTER_PROFILE_IMPORT_PROCESS_MESSAGES_H_
370 
371 #define IPC_MESSAGE_START ProfileImportMsgStart
372 
373 //-----------------------------------------------------------------------------
374 // ProfileImportProcess messages
375 // These are messages sent from the browser to the profile import process.
376 IPC_MESSAGE_CONTROL4(ProfileImportProcessMsg_StartImport,
377                      importer::SourceProfile,
378                      int                     /* Bitmask of items to import. */,
379                      DictionaryValue         /* Localized strings. */,
380                      bool                    /* Import to bookmark bar. */)
381 
382 IPC_MESSAGE_CONTROL0(ProfileImportProcessMsg_CancelImport)
383 
384 IPC_MESSAGE_CONTROL1(ProfileImportProcessMsg_ReportImportItemFinished,
385                      int  /* ImportItem */)
386 
387 //---------------------------------------------------------------------------
388 // ProfileImportProcessHost messages
389 // These are messages sent from the profile import process to the browser.
390 // These messages send information about the status of the import and
391 // individual import tasks.
392 IPC_MESSAGE_CONTROL0(ProfileImportProcessHostMsg_Import_Started)
393 
394 IPC_MESSAGE_CONTROL2(ProfileImportProcessHostMsg_Import_Finished,
395                      bool         /* was import successful? */,
396                      std::string  /* error message, if any */)
397 
398 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_ImportItem_Started,
399                      int  /* ImportItem */)
400 
401 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_ImportItem_Finished,
402                      int  /* ImportItem */)
403 
404 // These messages send data from the external importer process back to
405 // the process host so it can be written to the profile.
406 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyHistoryImportStart,
407                      int  /* total number of history::URLRow items */)
408 
409 IPC_MESSAGE_CONTROL2(ProfileImportProcessHostMsg_NotifyHistoryImportGroup,
410                      std::vector<history::URLRow>,
411                      int  /* the source of URLs as in history::VisitSource.*/
412                           /* To simplify IPC call, pass as an integer */)
413 
414 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyHomePageImportReady,
415                      GURL  /* GURL of home page */)
416 
417 IPC_MESSAGE_CONTROL3(ProfileImportProcessHostMsg_NotifyBookmarksImportStart,
418                      string16  /* first folder name */,
419                      int       /* options */,
420                      int       /* total number of bookmarks */)
421 
422 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyBookmarksImportGroup,
423                      std::vector<ProfileWriter::BookmarkEntry>)
424 
425 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyFaviconsImportStart,
426                      int  /* total number of favicons */)
427 
428 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyFaviconsImportGroup,
429                      std::vector<history::ImportedFaviconUsage>)
430 
431 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyPasswordFormReady,
432                      webkit_glue::PasswordForm)
433 
434 IPC_MESSAGE_CONTROL3(ProfileImportProcessHostMsg_NotifyKeywordsReady,
435                      std::vector<TemplateURL>,
436                      int,  /* default keyword index */
437                      bool  /* unique on host and path */)
438