Home | History | Annotate | Download | only in common
      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 traditional include guard.
      6 #include <string>
      7 
      8 #include "base/basictypes.h"
      9 #include "chrome/common/automation_constants.h"
     10 #include "chrome/common/content_settings.h"
     11 #include "chrome/common/security_style.h"
     12 #include "content/common/common_param_traits.h"
     13 #include "content/common/page_type.h"
     14 #include "content/common/webkit_param_traits.h"
     15 #include "ipc/ipc_message_macros.h"
     16 #include "ipc/ipc_message_utils.h"
     17 #include "net/base/host_port_pair.h"
     18 #include "net/base/upload_data.h"
     19 #include "ui/gfx/rect.h"
     20 
     21 // Singly-included section, not yet converted.
     22 #ifndef CHROME_COMMON_AUTOMATION_MESSAGES_H__
     23 #define CHROME_COMMON_AUTOMATION_MESSAGES_H__
     24 
     25 struct AutomationMsg_Find_Params {
     26   // Unused value, which exists only for backwards compat.
     27   int unused;
     28 
     29   // The word(s) to find on the page.
     30   string16 search_string;
     31 
     32   // Whether to search forward or backward within the page.
     33   bool forward;
     34 
     35   // Whether search should be Case sensitive.
     36   bool match_case;
     37 
     38   // Whether this operation is first request (Find) or a follow-up (FindNext).
     39   bool find_next;
     40 };
     41 
     42 struct AutomationURLResponse {
     43   AutomationURLResponse();
     44   AutomationURLResponse(const std::string& mime_type,
     45                         const std::string& headers,
     46                         int64 content_length,
     47                         const base::Time& last_modified,
     48                         const std::string& redirect_url,
     49                         int redirect_status,
     50                         const net::HostPortPair& host_socket_address);
     51   ~AutomationURLResponse();
     52 
     53   std::string mime_type;
     54   std::string headers;
     55   int64 content_length;
     56   base::Time last_modified;
     57   std::string redirect_url;
     58   int redirect_status;
     59   net::HostPortPair socket_address;
     60 };
     61 
     62 struct ExternalTabSettings {
     63   ExternalTabSettings();
     64   ExternalTabSettings(gfx::NativeWindow parent,
     65                       const gfx::Rect& dimensions,
     66                       unsigned int style,
     67                       bool is_incognito,
     68                       bool load_requests_via_automation,
     69                       bool handle_top_level_requests,
     70                       const GURL& initial_url,
     71                       const GURL& referrer,
     72                       bool infobars_enabled,
     73                       bool route_all_top_level_navigations);
     74   ~ExternalTabSettings();
     75 
     76   gfx::NativeWindow parent;
     77   gfx::Rect dimensions;
     78   unsigned int style;
     79   bool is_incognito;
     80   bool load_requests_via_automation;
     81   bool handle_top_level_requests;
     82   GURL initial_url;
     83   GURL referrer;
     84   bool infobars_enabled;
     85   bool route_all_top_level_navigations;
     86 };
     87 
     88 struct NavigationInfo {
     89   NavigationInfo();
     90   NavigationInfo(int navigation_type,
     91                  int relative_offset,
     92                  int navigation_index,
     93                  const std::wstring& title,
     94                  const GURL& url,
     95                  const GURL& referrer,
     96                  SecurityStyle security_style,
     97                  bool displayed_insecure_content,
     98                  bool ran_insecure_content);
     99   ~NavigationInfo();
    100 
    101   int navigation_type;
    102   int relative_offset;
    103   int navigation_index;
    104   std::wstring title;
    105   GURL url;
    106   GURL referrer;
    107   SecurityStyle security_style;
    108   bool displayed_insecure_content;
    109   bool ran_insecure_content;
    110 };
    111 
    112 // A stripped down version of ContextMenuParams in webkit/glue/context_menu.h.
    113 struct MiniContextMenuParams {
    114   MiniContextMenuParams();
    115   MiniContextMenuParams(int screen_x,
    116                         int screen_y,
    117                         const GURL& link_url,
    118                         const GURL& unfiltered_link_url,
    119                         const GURL& src_url,
    120                         const GURL& page_url,
    121                         const GURL& frame_url);
    122   ~MiniContextMenuParams();
    123 
    124   // The x coordinate for displaying the menu.
    125   int screen_x;
    126 
    127   // The y coordinate for displaying the menu.
    128   int screen_y;
    129 
    130   // This is the URL of the link that encloses the node the context menu was
    131   // invoked on.
    132   GURL link_url;
    133 
    134   // The link URL to be used ONLY for "copy link address". We don't validate
    135   // this field in the frontend process.
    136   GURL unfiltered_link_url;
    137 
    138   // This is the source URL for the element that the context menu was
    139   // invoked on.  Example of elements with source URLs are img, audio, and
    140   // video.
    141   GURL src_url;
    142 
    143   // This is the URL of the top level page that the context menu was invoked
    144   // on.
    145   GURL page_url;
    146 
    147   // This is the URL of the subframe that the context menu was invoked on.
    148   GURL frame_url;
    149 };
    150 
    151 struct AttachExternalTabParams {
    152   AttachExternalTabParams();
    153   AttachExternalTabParams(uint64 cookie,
    154                           const GURL& url,
    155                           const gfx::Rect& dimensions,
    156                           int disposition,
    157                           bool user_gesture,
    158                           const std::string& profile_name);
    159   ~AttachExternalTabParams();
    160 
    161   uint64 cookie;
    162   GURL url;
    163   gfx::Rect dimensions;
    164   int disposition;
    165   bool user_gesture;
    166   std::string profile_name;
    167 };
    168 
    169 #if defined(OS_WIN)
    170 
    171 struct Reposition_Params {
    172   HWND window;
    173   HWND window_insert_after;
    174   int left;
    175   int top;
    176   int width;
    177   int height;
    178   int flags;
    179   bool set_parent;
    180   HWND parent_window;
    181 };
    182 
    183 #endif  // defined(OS_WIN)
    184 
    185 struct AutomationURLRequest {
    186   AutomationURLRequest();
    187   AutomationURLRequest(const std::string& url,
    188                        const std::string& method,
    189                        const std::string& referrer,
    190                        const std::string& extra_request_headers,
    191                        scoped_refptr<net::UploadData> upload_data,
    192                        int resource_type,
    193                        int load_flags);
    194   ~AutomationURLRequest();
    195 
    196   std::string url;
    197   std::string method;
    198   std::string referrer;
    199   std::string extra_request_headers;
    200   scoped_refptr<net::UploadData> upload_data;
    201   int resource_type;  // see webkit/glue/resource_type.h
    202   int load_flags; // see net/base/load_flags.h
    203 };
    204 
    205 namespace IPC {
    206 
    207 template <>
    208 struct ParamTraits<AutomationMsg_Find_Params> {
    209   typedef AutomationMsg_Find_Params param_type;
    210   static void Write(Message* m, const param_type& p);
    211   static bool Read(const Message* m, void** iter, param_type* p);
    212   static void Log(const param_type& p, std::string* l);
    213 };
    214 
    215 template <>
    216 struct ParamTraits<AutomationMsg_NavigationResponseValues> {
    217   typedef AutomationMsg_NavigationResponseValues param_type;
    218   static void Write(Message* m, const param_type& p);
    219   static bool Read(const Message* m, void** iter, param_type* p);
    220   static void Log(const param_type& p, std::string* l);
    221 };
    222 
    223 template <>
    224 struct ParamTraits<AutomationMsg_ExtensionResponseValues> {
    225   typedef AutomationMsg_ExtensionResponseValues param_type;
    226   static void Write(Message* m, const param_type& p);
    227   static bool Read(const Message* m, void** iter, param_type* p);
    228   static void Log(const param_type& p, std::string* l);
    229 };
    230 
    231 template <>
    232 struct ParamTraits<AutomationMsg_ExtensionProperty> {
    233   typedef AutomationMsg_ExtensionProperty param_type;
    234   static void Write(Message* m, const param_type& p);
    235   static bool Read(const Message* m, void** iter, param_type* p);
    236   static void Log(const param_type& p, std::string* l);
    237 };
    238 
    239 template <>
    240 struct ParamTraits<SecurityStyle> {
    241   typedef SecurityStyle param_type;
    242   static void Write(Message* m, const param_type& p);
    243   static bool Read(const Message* m, void** iter, param_type* p);
    244   static void Log(const param_type& p, std::string* l);
    245 };
    246 
    247 template <>
    248 struct ParamTraits<PageType> {
    249   typedef PageType param_type;
    250   static void Write(Message* m, const param_type& p);
    251   static bool Read(const Message* m, void** iter, param_type* p);
    252   static void Log(const param_type& p, std::string* l);
    253 };
    254 
    255 #if defined(OS_WIN)
    256 
    257 // Traits for SetWindowPos_Params structure to pack/unpack.
    258 template <>
    259 struct ParamTraits<Reposition_Params> {
    260   typedef Reposition_Params param_type;
    261   static void Write(Message* m, const param_type& p) {
    262     WriteParam(m, p.window);
    263     WriteParam(m, p.window_insert_after);
    264     WriteParam(m, p.left);
    265     WriteParam(m, p.top);
    266     WriteParam(m, p.width);
    267     WriteParam(m, p.height);
    268     WriteParam(m, p.flags);
    269     WriteParam(m, p.set_parent);
    270     WriteParam(m, p.parent_window);
    271   }
    272   static bool Read(const Message* m, void** iter, param_type* p) {
    273     return ReadParam(m, iter, &p->window) &&
    274            ReadParam(m, iter, &p->window_insert_after) &&
    275            ReadParam(m, iter, &p->left) &&
    276            ReadParam(m, iter, &p->top) &&
    277            ReadParam(m, iter, &p->width) &&
    278            ReadParam(m, iter, &p->height) &&
    279            ReadParam(m, iter, &p->flags) &&
    280            ReadParam(m, iter, &p->set_parent) &&
    281            ReadParam(m, iter, &p->parent_window);
    282   }
    283   static void Log(const param_type& p, std::string* l) {
    284     l->append("(");
    285     LogParam(p.window, l);
    286     l->append(", ");
    287     LogParam(p.window_insert_after, l);
    288     l->append(", ");
    289     LogParam(p.left, l);
    290     l->append(", ");
    291     LogParam(p.top, l);
    292     l->append(", ");
    293     LogParam(p.width, l);
    294     l->append(", ");
    295     LogParam(p.height, l);
    296     l->append(", ");
    297     LogParam(p.flags, l);
    298     l->append(", ");
    299     LogParam(p.set_parent, l);
    300     l->append(", ");
    301     LogParam(p.parent_window, l);
    302     l->append(")");
    303   }
    304 };
    305 #endif  // defined(OS_WIN)
    306 
    307 // Traits for AutomationURLRequest structure to pack/unpack.
    308 template <>
    309 struct ParamTraits<AutomationURLRequest> {
    310   typedef AutomationURLRequest param_type;
    311   static void Write(Message* m, const param_type& p);
    312   static bool Read(const Message* m, void** iter, param_type* p);
    313   static void Log(const param_type& p, std::string* l);
    314 };
    315 
    316 // Traits for AutomationURLResponse structure to pack/unpack.
    317 template <>
    318 struct ParamTraits<AutomationURLResponse> {
    319   typedef AutomationURLResponse param_type;
    320   static void Write(Message* m, const param_type& p);
    321   static bool Read(const Message* m, void** iter, param_type* p);
    322   static void Log(const param_type& p, std::string* l);
    323 };
    324 
    325 // Traits for ExternalTabSettings structure to pack/unpack.
    326 template <>
    327 struct ParamTraits<ExternalTabSettings> {
    328   typedef ExternalTabSettings param_type;
    329   static void Write(Message* m, const param_type& p);
    330   static bool Read(const Message* m, void** iter, param_type* p);
    331   static void Log(const param_type& p, std::string* l);
    332 };
    333 
    334 // Traits for NavigationInfo structure to pack/unpack.
    335 template <>
    336 struct ParamTraits<NavigationInfo> {
    337   typedef NavigationInfo param_type;
    338   static void Write(Message* m, const param_type& p);
    339   static bool Read(const Message* m, void** iter, param_type* p);
    340   static void Log(const param_type& p, std::string* l);
    341 };
    342 
    343 // Traits for MiniContextMenuParams structure to pack/unpack.
    344 template <>
    345 struct ParamTraits<MiniContextMenuParams> {
    346   typedef MiniContextMenuParams param_type;
    347   static void Write(Message* m, const param_type& p);
    348   static bool Read(const Message* m, void** iter, param_type* p);
    349   static void Log(const param_type& p, std::string* l);
    350 };
    351 
    352 template <>
    353 struct ParamTraits<AttachExternalTabParams> {
    354   typedef AttachExternalTabParams param_type;
    355   static void Write(Message* m, const param_type& p);
    356   static bool Read(const Message* m, void** iter, param_type* p);
    357   static void Log(const param_type& p, std::string* l);
    358 };
    359 
    360 }  // namespace IPC
    361 
    362 #endif  // CHROME_COMMON_AUTOMATION_MESSAGES_H__
    363 
    364 // Keep this internal message file unchanged to preserve line numbering
    365 // (and hence the dubious __LINE__-based message numberings) across versions.
    366 #include "chrome/common/automation_messages_internal.h"
    367 
    368