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
|
// 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.
#ifndef CHROME_FRAME_CFPROXY_H_
#define CHROME_FRAME_CFPROXY_H_
#pragma once
#include <windows.h>
#include <map> // for proxy factory
#include <vector>
#include <string>
#include "base/lock.h"
#include "base/time.h" // for base::TimeDelta
#include "base/file_path.h"
#include "chrome/common/automation_constants.h"
#include "chrome/common/page_zoom.h"
enum FindInPageDirection { BACK = 0, FWD = 1 };
enum FindInPageCase { IGNORE_CASE = 0, CASE_SENSITIVE = 1 };
// Specifies the font size on a page which is requested by an automation
// client.
enum AutomationPageFontSize {
SMALLEST_FONT = 8,
SMALL_FONT = 12,
MEDIUM_FONT = 16,
LARGE_FONT = 24,
LARGEST_FONT = 36
};
class URLRequestStatus;
namespace IPC {
struct ExternalTabSettings;
struct NavigationInfo;
struct AutomationURLRequest;
struct AttachExternalTabParams;
struct MiniContextMenuParams;
};
class GURL;
class ChromeProxyFactory;
class ChromeProxyDelegate;
struct ProxyParams;
// Some callers of synchronous messages wants a context to be passed back
// in order to identify the call they made. Presumably one can make
// multiple sync calls of same type (as async) and want to identify what
// is what.
struct SyncMessageContext {
virtual ~SyncMessageContext() {}
};
/*
[npapi] UIDelegate (UI_THREAD)
[activex] <---------------+
[activedoc] |
|
| ChromeProxy (UI_THREAD)
+----------------+ --------------> +-------+
URL_FETCHER <---------|ExternalTabProxy| |CFProxy|
+----------------+ +-------+
|
^ |
| |
+-----------------------------+
ChromeProxyDelegate (IPC_THREAD)
*/
// ChromeProxy is an abstract class. Is forwards the commands to an
// instance of the running Chromium browser.
// A pointer to ChromeProxy instance is obtained through a
// ChromeProxyFactory object.
class ChromeProxy {
public:
// General
virtual void RemoveBrowsingData(int remove_mask) = 0; // async
virtual void InstallExtension(ChromeProxyDelegate* delegate,
const FilePath& crx_path,
SyncMessageContext* ctx) = 0;
virtual void LoadExtension(ChromeProxyDelegate* delegate,
const FilePath& path,
SyncMessageContext* ctx) = 0;
virtual void GetEnabledExtensions(ChromeProxyDelegate* delegate,
SyncMessageContext* ctx) = 0;
virtual void SetProxyConfig(const std::string& json_encoded_settings) = 0;
// Tab management.
virtual void CreateTab(ChromeProxyDelegate* delegate,
const IPC::ExternalTabSettings& settings) = 0;
virtual void ConnectTab(ChromeProxyDelegate* delegate, HWND hwnd,
uint64 cookie) = 0;
virtual void BlockTab(uint64 cookie) = 0;
// Tab related.
virtual void Tab_PostMessage(int tab, const std::string& message,
const std::string& origin,
const std::string& target) = 0;
virtual void Tab_Reload(int tab) = 0;
virtual void Tab_Stop(int tab) = 0;
virtual void Tab_SaveAs(int tab) = 0;
virtual void Tab_Print(int tab) = 0;
virtual void Tab_Cut(int tab) = 0;
virtual void Tab_Copy(int tab) = 0;
virtual void Tab_Paste(int tab) = 0;
virtual void Tab_SelectAll(int tab) = 0;
virtual void Tab_Find(int tab, const string16& search_string,
FindInPageDirection forward, FindInPageCase match_case,
bool find_next) = 0;
virtual void Tab_MenuCommand(int tab, int selected_command) = 0;
// UI
virtual void Tab_Zoom(int tab, PageZoom::Function zoom_level) = 0;
virtual void Tab_FontSize(int tab, enum AutomationPageFontSize font_size) = 0;
virtual void Tab_SetInitialFocus(int tab,
bool reverse, bool restore_focus_to_view) = 0;
virtual void Tab_SetParentWindow(int tab) = 0;
virtual void Tab_Resize(int tab) = 0;
virtual void Tab_ProcessAccelerator(int tab, const MSG& msg) = 0;
// Misc.
virtual void Tab_OnHostMoved(int tab) = 0;
virtual void Tab_RunUnloadHandlers(int tab) = 0;
virtual void Tab_SetEnableExtensionAutomation(int tab,
const std::vector<std::string>& functions_enabled) = 0;
virtual void Tab_Navigate(int tab, const GURL& url, const GURL& referrer) = 0;
virtual void Tab_OverrideEncoding(int tab, const char* encoding) = 0;
protected:
// Accessible by ChromeProxyFactory
friend class ChromeProxyFactory;
virtual ~ChromeProxy() {}
virtual void Init(const ProxyParams& params) = 0;
virtual int AddDelegate(ChromeProxyDelegate* delegate) = 0;
virtual int RemoveDelegate(ChromeProxyDelegate* delegate) = 0;
};
// The object that uses ChromeProxy should implement ChromeProxyDelegate in
// order to get notified about important events/requests coming from the
// instance of Chromium.
// Allow only one delegate per tab, i.e. delegate can handle only a single tab.
// Note: all of the methods are invoked always in a background IPC thread.
class ChromeProxyDelegate {
public:
enum DisconnectReason {
CHROME_EXE_LAUNCH_FAILED,
CHROME_EXE_LAUNCH_TIMEOUT,
CHANNEL_ERROR
};
virtual void Connected(ChromeProxy* proxy) = 0;
virtual void Disconnected() = 0;
virtual void PeerLost(ChromeProxy* proxy, DisconnectReason reason) = 0;
virtual int tab_handle() = 0; // to avoid reverse lookup :)
// Sync message responses.
virtual void Completed_CreateTab(bool success, HWND chrome_wnd,
HWND tab_window, int tab_handle) = 0;
virtual void Completed_ConnectToTab(bool success, HWND chrome_window,
HWND tab_window, int tab_handle) = 0;
virtual void Completed_Navigate(bool success,
enum AutomationMsg_NavigationResponseValues res) = 0;
virtual void Completed_InstallExtension(bool success,
AutomationMsg_ExtensionResponseValues res, SyncMessageContext* ctx) = 0;
virtual void Completed_LoadExpandedExtension(bool success,
AutomationMsg_ExtensionResponseValues res, SyncMessageContext* ctx) = 0;
virtual void Completed_GetEnabledExtensions(bool success,
const std::vector<FilePath>* extensions) = 0;
// Network requests from Chrome.
virtual void Network_Start(int request_id,
const IPC::AutomationURLRequest& request_info) = 0;
virtual void Network_Read(int request_id, int bytes_to_read) = 0;
virtual void Network_End(int request_id, const URLRequestStatus& status) = 0;
virtual void Network_DownloadInHost(int request_id) = 0;
virtual void GetCookies(const GURL& url, int cookie_id) = 0;
virtual void SetCookie(const GURL& url, const std::string& cookie) = 0;
// Navigation progress notifications.
virtual void NavigationStateChanged(int flags,
const IPC::NavigationInfo& nav_info) = 0;
virtual void UpdateTargetUrl(const std::wstring& url) = 0;
virtual void NavigationFailed(int error_code, const GURL& gurl) = 0;
virtual void DidNavigate(const IPC::NavigationInfo& navigation_info) = 0;
virtual void TabLoaded(const GURL& url) = 0;
// Navigation and messaging.
virtual void OpenURL(const GURL& url_to_open, const GURL& referrer,
int open_disposition) = 0;
virtual void GoToHistoryOffset(int offset) = 0;
virtual void MessageToHost(const std::string& message,
const std::string& origin,
const std::string& target) = 0;
// Misc. UI.
virtual void HandleAccelerator(const MSG& accel_message) = 0;
virtual void HandleContextMenu(HANDLE menu_handle, int align_flags,
const IPC::MiniContextMenuParams& params) = 0;
virtual void TabbedOut(bool reverse) = 0;
// Tab related.
virtual void TabClosed() = 0;
virtual void AttachTab(const IPC::AttachExternalTabParams& attach_params) = 0;
protected:
~ChromeProxyDelegate() {}
};
// a way to obtain a ChromeProxy implementation
struct ProxyParams {
std::string profile;
std::wstring extra_params;
FilePath profile_path;
base::TimeDelta timeout;
};
class ChromeProxyFactory {
public:
ChromeProxyFactory();
~ChromeProxyFactory();
void GetProxy(ChromeProxyDelegate* delegate, const ProxyParams& params);
bool ReleaseProxy(ChromeProxyDelegate* delegate, const std::string& profile);
protected:
virtual ChromeProxy* CreateProxy();
typedef std::map<std::string, ChromeProxy*> ProxyMap;
ProxyMap proxies_;
Lock lock_;
};
#endif // CHROME_FRAME_CFPROXY_H_
|
