summaryrefslogtreecommitdiffstats
path: root/chrome/common/automation_messages_internal.h
blob: e2198a13c100f577bf0a1aefef40acdf76ef1f45 (plain)
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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
// Copyright (c) 2010 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.

// Defines the IPC messages used by the automation interface.

// This header is meant to be included in multiple passes, hence no traditional
// header guard.
// See ipc_message_macros.h for explanation of the macros and passes.

#include <string>
#include <vector>

#include "base/basictypes.h"
#include "base/string16.h"
#include "chrome/common/content_settings.h"
#include "chrome/common/navigation_types.h"
#include "chrome/test/automation/autocomplete_edit_proxy.h"
#include "gfx/point.h"
#include "gfx/rect.h"
#include "googleurl/src/gurl.h"
#include "ipc/ipc_message_macros.h"
#include "net/url_request/url_request_status.h"

// NOTE: All IPC messages have either a routing_id of 0 (for asynchronous
//       messages), or one that's been assigned by the proxy (for calls
//       which expect a response).  The routing_id shouldn't be used for
//       any other purpose in these message types.

// NOTE: All the new IPC messages should go at the end (before IPC_END_MESSAGES)
//       The IPC message IDs are part of an enum and hence the value
//       assumed to be constant across the builds may change.
//       The messages AutomationMsg_WindowHWND* in particular should not change
//       since the PageCyclerReferenceTest depends on the correctness of the
//       message IDs across the builds.

IPC_BEGIN_MESSAGES(Automation)

  // This message is fired when the AutomationProvider is up and running
  // in the app (the app is not fully up at this point). The parameter to this
  // message is the version string of the automation provider. This parameter
  // is defined to be the version string as returned by
  // chrome::VersionInfo::Version().
  // The client can choose to use this version string to decide whether or not
  // it can talk to the provider.
  IPC_MESSAGE_ROUTED1(AutomationMsg_Hello, std::string)

  // This message is fired when the initial tab(s) are finished loading.
  IPC_MESSAGE_ROUTED0(AutomationMsg_InitialLoadsComplete)

  // This message notifies the AutomationProvider to append a new tab the
  // window with the given handle. The return value contains the index of
  // the new tab, or -1 if the request failed.
  // The second parameter is the url to be loaded in the new tab.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_AppendTab, int, GURL, int)

  // This message requests the (zero-based) index for the currently
  // active tab in the window with the given handle. The return value contains
  // the index of the active tab, or -1 if the request failed.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_ActiveTabIndex, int, int)

  // This message notifies the AutomationProvider to active the tab.
  // The first parameter is the handle to window resource.
  // The second parameter is the (zero-based) index to be activated
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_ActivateTab, int, int, int)

  // This message requests the cookie value for given url in the
  // profile of the tab identified by the second parameter.  The first
  // parameter is the URL string. The response contains the length of the
  // cookie value string. On failure, this length = -1.
  IPC_SYNC_MESSAGE_ROUTED2_2(AutomationMsg_GetCookies, GURL, int,
                             int, std::string)

  // This message notifies the AutomationProvider to set and broadcast a cookie
  // with given name and value for the given url in the profile of the tab
  // identified by the third parameter. The first parameter is the URL
  // string, and the second parameter is the cookie name and value to be set.
  // The return value is a non-negative value on success.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_SetCookie, GURL, std::string,
                             int, int)

  // This message notifies the AutomationProvider to navigate to a specified
  // url in the tab with given handle. The first parameter is the handle to
  // the tab resource. The second parameter is the target url.  The return
  // value contains a status code which is nonnegative on success.
  // See AutomationMsg_NavigationResponseValues for the return value.
  //
  // Deprecated in favor of
  // AutomationMsg_NavigateToURLBlockUntilNavigationsComplete.
  // TODO(phajdan.jr): Remove when the reference build gets updated.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_NavigateToURL, int, GURL,
                             AutomationMsg_NavigationResponseValues)

  // This message is used to implement the asynchronous version of
  // NavigateToURL.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_NavigationAsync,
                             int /* tab handle */,
                             GURL,
                             bool /* result */)

  // This message notifies the AutomationProvider to navigate back in session
  // history in the tab with given handle. The first parameter is the handle
  // to the tab resource.
  // See AutomationMsg_NavigationResponseValues for the navigation response
  // values.
  //
  // Deprecated in favor of AutomationMsg_GoBackBlockUntilNavigationsComplete.
  // TODO(phajdan.jr): Remove when the reference build gets updated.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_GoBack, int,
                             AutomationMsg_NavigationResponseValues)

  // This message notifies the AutomationProvider to navigate forward in session
  // history in the tab with given handle. The first parameter is the handle
  // to the tab resource.
  // See AutomationMsg_NavigationResponseValues for the navigation response
  // values.
  //
  // Deprecated in favor of
  // AutomationMsg_GoForwardBlockUntilNavigationsComplete.
  // TODO(phajdan.jr): Remove when the reference build gets updated.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_GoForward, int,
                             AutomationMsg_NavigationResponseValues)

  // This message requests the number of browser windows that the app currently
  // has open.  The return value is the number of windows.
  IPC_SYNC_MESSAGE_ROUTED0_1(AutomationMsg_BrowserWindowCount, int)

  // This message requests the handle (int64 app-unique identifier) of the
  // window with the given (zero-based) index.  On error, the returned handle
  // value is 0.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_BrowserWindow, int, int)

  // This message requests the number of tabs in the window with the given
  // handle.  The return value contains the number of tabs, or -1 if the
  // request failed.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_TabCount, int, int)

  // This message requests the handle of the tab with the given (zero-based)
  // index in the given app window. First parameter specifies the given window
  // handle, second specifies the given tab_index. On error, the returned handle
  // value is 0.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_Tab, int, int, int)

  // This message requests the the title of the tab with the given handle.
  // The return value contains the size of the title string. On error, this
  // value should be -1 and empty string. Note that the title can be empty in
  // which case the size would be 0.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_TabTitle,
                             int,
                             int,
                             std::wstring)

  // This message requests the url of the tab with the given handle.
  // The return value contains a success flag and the URL string. The URL will
  // be empty on failure, and it still may be empty on success.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_TabURL,
                             int /* tab handle */,
                             bool /* success flag */,
                             GURL)

#if defined(OS_WIN)
  // TODO(estade): delete this unused message.
  IPC_SYNC_MESSAGE_ROUTED0_0(AutomationMsg_WindowHWND)

  // This message requests the HWND of the tab that corresponds
  // to the given automation handle.
  // The return value contains the HWND value, which is 0 if the call fails.
  //
  // TODO(estade): The only test that uses this message is
  // NPAPIVisiblePluginTester.SelfDeletePluginInvokeInSynchronousMouseMove. It
  // can probably be done in another way, and this can be removed.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_TabHWND,
                             int /* tab_handle */,
                             HWND /* win32 Window Handle */)
