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 26 namespace IPC { 27 28 // Traits for importer::SourceProfile struct to pack/unpack. 29 template <> 30 struct 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. 82 template <> 83 struct 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. 132 template <> 133 struct 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. 170 template <> 171 struct 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 196 template <> 197 struct 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 225 template <> 226 struct 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. 262 IPC_MESSAGE_CONTROL3(ProfileImportProcessMsg_StartImport, 263 importer::SourceProfile, 264 int /* Bitmask of items to import. */, 265 base::DictionaryValue /* Localized strings. */) 266 267 IPC_MESSAGE_CONTROL0(ProfileImportProcessMsg_CancelImport) 268 269 IPC_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. 277 IPC_MESSAGE_CONTROL0(ProfileImportProcessHostMsg_Import_Started) 278 279 IPC_MESSAGE_CONTROL2(ProfileImportProcessHostMsg_Import_Finished, 280 bool /* was import successful? */, 281 std::string /* error message, if any */) 282 283 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_ImportItem_Started, 284 int /* ImportItem */) 285 286 IPC_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. 291 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyHistoryImportStart, 292 int /* total number of ImporterURLRow items */) 293 294 IPC_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 299 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyHomePageImportReady, 300 GURL /* GURL of home page */) 301 302 IPC_MESSAGE_CONTROL2(ProfileImportProcessHostMsg_NotifyBookmarksImportStart, 303 base::string16 /* first folder name */, 304 int /* total number of bookmarks */) 305 306 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyBookmarksImportGroup, 307 std::vector<ImportedBookmarkEntry>) 308 309 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyFaviconsImportStart, 310 int /* total number of favicons */) 311 312 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyFaviconsImportGroup, 313 std::vector<ImportedFaviconUsage>) 314 315 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyPasswordFormReady, 316 autofill::PasswordForm) 317 318 IPC_MESSAGE_CONTROL2(ProfileImportProcessHostMsg_NotifyKeywordsReady, 319 std::vector<importer::URLKeywordInfo>, // url_keywords 320 bool /* unique on host and path */) 321 322 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyFirefoxSearchEngData, 323 std::vector<std::string>) // search_engine_data 324 325 #if defined(OS_WIN) 326 IPC_MESSAGE_CONTROL1(ProfileImportProcessHostMsg_NotifyIE7PasswordInfo, 327 importer::ImporterIE7PasswordInfo) // password_info 328 #endif 329
