OLD | NEW |
| (Empty) |
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 #ifndef CHROME_FRAME_CFPROXY_PRIVATE_H_ | |
6 #define CHROME_FRAME_CFPROXY_PRIVATE_H_ | |
7 #pragma once | |
8 | |
9 #include <map> | |
10 #include <set> | |
11 #include <string> | |
12 #include <vector> | |
13 | |
14 #include "chrome_frame/cfproxy.h" | |
15 #include "base/threading/thread.h" | |
16 // Since we can't forward declare IPC::Message::Sender or IPC::Channel::Listener | |
17 #include "ipc/ipc_message.h" | |
18 #include "ipc/ipc_channel.h" | |
19 | |
20 typedef std::map<int, ChromeProxyDelegate*> TabsMap; | |
21 | |
22 // This is the functions needed by CFProxy implementation. | |
23 // Extracted in separate class so we can mock it. | |
24 class CFProxyTraits { | |
25 public: | |
26 virtual IPC::Message::Sender* CreateChannel(const std::string& id, | |
27 IPC::Channel::Listener* l); | |
28 virtual void CloseChannel(IPC::Message::Sender* s); | |
29 virtual bool LaunchApp(const std::wstring& cmd_line); | |
30 }; | |
31 | |
32 // Holds a queue of sent synchronous IPC messages. Knows how to dispatch | |
33 // the replies. | |
34 class SyncMsgSender { | |
35 public: | |
36 explicit SyncMsgSender(TabsMap* tab2delegate); | |
37 void QueueSyncMessage(const IPC::SyncMessage* msg, | |
38 ChromeProxyDelegate* delegate, SyncMessageContext* ctx); | |
39 bool OnReplyReceived(const IPC::Message* reply_msg); | |
40 void OnChannelClosed(); | |
41 void Cancel(ChromeProxyDelegate* delegate); | |
42 private: | |
43 // sync_message_id -> (message_type, delegate, context) | |
44 struct SingleSentMessage { | |
45 SingleSentMessage() : type_(0), ctx_(NULL), delegate_(NULL) {} | |
46 SingleSentMessage(uint32 type, | |
47 ChromeProxyDelegate* delegate, | |
48 SyncMessageContext* ctx) | |
49 : type_(type), ctx_(ctx), delegate_(delegate) {} | |
50 ~SingleSentMessage() { delete ctx_; } | |
51 uint32 type_; | |
52 SyncMessageContext* ctx_; | |
53 ChromeProxyDelegate* delegate_; | |
54 }; | |
55 | |
56 SingleSentMessage* RemoveMessage(int id); | |
57 typedef std::map<int, SingleSentMessage*> SentMessages; | |
58 SentMessages messages_; | |
59 base::Lock messages_lock_; | |
60 TabsMap* tab2delegate_; | |
61 }; | |
62 | |
63 // Converts method call to an IPC message and then send it over Message::Sender | |
64 class Interface2IPCMessage : public ChromeProxy { | |
65 public: | |
66 Interface2IPCMessage() {} | |
67 | |
68 // General | |
69 virtual void RemoveBrowsingData(int mask); | |
70 virtual void SetProxyConfig(const std::string& json_encoded_proxy_cfg); | |
71 // Tab related. | |
72 virtual void Tab_PostMessage(int tab, const std::string& message, | |
73 const std::string& origin, const std::string& target); | |
74 virtual void Tab_Reload(int tab); | |
75 virtual void Tab_Stop(int tab); | |
76 virtual void Tab_SaveAs(int tab); | |
77 virtual void Tab_Print(int tab); | |
78 virtual void Tab_Cut(int tab); | |
79 virtual void Tab_Copy(int tab); | |
80 virtual void Tab_Paste(int tab); | |
81 virtual void Tab_SelectAll(int tab); | |
82 virtual void Tab_MenuCommand(int tab, int selected_command); | |
83 virtual void Tab_Zoom(int tab, content::PageZoom zoom_level); | |
84 virtual void Tab_FontSize(int tab, enum AutomationPageFontSize font_size); | |
85 virtual void Tab_SetInitialFocus(int tab, bool reverse, | |
86 bool restore_focus_to_view); | |
87 virtual void Tab_SetParentWindow(int tab); | |
88 virtual void Tab_Resize(int tab); | |
89 virtual void Tab_ProcessAccelerator(int tab, const MSG& msg); | |
90 | |
91 // Misc. | |
92 virtual void Tab_OnHostMoved(int tab); | |
93 protected: | |
94 ~Interface2IPCMessage() {} | |
95 private: | |
96 IPC::Message::Sender* sender_; | |
97 }; | |
98 | |
99 // Simple class to keep a list of pointers to ChromeProxyDelegate for a | |
100 // specific proxy as well as mapping between tab_id -> ChromeProxyDelegate. | |
101 class DelegateHolder { | |
102 protected: | |
103 DelegateHolder() { | |
104 } | |
105 | |
106 void AddDelegate(ChromeProxyDelegate* p); | |
107 void RemoveDelegate(ChromeProxyDelegate* p); | |
108 // Helper | |
109 ChromeProxyDelegate* Tab2Delegate(int tab_handle); | |
110 TabsMap tab2delegate_; | |
111 typedef std::set<ChromeProxyDelegate*> DelegateList; | |
112 DelegateList delegate_list_; | |
113 }; | |
114 | |
115 // ChromeFrame Automation Proxy implementation. | |
116 class CFProxy : public Interface2IPCMessage, | |
117 public IPC::Channel::Listener, | |
118 public DelegateHolder { | |
119 public: | |
120 explicit CFProxy(CFProxyTraits* api); | |
121 ~CFProxy(); | |
122 | |
123 private: | |
124 virtual void Init(const ProxyParams& params); | |
125 virtual int AddDelegate(ChromeProxyDelegate* p); | |
126 virtual int RemoveDelegate(ChromeProxyDelegate* p); | |
127 | |
128 // Executed in IPC thread. | |
129 void AddDelegateOnIoThread(ChromeProxyDelegate* p); | |
130 void RemoveDelegateOnIoThread(ChromeProxyDelegate* p); | |
131 // Initialization that has to be mede in IPC thread. | |
132 void InitInIoThread(const ProxyParams& params); | |
133 // Cleanup that has to be made in IPC thread. | |
134 void CleanupOnIoThread(); | |
135 // IPC connection was not established in timely manner | |
136 void LaunchTimeOut(); | |
137 // Close channel, inform delegates. | |
138 void OnPeerLost(ChromeProxyDelegate::DisconnectReason reason); | |
139 // Queues message to be send in IPC thread. | |
140 void SendIpcMessage(IPC::Message* m); | |
141 // Same but in IPC thread. | |
142 void SendIpcMessageOnIoThread(IPC::Message* m); | |
143 | |
144 ////////////////////////////////////////////////////////////////////////// | |
145 // Sync messages. | |
146 virtual void Tab_Find(int tab, const string16& search_string, | |
147 FindInPageDirection forward, FindInPageCase match_case, bool find_next); | |
148 virtual void Tab_OverrideEncoding(int tab, const char* encoding); | |
149 virtual void Tab_Navigate(int tab, const GURL& url, const GURL& referrer); | |
150 virtual void CreateTab(ChromeProxyDelegate* delegate, | |
151 const ExternalTabSettings& p); | |
152 virtual void ConnectTab(ChromeProxyDelegate* delegate, HWND hwnd, | |
153 uint64 cookie); | |
154 virtual void BlockTab(uint64 cookie); | |
155 virtual void Tab_RunUnloadHandlers(int tab); | |
156 | |
157 ////////////////////////////////////////////////////////////////////////// | |
158 // IPC::Channel::Listener implementation. | |
159 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE; | |
160 virtual void OnChannelConnected(int32 peer_pid) OVERRIDE; | |
161 virtual void OnChannelError() OVERRIDE; | |
162 | |
163 bool CalledOnIpcThread() const { | |
164 return base::PlatformThread::CurrentId() == ipc_thread_.thread_id(); | |
165 } | |
166 | |
167 base::Thread ipc_thread_; | |
168 SyncMsgSender sync_dispatcher_; | |
169 IPC::Message::Sender* ipc_sender_; | |
170 CFProxyTraits* api_; | |
171 int delegate_count_; | |
172 bool is_connected_; | |
173 }; | |
174 | |
175 // Support functions. | |
176 std::string GenerateChannelId(); | |
177 std::wstring BuildCmdLine(const std::string& channel_id, | |
178 const FilePath& profile_path, | |
179 const std::wstring& extra_args); | |
180 #endif // CHROME_FRAME_CFPROXY_PRIVATE_H_ | |
OLD | NEW |