#endif  // defined(OS_WIN)

  // This message notifies the AutomationProxy that a handle that it has
  // previously been given is now invalid.  (For instance, if the handle
  // represented a window which has now been closed.)  The parameter
  // value is the handle.
  IPC_MESSAGE_ROUTED1(AutomationMsg_InvalidateHandle, int)

  // This message notifies the AutomationProvider that a handle is no
  // longer being used, so it can stop paying attention to the
  // associated resource.  The parameter value is the handle.
  IPC_MESSAGE_ROUTED1(AutomationMsg_HandleUnused, int)

  // This message tells the AutomationProvider to provide the given
  // authentication data to the specified tab, in response to an HTTP/FTP
  // authentication challenge.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_SetAuth,
                             int,  // tab handle
                             std::wstring,  // username
                             std::wstring,  // password
                             AutomationMsg_NavigationResponseValues)  // status

  // This message tells the AutomationProvider to cancel the login in the
  // specified tab.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_CancelAuth,
                             int,  // tab handle
                             AutomationMsg_NavigationResponseValues)  // status

  // Requests that the automation provider ask history for the most recent
  // chain of redirects coming from the given URL. The response must be
  // decoded by the caller manually; it contains an integer indicating the
  // number of URLs, followed by that many wstrings indicating a chain of
  // redirects. On failure, the count will be negative.
  IPC_SYNC_MESSAGE_ROUTED2_2(AutomationMsg_RedirectsFrom,
                             int,   // tab handle
                             GURL,  // source URL
                             bool /* succeeded */,
                             std::vector<GURL> /* redirects */)

  // This message asks the AutomationProvider whether a tab is waiting for
  // login info.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_NeedsAuth,
                             int,   // tab handle
                             bool)  // status

  // This message requests the AutomationProvider to apply a certain
  // accelerator. It is completely asynchronous with the resulting accelerator
  // action.
  IPC_SYNC_MESSAGE_ROUTED2_0(AutomationMsg_ApplyAccelerator,
                             int,  // window handle
                             int)  // accelerator id like (IDC_BACK,
                                   //  IDC_FORWARD, etc)
                                   // The list can be found at
                                   // chrome/app/chrome_command_ids.h

  // This message requests that the AutomationProvider executes a JavaScript,
  // which is sent embedded in a 'javascript:' URL.
  // The javascript is executed in context of child frame whose xpath
  // is passed as parameter (context_frame). The execution results in
  // a serialized JSON string response.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_DomOperation,
                             int,           // tab handle
                             std::wstring,  // context_frame
                             std::wstring,  // the javascript to be executed
                             std::string)   // the serialized json string
                                            // containing the result of a
                                            // javascript execution

  // Is the Download Shelf visible for the specified browser?
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_ShelfVisibility,
                             int /* browser_handle */,
                             bool /* is_visible */)

  // This message requests the number of constrained windows in the tab with
  // the given handle.  The return value contains the number of constrained
  // windows, or -1 if the request failed.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_ConstrainedWindowCount,
                             int /* tab_handle */,
                             int /* constrained_window_count */)

  // This message requests the bounds of the specified View element in
  // window coordinates.
  // Request:
  //   int - the handle of the window in which the view appears
  //   int - the ID of the view, as specified in chrome/browser/view_ids.h
  //   bool - whether the bounds should be returned in the screen coordinates
  //          (if true) or in the browser coordinates (if false).
  // Response:
  //   bool - true if the view was found
  //   gfx::Rect - the bounds of the view, in window coordinates
  IPC_SYNC_MESSAGE_ROUTED3_2(AutomationMsg_WindowViewBounds, int, int,
                             bool, bool, gfx::Rect)

  // This message sets the bounds of the window.
  // Request:
  //   int - the handle of the window to resize
  //   gfx::Rect - the bounds of the window
  // Response:
  //   bool - true if the resize was successful
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_SetWindowBounds, int, gfx::Rect,
                             bool)

#if defined(OS_WIN)
  // TODO(port): Port these messages.
  //
  // This message requests that a drag be performed in window coordinate space
  // Request:
  //   int - the handle of the window that's the context for this drag
  //   std::vector<gfx::Point> - the path of the drag in window coordinate
  //                             space; it should have at least 2 points
  //                             (start and end)
  //   int - the flags which identify the mouse button(s) for the drag, as
  //         defined in chrome/views/event.h
  // Response:
  //   bool - true if the drag could be performed
  IPC_SYNC_MESSAGE_ROUTED4_1(AutomationMsg_WindowDrag,
                             int, std::vector<gfx::Point>, int, bool, bool)
#endif  // defined(OS_WIN)

  // Similar to AutomationMsg_InitialLoadsComplete, this indicates that the
  // new tab ui has completed the initial load of its data.
  // Time is how many milliseconds the load took.
  IPC_MESSAGE_ROUTED1(AutomationMsg_InitialNewTabUILoadComplete,
                      int /* time */)

  // This message starts a find within a tab corresponding to the supplied
  // tab handle. The return value contains the number of matches found on the
  // page within the tab specified. The parameter 'search_string' specifies
  // what string to search for, 'forward' specifies whether to search in
  // forward direction (1=forward, 0=back), 'match_case' specifies case
  // sensitivity
  // (1=case sensitive, 0=case insensitive). If an error occurs, matches_found
  // will be -1.
  //
  // NOTE: This message has been deprecated, please use the new message
  // AutomationMsg_Find below.
  //
  IPC_SYNC_MESSAGE_ROUTED4_2(AutomationMsg_FindInPage,   // DEPRECATED.
                             int, /* tab_handle */
                             std::wstring, /* find_request */
                             int, /* forward */
                             int /* match_case */,
                             int /* active_ordinal */,
                             int /* matches_found */)

  // This message sends a inspect element request for a given tab. The response
  // contains the number of resources loaded by the inspector controller.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_InspectElement,
                             int, /* tab_handle */
                             int, /* x */
                             int  /* y */,
                             int)

  // This message requests the process ID of the tab that corresponds
  // to the given automation handle.
  // The return value has an integer corresponding to the PID of the tab's
  // renderer, 0 if the tab currently has no renderer process, or -1 on error.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_TabProcessID,
                             int /* tab_handle */,
                             int /* process ID */)

  // This tells the browser to enable or disable the filtered network layer.
  IPC_MESSAGE_ROUTED1(AutomationMsg_SetFilteredInet,
                      bool /* enabled */)

  // Gets the directory that downloads will occur in for the active profile.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_DownloadDirectory,
                             int /* tab_handle */,
                             FilePath /* directory */)

  // This message requests the id of the view that has the focus in the
  // specified window. If no view is focused, -1 is returned.  Note that the
  // window should either be a ViewWindow or a Browser.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_GetFocusedViewID,
                             int /* view_handle */,
                             int /* focused_view_id */)

  // This message shows/hides the window.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_SetWindowVisible,
                             int /* view_handle */,
                             bool /* visible */,
                             bool /* success */)

  // Gets the active status of a window.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_IsWindowActive,
                             int /* view_handle */,
                             bool /* success */,
                             bool /* active */)

  // Makes the specified window the active window.
  IPC_SYNC_MESSAGE_ROUTED1_0(AutomationMsg_ActivateWindow,
                             int /* view_handle */)

  // Opens a new browser window.
  // TODO(sky): remove this and replace with OpenNewBrowserWindowOfType.
  // Doing this requires updating the reference build.
  IPC_SYNC_MESSAGE_ROUTED1_0(AutomationMsg_OpenNewBrowserWindow,
                             bool /* show */ )

  // This message requests the handle (int64 app-unique identifier) of the
  // current active top window.  On error, the returned handle value is 0.
  IPC_SYNC_MESSAGE_ROUTED0_1(AutomationMsg_ActiveWindow, int)

  // This message requests the browser associated with the specified window
  // handle.
  // The return value contains a success flag and the handle of the browser.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_BrowserForWindow,
                             int /* window handle */,
                             bool /* success flag */,
                             int /* browser handle */)

  // This message requests the window associated with the specified browser
  // handle.
  // The return value contains a success flag and the handle of the window.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_WindowForBrowser,
                             int /* browser handle */,
                             bool /* success flag */,
                             int /* window handle */)

  // This message requests the AutocompleteEdit associated with the specified
  // browser handle.
  // The return value contains a success flag and the handle of the omnibox.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_AutocompleteEditForBrowser,
                             int /* browser handle */,
                             bool /* success flag */,
                             int /* AutocompleteEdit handle */)

#if defined(OS_WIN)
  // TODO(estade): This message is defined later on for Mac and Linux. This is
  // to avoid adding a new IPC in the middle for those platforms (see comment
  // at top). The message is exactly the same, so they should be remerged when
  // all messages in this file have been made cross-platform (at which point we
  // will need to check in new reference builds).
  //
  // This message requests that a mouse click be performed in window coordinate
  // space.
  // Request:
  //   int - the handle of the window that's the context for this click
  //   gfx::Point - the point to click
  //   int - the flags which identify the mouse button(s) for the click, as
  //       defined in chrome/views/event.h
  IPC_MESSAGE_ROUTED3(AutomationMsg_WindowClick, int, gfx::Point, int)
#endif  // defined(OS_WIN)

  // This message requests that a key press be performed.
  // Request:
  //   int - the handle of the window that's the context for this click
  //   int - the app::KeyboardCode of the key that was pressed.
  //   int - the flags which identify the modifiers (shift, ctrl, alt)
  //         associated for, as defined in chrome/views/event.h
  IPC_MESSAGE_ROUTED3(AutomationMsg_WindowKeyPress, int, int, int)

  // This message notifies the AutomationProvider to create a tab which is
  // hosted by an external process.
  // Request:
  //   ExternalTabSettings - settings for external tab
  IPC_SYNC_MESSAGE_ROUTED1_4(AutomationMsg_CreateExternalTab,
                             IPC::ExternalTabSettings  /* settings*/,
                             gfx::NativeWindow  /* Tab container window */,
                             gfx::NativeWindow  /* Tab window */,
                             int  /* Handle to the new tab */,
                             int  /* Session Id of the new tab */)

  // This message notifies the AutomationProvider to navigate to a specified
  // url in the external tab with given handle. The first parameter is the
  // handle to the tab resource. The second parameter is the target url.
  // The third parameter is the referrer.
  // The return value contains a status code which is nonnegative on success.
  // see AutomationMsg_NavigationResponseValues for the navigation response.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_NavigateInExternalTab,
                             int,
                             GURL,
                             GURL,
                             AutomationMsg_NavigationResponseValues)

  // This message is an outgoing message from Chrome to an external host.
  // It is a notification that the NavigationState was changed
  // Request:
  //   -int: The flags specifying what changed
  //         (see TabContents::InvalidateTypes)
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED3(AutomationMsg_NavigationStateChanged,
                      int,  // tab handle
                      int,  // TabContents::InvalidateTypes
                      IPC::NavigationInfo)  // title, url etc.

  // This message is an outgoing message from Chrome to an external host.
  // It is a notification that the target URL has changed (the target URL
  // is the URL of the link that the user is hovering on)
  // Request:
  //   -int: The tab handle
  //   -std::wstring: The new target URL
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED2(AutomationMsg_UpdateTargetUrl, int, std::wstring)

  // This message notifies the AutomationProvider to show the specified html
  // text in an interstitial page in the tab with given handle. The first
  // parameter is the handle to the tab resource. The second parameter is the
  // html text to be displayed.
  // The return value contains a success flag.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_ShowInterstitialPage,
                             int,
                             std::string,
                             AutomationMsg_NavigationResponseValues)

  // This message notifies the AutomationProvider to hide the current
  // interstitial page in the tab with given handle. The parameter is the
  // handle to the tab resource.
  // The return value contains a success flag.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_HideInterstitialPage, int,
                             bool)

  // This message requests that a tab be closed.
  // Request:
  //   - int: handle of the tab to close
  //   - bool: if true the proxy blocks until the tab has completely closed,
  //           otherwise the proxy only blocks until it initiates the close.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_CloseTab, int, bool, bool)

  // This message requests that the browser be closed.
  // Request:
  //   - int: handle of the browser which contains the tab
  // Response:
  //  - bool: whether the operation was successfull.
  //  - bool: whether the browser process will be terminated as a result (if
  //          this was the last closed browser window).
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_CloseBrowser, int, bool,
                             bool)

  IPC_MESSAGE_ROUTED1(AutomationMsg_CloseBrowserRequestAsync, int)

  // Unused.
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED1(AutomationMsg_Unused, int)

#if defined(OS_WIN)
  // TODO(port): Port these messages.
  //
  // This message is an outgoing message from Chrome to an external host.
  // It is a request to process a keyboard accelerator.
  // Request:
  //   -int: Tab handle
  //   -MSG: The keyboard message
  // Response:
  //   None expected
  // TODO(sanjeevr): Ideally we need to add a response from the external
  // host saying whether it processed the accelerator
  IPC_MESSAGE_ROUTED2(AutomationMsg_HandleAccelerator, int, MSG)

  // This message is sent by the container of an externally hosted tab to
  // reflect any accelerator keys that it did not process. This gives the
  // tab a chance to handle the keys
  // Request:
  //   - int: handle of the tab
  //   -MSG: The keyboard message that the container did not handle
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED2(AutomationMsg_ProcessUnhandledAccelerator, int, MSG)
#endif  // defined(OS_WIN)

  // Sent by the external tab to the host to notify that the user has tabbed
  // out of the tab.
  // Request:
  //   - int: Tab handle
  //   - bool: |reverse| set to true when shift-tabbing out of the tab, false
  //    otherwise.
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED2(AutomationMsg_TabbedOut, int, bool)

  // Sent by the external tab host to ask focus to be set to either the first
  // or last element on the page.
  // Request:
  //   - int: handle of the tab
  //   - bool: |reverse|
  //      true: Focus will be set to the last focusable element
  //      false: Focus will be set to the first focusable element
  //   - bool: |restore_focus_to_view|
  //      true: The renderer view associated with the current tab will be
  //            infomed that it is receiving focus.
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED3(AutomationMsg_SetInitialFocus, int, bool, bool)

  // This message is an outgoing message from Chrome to an external host.
  // It is a request to open a url
  // Request:
  //   -int: Tab handle
  //   -GURL: The URL to open
  //   -GURL: The referrer
  //   -int: The WindowOpenDisposition that specifies where the URL should
  //         be opened (new tab, new window etc).
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED4(AutomationMsg_OpenURL, int, GURL, GURL, int)

  // This message requests the provider to wait until the specified tab has
  // finished restoring after session restore.
  // Request:
  //   - int: handle of the tab
  // Response:
  //  - bool: whether the operation was successful.
  IPC_SYNC_MESSAGE_ROUTED1_0(AutomationMsg_WaitForTabToBeRestored, int)

  // This message is an outgoing message from Chrome to an external host.
  // It is a notification that a navigation happened
  // Request:
  //   -int:  Tab handle
  //
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED2(AutomationMsg_DidNavigate, int, IPC::NavigationInfo)

  // This message requests the different security states of the page displayed
  // in the specified tab.
  // Request:
  //   - int: handle of the tab
  // Response:
  //  - bool: whether the operation was successful.
  //  - SecurityStyle: the security style of the tab.
  //  - int: the status of the server's ssl cert (0 means no errors or no ssl
  //         was used).
  //  - int: the insecure content state, 0 means no insecure contents.

  IPC_SYNC_MESSAGE_ROUTED1_4(AutomationMsg_GetSecurityState,
                             int,
                             bool,
                             SecurityStyle,
                             int,
                             int)

  // This message requests the page type of the page displayed in the specified
  // tab (normal, error or interstitial).
  // Request:
  //   - int: handle of the tab
  // Response:
  //  - bool: whether the operation was successful.
  //  - PageType: the type of the page currently displayed.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_GetPageType, int, bool, PageType)

  // This message simulates the user action on the SSL blocking page showing in
  // the specified tab.  This message is only effective if an interstitial page
  // is showing in the tab.
  // Request:
  //   - int: handle of the tab
  //   - bool: whether to proceed or abort the navigation
  // Response:
  //  - AutomationMsg_NavigationResponseValues: result of the operation.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_ActionOnSSLBlockingPage, int, bool,
                             AutomationMsg_NavigationResponseValues)

  // Message to request that a browser window is brought to the front and
  // activated.
  // Request:
  //   - int: handle of the browser window.
  // Response:
  //   - bool: True if the browser is brought to the front.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_BringBrowserToFront, int, bool)

  // Message to request whether a certain item is enabled of disabled in the
  // menu in the browser window
  //
  // Request:
  //   - int: handle of the browser window.
  //   - int: IDC message identifier to query if enabled
  // Response:
  //   - bool: True if the command is enabled on the menu
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_IsMenuCommandEnabled, int, int, bool)

  // This message notifies the AutomationProvider to print the tab with given
  // handle. The first parameter is the handle to the tab resource.  The
  // return value contains a bool which is true on success.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_PrintNow, int, bool)

  // This message notifies the AutomationProvider to reload the current page in
  // the tab with given handle. The first parameter is the handle to the tab
  // resource.  The return value contains a status code which is nonnegative on
  // success.
  // see AutomationMsg_NavigationResponseValues for the navigation response.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_Reload, int,
                             AutomationMsg_NavigationResponseValues)

  // This message requests the handle (int64 app-unique identifier) of the
  // last active browser window, or the browser at index 0 if there is no last
  // active browser, or it no longer exists. Returns 0 if no browser windows
  // exist.
  IPC_SYNC_MESSAGE_ROUTED0_1(AutomationMsg_LastActiveBrowserWindow, int)

  // This message notifies the AutomationProvider to save the page with given
  // handle. The first parameter is the handle to the tab resource. The second
  // parameter is the main HTML file name. The third parameter is the directory
  // for saving resources. The fourth parameter is the saving type: 0 for HTML
  // only; 1 for complete web page.
  // The return value contains a bool which is true on success.
  IPC_SYNC_MESSAGE_ROUTED4_1(AutomationMsg_SavePage, int, FilePath, FilePath,
                             int, bool)

  // This message requests the text currently being displayed in the
  // AutocompleteEdit.  The parameter is the handle to the AutocompleteEdit.
  // The return value is a string indicating the text in the AutocompleteEdit.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_AutocompleteEditGetText,
                             int /* autocomplete edit handle */,
                             bool /* the requested autocomplete edit exists */,
                             std::wstring /* omnibox text */)

  // This message sets the text being displayed in the AutocompleteEdit.  The
  // first parameter is the handle to the omnibox and the second parameter is
  // the text to be displayed in the AutocompleteEdit.
  // The return value has no parameters and is returned when the operation has
  // completed.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_AutocompleteEditSetText,
                             int /* autocomplete edit handle */,
                             std::wstring /* text to set */,
                             bool /* the requested autocomplete edit exists */)

  // This message requests if a query to a autocomplete provider is still in
  // progress.  The first parameter in the request is the handle to the
  // autocomplete edit.
  // The first return value indicates if the request succeeded.
  // The second return value indicates if a query is still in progress.
  IPC_SYNC_MESSAGE_ROUTED1_2( \
      AutomationMsg_AutocompleteEditIsQueryInProgress,
      int /* autocomplete edit handle*/,
      bool /* the requested autocomplete edit exists */,
      bool /* indicates if a query is in progress */)

  // This message requests a list of the autocomplete messages currently being
  // displayed by the popup.  The parameter in the request is a handle to the
  // autocomplete edit.
  // The first return value indicates if the request was successful, while
  // while the second is the actual list of matches.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_AutocompleteEditGetMatches,
                             int /* autocomplete edit handle*/,
                             bool /* the requested autocomplete edit exists */,
                             std::vector<AutocompleteMatchData> /* matches */)

  // This message requests the execution of a browser command in the browser
  // for which the handle is specified.
  // The return value contains a boolean, whether the command was dispatched.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_WindowExecuteCommandAsync,
                             int /* automation handle */,
                             int /* browser command */,
                             bool /* success flag */)

  // This message requests the execution of a browser command in the browser
  // for which the handle is specified.
  // The return value contains a boolean, whether the command was dispatched
  // and successful executed.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_WindowExecuteCommand,
                             int /* automation handle */,
                             int /* browser command */,
                             bool /* success flag */)


  // This message opens the Find window within a tab corresponding to the
  // supplied tab handle.
  IPC_MESSAGE_ROUTED1(AutomationMsg_OpenFindInPage,
                      int /* tab_handle */)

  // Posts a message from external host to chrome renderer.
  IPC_MESSAGE_ROUTED4(AutomationMsg_HandleMessageFromExternalHost,
                      int /* automation handle */,
                      std::string /* message */,
                      std::string /* origin */,
                      std::string /* target */)

  // A message for an external host.
  IPC_MESSAGE_ROUTED4(AutomationMsg_ForwardMessageToExternalHost,
                      int, /* handle */
                      std::string /* message */,
                      std::string /* origin */,
                      std::string /* target */)

  // This message starts a find within a tab corresponding to the supplied
  // tab handle. The parameter |request| specifies what to search for.
  // If an error occurs, |matches_found| will be -1.
  //
  IPC_SYNC_MESSAGE_ROUTED2_2(AutomationMsg_Find,
                             int /* tab_handle */,
                             AutomationMsg_Find_Params /* params */,
                             int /* active_ordinal */,
                             int /* matches_found */)

  // Is the Find window fully visible (and not animating) for the specified
  // tab?
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_FindWindowVisibility,
                             int /* tab_handle */,
                             bool /* is_visible */)

  // Where is the Find window located. |x| and |y| will be -1, -1 on failure.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_FindWindowLocation,
                             int /* tab_handle */,
                             int /* x */,
                             int /* y */)

  // Is the Bookmark bar visible? The return value will indicate whether it is
  // visible or not and whether it is being animated into (or out of its place).
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_BookmarkBarVisibility,
                             int /* browser_handle */,
                             bool, /* is_visible */
                             bool  /* still_animating */)

  // This message requests the number of related info bars opened.  It
  // returns -1 if an error occurred.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_GetInfoBarCount,
                             int /* tab_handle */,
                             int /* info bar count */)

  // This message triggers the action associated with the "accept" button in
  // the info-bar at the specified index.  If |wait for navigation| is true, it
  // won't return until a navigation has occurred.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_ClickInfoBarAccept,
                             int /* tab_handle */,
                             int /* info bar index */,
                             bool /* wait for navigation */,

                             /* navigation result */
                             AutomationMsg_NavigationResponseValues)

  // This message retrieves the last time a navigation occurred in the specified
  // tab.  The value is intended to be used with WaitForNavigation.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_GetLastNavigationTime,
                             int /* tab_handle */,
                             int64 /* last navigation time */)

  // This messages is used to block until a new navigation occurs (if there is
  // none more recent then the time specified).
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_WaitForNavigation,
                             int /* tab_handle */,
                             int64 /* last navigation time */,

                             /* navigation result */
                             AutomationMsg_NavigationResponseValues)

  // This messages sets an int-value preference.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_SetIntPreference,
                             int /* browser handle */,
                             std::string /* pref name */,
                             int /* value */,
                             bool /* success */)

  // Queries whether an app modal dialog is currently being shown. (i.e. a
  // javascript alert) and which buttons it contains.
  IPC_SYNC_MESSAGE_ROUTED0_2(AutomationMsg_ShowingAppModalDialog,
                             bool /* showing dialog */,
                             int /* view::DelegateDialog::DialogButton */)

  // This message triggers the specified button for the currently showing
  // modal dialog.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_ClickAppModalDialogButton,
                             int /* view::DelegateDialog::DialogButton */,
                             bool /* success */)

  // This messages sets a string-value preference.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_SetStringPreference,
                             int /* browser handle */,
                             std::string /* pref name */,
                             std::string /* pref value */,
                             bool)

  // This messages gets a boolean-value preference.
  IPC_SYNC_MESSAGE_ROUTED2_2(AutomationMsg_GetBooleanPreference,
                             int /* browser handle */,
                             std::string /* pref name */,
                             bool /* success */,
                             bool /* pref value */)

  // This messages sets a boolean-value preference.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_SetBooleanPreference,
                             int /* browser handle */,
                             std::string /* pref name */,
                             bool /* pref value */,
                             bool /* success */)

  // Queries the current used encoding name of the page in the specified
  // web content tab.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_GetPageCurrentEncoding,
                             int /* tab handle */,
                             std::string /* current used encoding name */)

  // Uses the specified encoding to override the encoding of the page in the
  // specified web content tab.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_OverrideEncoding,
                             int /* tab handle */,
                             std::string /* overrided encoding name */,
                             bool /* success */)

  // Used to disable the dialog box that prompts the user for a path when
  // saving a web page.
  IPC_SYNC_MESSAGE_ROUTED1_0(AutomationMsg_SavePackageShouldPromptUser,
                             bool /* false if we want to not show the dialog */)

  // This message is an outgoing message from Chrome to an external host.
  // It is a notification that a navigation failed
  // Request:
  //   -int : Tab handle
  //   -int : The status code.
  //   -GURL:  The URL we failed to navigate to.
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED3(AutomationMsg_NavigationFailed, int, int, GURL)

#if defined(OS_WIN)
  // This message is an outgoing message from an automation client to Chrome.
  // It is used to reposition a chrome tab window.
  IPC_MESSAGE_ROUTED2(AutomationMsg_TabReposition,
                      int /* tab handle */,
                      IPC::Reposition_Params /* SetWindowPos params */)
#endif  // defined(OS_WIN)

  // Gets the title of the top level browser window.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_WindowTitle,
                             int /* automation handle */,
                             string16 /* title text */ )

  // Tab load complete
  IPC_MESSAGE_ROUTED2(AutomationMsg_TabLoaded,
                      int,  // tab handle
                      GURL)

  // This message requests the tabstrip index of the tab with the given handle.
  // The return value contains the index, which will be -1 on failure.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_TabIndex, int, int)

  // This message requests the handle (int64 app-unique identifier) of
  // a valid normal browser window, i.e. normal type and non-incognito mode.
  // On error, the returned handle value is 0.
  IPC_SYNC_MESSAGE_ROUTED0_1(AutomationMsg_FindNormalBrowserWindow, int)

  // This message requests the number of normal browser windows, i.e. normal
  // type and non-incognito mode that the app currently has open.  The return
  // value is the number of windows.
  IPC_SYNC_MESSAGE_ROUTED0_1(AutomationMsg_NormalBrowserWindowCount, int)

  // Used to put the browser into "extension automation mode" for a given
  // set of Chrome Extensions API functions for the current profile, or turn
  // off automation mode.  The specified tab is used as the conduit for all
  // automated API functions.  It must be an external tab (as in
  // AutomationMsg_CreateExternalTab).
  IPC_MESSAGE_ROUTED2(AutomationMsg_SetEnableExtensionAutomation,
                      // Tab handle.
                      int,
                      // Empty to disable automation, non-empty to enable
                      // automation of the specified API functions, single
                      // entry of "*" to enable automation of all API
                      // functions.
                      std::vector<std::string>)

  // This message tells the browser to start using the new proxy configuration
  // represented by the given JSON string. The parameters used in the JSON
  // string are defined in automation_constants.h.
  IPC_MESSAGE_ROUTED1(AutomationMsg_SetProxyConfig,
                      std::string /* proxy_config_json_string */)

  // Sets Download Shelf visibility for the specified browser.
  IPC_SYNC_MESSAGE_ROUTED2_0(AutomationMsg_SetShelfVisibility,
                             int /* browser_handle */,
                             bool /* is_visible */)

  // This message requests the number of blocked popups in a certain tab with
  // the given handle. The return value is the number of blocked popups, or -1
  // if this request failed.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_BlockedPopupCount,
                             int /* tab_handle */,
                             int /* blocked_popup_count */)

  // This message retrieves the locale of the browser process.  On success
  // |chrome_locale| will contain the locale as reported by ICU.  On failure
  // |chrome_locale| is the empty string.
  IPC_SYNC_MESSAGE_ROUTED0_1(AutomationMsg_GetBrowserLocale,
                             string16 /* chrome_locale */)

#if defined(OS_WIN)
  IPC_MESSAGE_ROUTED4(AutomationMsg_ForwardContextMenuToExternalHost,
                      int /* tab_handle */,
                      HANDLE /* source menu handle */,
                      int    /* align flags */,
                      IPC::MiniContextMenuParams /* params */)

  IPC_MESSAGE_ROUTED2(AutomationMsg_ForwardContextMenuCommandToChrome,
                      int /* tab_handle */,
                      int /* selected_command */)
#endif  // OS_WIN

  // A URL request to be fetched via automation
  IPC_MESSAGE_ROUTED3(AutomationMsg_RequestStart,
                      int /* tab_handle */,
                      int /* request_id */,
                      IPC::AutomationURLRequest /* request */)

  // Read data from a URL request to be fetched via automation
  IPC_MESSAGE_ROUTED3(AutomationMsg_RequestRead,
                      int /* tab_handle */,
                      int /* request_id */,
                      int /* bytes_to_read */)

  // Response to a AutomationMsg_RequestStart message
  IPC_MESSAGE_ROUTED3(AutomationMsg_RequestStarted,
                      int /* tab_handle */,
                      int /* request_id */,
                      IPC::AutomationURLResponse /* response */)

  // Data read via automation
  IPC_MESSAGE_ROUTED3(AutomationMsg_RequestData,
                      int /* tab_handle */,
                      int /* request_id */,
                      std::string /* data */)

  IPC_MESSAGE_ROUTED3(AutomationMsg_RequestEnd,
                      int /* tab_handle */,
                      int /* request_id */,
                      URLRequestStatus /* status */)

  IPC_MESSAGE_ROUTED1(AutomationMsg_PrintAsync,
                      int /* tab_handle */)

  IPC_MESSAGE_ROUTED3(AutomationMsg_SetCookieAsync,
                      int /* tab_handle */,
                      GURL /* url */,
                      std::string /* cookie */)

  IPC_MESSAGE_ROUTED1(AutomationMsg_SelectAll,
                      int /* tab handle */)

  IPC_MESSAGE_ROUTED1(AutomationMsg_Cut,
                      int /* tab handle */)

  IPC_MESSAGE_ROUTED1(AutomationMsg_Copy,
                      int /* tab handle */)

  IPC_MESSAGE_ROUTED1(AutomationMsg_Paste,
                      int /* tab handle */)

  IPC_MESSAGE_ROUTED1(AutomationMsg_ReloadAsync,
                      int /* tab handle */)

  IPC_MESSAGE_ROUTED1(AutomationMsg_StopAsync,
                      int /* tab handle */)

  // Returns the number of times a filter was used to service an URL request.
  // See AutomationMsg_SetFilteredInet.
  IPC_SYNC_MESSAGE_ROUTED0_1(AutomationMsg_GetFilteredInetHitCount,
                             int /* hit_count */)

  // Is the browser in fullscreen mode?
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_IsFullscreen,
                             int /* browser_handle */,
                             bool /* is_fullscreen */)

  // Is the fullscreen bubble visible?
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_IsFullscreenBubbleVisible,
                             int /* browser_handle */,
                             bool /* is_visible */)

#if defined(OS_POSIX)
  // See previous definition of this message for explanation of why it is
  // defined twice.
  IPC_MESSAGE_ROUTED3(AutomationMsg_WindowClick, int, gfx::Point, int)
#endif

  // This message notifies the AutomationProvider to navigate to a specified
  // url in the tab with given handle. The first parameter is the handle to
  // the tab resource. The second parameter is the target url.  The third
  // parameter is the number of navigations that are required for a successful
  // return value. See AutomationMsg_NavigationResponseValues for the return
  // value.
  IPC_SYNC_MESSAGE_ROUTED3_1(
      AutomationMsg_NavigateToURLBlockUntilNavigationsComplete, int, GURL, int,
      AutomationMsg_NavigationResponseValues)

  // This message notifies the AutomationProvider to navigate to a specified
  // navigation entry index in the external tab with given handle. The first
  // parameter is the handle to the tab resource. The second parameter is the
  // index of navigation entry.
  // The return value contains a status code which is nonnegative on success.
  // see AutomationMsg_NavigationResponseValues for the navigation response.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_NavigateExternalTabAtIndex, int, int,
                             AutomationMsg_NavigationResponseValues)

  // This message requests the provider to wait until the window count
  // reached the specified value.
  // Request:
  //   - int: target browser window count
  // Response:
  //  - bool: whether the operation was successful.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_WaitForBrowserWindowCountToBecome,
                             int, bool)

  // This message requests the provider to wait until an application modal
  // dialog is shown.
  // Response:
  //  - bool: whether the operation was successful
  IPC_SYNC_MESSAGE_ROUTED0_1(AutomationMsg_WaitForAppModalDialogToBeShown, bool)

  // This message notifies the AutomationProvider to navigate back in session
  // history in the tab with given handle. The first parameter is the handle
  // to the tab resource. The second parameter is the number of navigations the
  // provider will wait for.
  // See AutomationMsg_NavigationResponseValues for the navigation response
  // values.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_GoBackBlockUntilNavigationsComplete,
                             int, int,
                             AutomationMsg_NavigationResponseValues)

  // This message notifies the AutomationProvider to navigate forward in session
  // history in the tab with given handle. The first parameter is the handle
  // to the tab resource. The second parameter is the number of navigations
  // the provider will wait for.
  // See AutomationMsg_NavigationResponseValues for the navigation response
  // values.
  IPC_SYNC_MESSAGE_ROUTED2_1(
      AutomationMsg_GoForwardBlockUntilNavigationsComplete, int, int,
      AutomationMsg_NavigationResponseValues)

  // This message is used by automation clients to upload histogram data to the
  // browser process.
  IPC_MESSAGE_ROUTED1(AutomationMsg_RecordHistograms,
                      std::vector<std::string> /* histogram_list */)

  IPC_MESSAGE_ROUTED2(AutomationMsg_AttachExternalTab,
                      int     /* 'source' tab_handle */,
                      IPC::AttachExternalTabParams)

  // Sent when the automation client connects to an existing tab.
  IPC_SYNC_MESSAGE_ROUTED3_4(AutomationMsg_ConnectExternalTab,
                             uint64 /* cookie */,
                             bool   /* allow/block tab*/,
                             gfx::NativeWindow  /* parent window */,
                             gfx::NativeWindow  /* Tab container window */,
                             gfx::NativeWindow  /* Tab window */,
                             int  /* Handle to the new tab */,
                             int  /* Session Id of the new tab */)

#if defined(OS_POSIX)
  // TODO(estade): this should be merged with the windows message of the same
  // name. See comment for WindowClick.
  IPC_SYNC_MESSAGE_ROUTED4_1(AutomationMsg_WindowDrag,
                             int, std::vector<gfx::Point>, int, bool, bool)
#endif  // defined(OS_POSIX)

  // This message gets the bounds of the window.
  // Request:
  //   int - the handle of the window to query
  // Response:
  //   gfx::Rect - the bounds of the window
  //   bool - true if the query was successful
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_GetWindowBounds, int, gfx::Rect,
                             bool)

  // Simulate an end of session. Normally this happens when the user
  // shuts down the machine or logs off.
  // Request:
  //   int - the handle of the browser
  // Response:
  //   bool - true if succesful
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_TerminateSession, int, bool)

  // Returns whether the window is maximized.
  // Request:
  //   int - the handle of the window
  // Response:
  //   bool - true if the window is maximized
  //   bool - true if query is successful
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_IsWindowMaximized, int, bool, bool)

  IPC_MESSAGE_ROUTED2(AutomationMsg_SetPageFontSize,
                      int /* tab_handle */,
                      int /* The font size */)

  // Returns a metric event duration that was last recorded.  Returns -1 if the
  // event hasn't occurred yet.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_GetMetricEventDuration,
                             std::string /* event_name */,
                             int /* duration ms */)

  // Sent by automation provider - go to history entry via automation.
  IPC_MESSAGE_ROUTED2(AutomationMsg_RequestGoToHistoryEntryOffset,
                             int,   // tab handle
                             int)   // numbers of entries (negative or positive)

  // Silently install the extension in the given crx file.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_InstallExtension,
                             FilePath /* full path to crx file */,
                             AutomationMsg_ExtensionResponseValues)

  // Silently load the extension in the given directory.  This expects an
  // extension expanded into the directory, not a crx file.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_LoadExpandedExtension,
                             FilePath /* root directory of extension */,
                             AutomationMsg_ExtensionResponseValues)

  // Retrieves a list of the root directories of all enabled extensions
  // that have been installed into Chrome by dropping a .crx file onto
  // Chrome or an equivalent action (including loaded extensions).
  // Other types of extensions are not included on the list (e.g. "component"
  // or "external" extensions) since they are generally not useful for testing
  // (e.g. an external extension could mess with an automated test if it's
  // present on some systems only).
  IPC_SYNC_MESSAGE_ROUTED0_1(AutomationMsg_GetEnabledExtensions,
                             std::vector<FilePath>)

  // This message requests the type of the window with the given handle. The
  // return value contains the type (Browser::Type), or -1 if the request
  // failed.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_Type, int, int)

  // Opens a new browser window of a specific type.
  IPC_SYNC_MESSAGE_ROUTED2_0(AutomationMsg_OpenNewBrowserWindowOfType,
                             int   /* Type (Browser::Type) */,
                             bool  /* show */ )

  // This message requests that the mouse be moved to this location, in
  // window coordinate space.
  // Request:
  //   int - the handle of the window that's the context for this click
  //   gfx::Point - the location to move to
  IPC_MESSAGE_ROUTED2(AutomationMsg_WindowMouseMove, int, gfx::Point)

  // Called when requests should be downloaded using a host browser's
  // download mechanism when chrome is being embedded.
  IPC_MESSAGE_ROUTED2(AutomationMsg_DownloadRequestInHost,
                      int /* tab_handle */,
                      int /* request_id */)

  // Shuts down the session service for the browser identified by
  // |browser_handle|. On success |result| is set to true.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_ShutdownSessionService,
                             int   /* browser_handle */,
                             bool  /* result */)

  IPC_MESSAGE_ROUTED1(AutomationMsg_SaveAsAsync,
                      int /* tab handle */)

#if defined(OS_WIN)
  // An incoming message from an automation host to Chrome.  Signals that
  // the browser containing |tab_handle| has moved.
  IPC_MESSAGE_ROUTED1(AutomationMsg_BrowserMove,
                      int /* tab handle */)
#endif

  // Used to get cookies for the given URL.
  IPC_MESSAGE_ROUTED3(AutomationMsg_GetCookiesFromHost,
                      int /* tab_handle */,
                      GURL /* url */,
                      int /* opaque_cookie_id */)

  IPC_MESSAGE_ROUTED5(AutomationMsg_GetCookiesHostResponse,
                      int /* tab_handle */,
                      bool /* success */,
                      GURL /* url */,
                      std::string /* cookies */,
                      int /* opaque_cookie_id */)

  // If the given host is empty, then the default content settings are
  // modified.
  IPC_SYNC_MESSAGE_ROUTED4_1(AutomationMsg_SetContentSetting,
                             int /* browser handle */,
                             std::string /* host */,
                             ContentSettingsType /* content type */,
                             ContentSetting /* setting */,
                             bool /* success */)

#if defined(OS_CHROMEOS)
  // Logs in through the browser's login wizard if available.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_LoginWithUserAndPass,
                             std::string /* username*/,
                             std::string /* password*/,
                             bool /* Whether successful*/)
#endif

  // Return the bookmarks encoded as a JSON string.
  IPC_SYNC_MESSAGE_ROUTED1_2(AutomationMsg_GetBookmarksAsJSON,
                             int /* browser_handle */,
                             std::string /* bookmarks as a JSON string */,
                             bool /* success */)

  // Wait for the bookmark model to load.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_WaitForBookmarkModelToLoad,
                             int /* browser_handle */,
                             bool /* success */)

  // Bookmark addition, modification, and removal.
  // Bookmarks are indexed by their id.
  IPC_SYNC_MESSAGE_ROUTED4_1(AutomationMsg_AddBookmarkGroup,
                             int /* browser_handle */,
                             int64 /* parent_id */,
                             int /* index */,
                             std::wstring /* title */,
                             bool /* success */)
  IPC_SYNC_MESSAGE_ROUTED5_1(AutomationMsg_AddBookmarkURL,
                             int /* browser_handle */,
                             int64 /* parent_id */,
                             int /* index */,
                             std::wstring /* title */,
                             GURL /* url */,
                             bool /* success */)
  IPC_SYNC_MESSAGE_ROUTED4_1(AutomationMsg_ReparentBookmark,
                             int /* browser_handle */,
                             int64 /* id */,
                             int64 /* new_parent_id */,
                             int /* index */,
                             bool /* success */)
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_SetBookmarkTitle,
                             int /* browser_handle */,
                             int64 /* id */,
                             std::wstring /* title */,
                             bool /* success */)
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_SetBookmarkURL,
                             int /* browser_handle */,
                             int64 /* id */,
                             GURL /* url */,
                             bool /* success */)
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_RemoveBookmark,
                             int /* browser_handle */,
                             int64 /* id */,
                             bool /* success */)

  // This message informs the browser process to remove the history entries
  // for the specified types across all time ranges. See
  // browsing_data_remover.h for a list of REMOVE_* types supported in the
  // remove_mask parameter.
  IPC_MESSAGE_ROUTED1(AutomationMsg_RemoveBrowsingData, int)

  // Block until the focused view id changes to something other than
  // |previous_view_id|.
  IPC_SYNC_MESSAGE_ROUTED2_2(AutomationMsg_WaitForFocusedViewIDToChange,
                             int /* window handle */,
                             int /* previous_view_id */,
                             bool /* success */,
                             int /* new_view_id */)

  // To avoid race conditions, waiting until a popup menu opens is a
  // three-step process:
  //   1. Call StartTrackingPopupMenus.
  //   2. Call an automation method that results in opening the popup menu.
  //   3. Call WaitForPopupMenuToOpen and check for success.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_StartTrackingPopupMenus,
                             int /* browser handle */,
                             bool /* success */)
  IPC_SYNC_MESSAGE_ROUTED0_1(AutomationMsg_WaitForPopupMenuToOpen,
                             bool /* success */)

  // Generic pyauto pattern to help avoid future addition of
  // automation messages.
  IPC_SYNC_MESSAGE_ROUTED2_2(AutomationMsg_SendJSONRequest,
                             int /* browser_handle */,
                             std::string /* JSON request */,
                             std::string /* JSON response */,
                             bool /* success */)

  // Installs an extension from the crx file and returns its id.
  // On error, |extension handle| will be 0.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_InstallExtensionAndGetHandle,
                             FilePath     /* full path to crx file */,
                             bool         /* with UI */,
                             int          /* extension handle */)

  // Waits for the next extension test result. Sets |test result| as the
  // received result and |message| as any accompanying message with the
  // result, which could be the empty string.
  IPC_SYNC_MESSAGE_ROUTED0_2(AutomationMsg_WaitForExtensionTestResult,
                             bool         /* test result */,
                             std::string  /* message */)

  // Uninstalls an extension. On success |success| is true.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_UninstallExtension,
                             int   /* extension handle */,
                             bool  /* success */)

  // Enables an extension. On success |success| is true.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_EnableExtension,
                             int   /* extension handle */,
                             bool  /* success */)

  // Disables an extension. On success |success| is true.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_DisableExtension,
                             int   /* extension handle */,
                             bool  /* success */)

  // Executes the action associated with the given extension. This executes
  // the extension's page or browser action in the given browser, but does
  // not open popups. On success |success| is true.
  IPC_SYNC_MESSAGE_ROUTED2_1(
      AutomationMsg_ExecuteExtensionActionInActiveTabAsync,
      int   /* extension handle */,
      int   /* browser handle */,
      bool  /* success */)

  // Moves the browser action to the given index in the browser action toolbar.
  // On success |success| is true.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_MoveExtensionBrowserAction,
                             int   /* extension handle */,
                             int   /* index */,
                             bool  /* success */)

  // Gets an extension property |property type|. On success |success| is true,
  // and |property value| is set.
  IPC_SYNC_MESSAGE_ROUTED2_2(AutomationMsg_GetExtensionProperty,
      int                              /* extension handle */,
      AutomationMsg_ExtensionProperty  /* property type */,
      bool                             /* success */,
      std::string                      /* property value */)

  // Resets to the default theme.
  IPC_SYNC_MESSAGE_ROUTED0_0(AutomationMsg_ResetToDefaultTheme)

  // Navigates asynchronously to a URL with a certain disposition,
  // like in a new tab.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_NavigationAsyncWithDisposition,
                             int /* tab handle */,
                             GURL,
                             WindowOpenDisposition,
                             bool /* result */)


  // This message requests the cookie be deleted for given url in the
  // profile of the tab identified by the first parameter.  The second
  // parameter is the cookie name.
  IPC_SYNC_MESSAGE_ROUTED3_1(AutomationMsg_DeleteCookie, GURL, std::string,
                             int /* tab handle */,
                             bool /* result */)

  // This message triggers the collected cookies dialog for a specific tab.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_ShowCollectedCookiesDialog,
                             int /* tab handle */,
                             bool /* result */)

  // This message requests the external tab identified by the tab handle
  // passed in be closed.
  // Request:
  //   -int: Tab handle
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED1(AutomationMsg_CloseExternalTab, int)

  // This message requests that the external tab identified by the tab handle
  // runs unload handlers if any on the current page.
  // Request:
  //   -int: Tab handle
  //   -bool: result: true->unload, false->don't unload
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_RunUnloadHandlers, int, bool)

  // This message sets the current zoom level on the tab
  // Request:
  //   -int: Tab handle
  //   -int: Zoom level. Values ZOOM_OUT = -1, RESET = 0, ZOOM_IN  = 1
  // Response:
  //   None expected
  IPC_MESSAGE_ROUTED2(AutomationMsg_SetZoomLevel, int, int)

  // Waits for tab count to reach target value.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_WaitForTabCountToBecome,
                             int /* browser handle */,
                             int /* target tab count */,
                             bool /* success */)

  // Waits for the infobar count to reach given number.
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_WaitForInfoBarCount,
                             int /* tab handle */,
                             int /* target count */,
                             bool /* success */)

  // Waits for the autocomplete edit to receive focus.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_WaitForAutocompleteEditFocus,
                             int /* autocomplete edit handle */,
                             bool /* success */)

  // Loads all blocked plug-ins on the page.
  IPC_SYNC_MESSAGE_ROUTED1_1(AutomationMsg_LoadBlockedPlugins,
                             int /* tab handle */,
                             bool /* success */)

  // Captures the entire page for the tab, including those portions not in
  // view, and saves the image as a PNG in the given file location.
  // Request:
  //   -int: Tab handle
  //   -FilePath: Path to save the captured image to
  // Response:
  //   -bool: Whether the method succeeded
  IPC_SYNC_MESSAGE_ROUTED2_1(AutomationMsg_CaptureEntirePageAsPNG, int,
                             FilePath, bool)

IPC_END_MESSAGES(Automation)