Replace uses of ArgumentEncoder/ArgumentDecoder with MessageEncoder/MessageDecoder
[WebKit-https.git] / Source / WebKit2 / UIProcess / WebProcessProxy.h
1 /*
2  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef WebProcessProxy_h
27 #define WebProcessProxy_h
28
29 #include "PlatformProcessIdentifier.h"
30 #include "PluginInfoStore.h"
31 #include "ProcessLauncher.h"
32 #include "ResponsivenessTimer.h"
33 #include "WebConnectionToWebProcess.h"
34 #include "WebPageProxy.h"
35 #include "WebProcessProxyMessages.h"
36 #include <WebCore/LinkHash.h>
37 #include <wtf/Forward.h>
38 #include <wtf/HashMap.h>
39 #include <wtf/PassRefPtr.h>
40 #include <wtf/RefCounted.h>
41
42 namespace WebCore {
43     class KURL;
44 };
45
46 namespace WebKit {
47
48 #if USE(SECURITY_FRAMEWORK)
49 class SecItemRequestData;
50 class SecItemResponseData;
51 #endif
52
53 class WebBackForwardListItem;
54 class WebContext;
55 class WebPageGroup;
56 struct WebNavigationDataStore;
57
58 class WebProcessProxy : public ThreadSafeRefCounted<WebProcessProxy>, CoreIPC::Connection::Client, ResponsivenessTimer::Client, ProcessLauncher::Client,  CoreIPC::Connection::QueueClient {
59 public:
60     typedef HashMap<uint64_t, RefPtr<WebFrameProxy> > WebFrameProxyMap;
61     typedef HashMap<uint64_t, RefPtr<WebBackForwardListItem> > WebBackForwardListItemMap;
62
63     static PassRefPtr<WebProcessProxy> create(PassRefPtr<WebContext>);
64     ~WebProcessProxy();
65
66     static WebProcessProxy* fromConnection(CoreIPC::Connection*);
67
68     void terminate();
69
70     template<typename T> bool send(const T& message, uint64_t destinationID, unsigned messageSendFlags = 0);
71     template<typename U> bool sendSync(const U& message, const typename U::Reply& reply, uint64_t destinationID, double timeout = 1);
72     
73     CoreIPC::Connection* connection() const
74     { 
75         ASSERT(m_connection);
76         
77         return m_connection->connection(); 
78     }
79     WebConnection* webConnection() const { return m_connection.get(); }
80
81     WebContext* context() const { return m_context.get(); }
82
83     PlatformProcessIdentifier processIdentifier() const { return m_processLauncher->processIdentifier(); }
84
85     WebPageProxy* webPage(uint64_t pageID) const;
86     PassRefPtr<WebPageProxy> createWebPage(PageClient*, WebContext*, WebPageGroup*);
87     void addExistingWebPage(WebPageProxy*, uint64_t pageID);
88     void removeWebPage(uint64_t pageID);
89     Vector<WebPageProxy*> pages() const;
90
91 #if ENABLE(WEB_INTENTS)
92     void removeMessagePortChannel(uint64_t channelID);
93 #endif
94
95     WebBackForwardListItem* webBackForwardItem(uint64_t itemID) const;
96
97     ResponsivenessTimer* responsivenessTimer() { return &m_responsivenessTimer; }
98
99     bool isValid() const { return m_connection; }
100     bool isLaunching() const;
101     bool canSendMessage() const { return isValid() || isLaunching(); }
102
103     WebFrameProxy* webFrame(uint64_t) const;
104     bool canCreateFrame(uint64_t frameID) const;
105     void frameCreated(uint64_t, WebFrameProxy*);
106     void disconnectFramesFromPage(WebPageProxy*); // Including main frame.
107     size_t frameCountInPage(WebPageProxy*) const; // Including main frame.
108
109     void updateTextCheckerState();
110
111     void registerNewWebBackForwardListItem(WebBackForwardListItem*);
112
113     void willAcquireUniversalFileReadSandboxExtension() { m_mayHaveUniversalFileReadSandboxExtension = true; }
114     void assumeReadAccessToBaseURL(const String&);
115
116     bool checkURLReceivedFromWebProcess(const String&);
117     bool checkURLReceivedFromWebProcess(const WebCore::KURL&);
118
119     static bool fullKeyboardAccessEnabled();
120
121     // FIXME: This variant of send is deprecated. All clients should move to an overload that take a message type.
122     template<typename E, typename T> bool deprecatedSend(E messageID, uint64_t destinationID, const T& arguments);
123
124 private:
125     explicit WebProcessProxy(PassRefPtr<WebContext>);
126
127     // Initializes the process launcher which will begin launching the process.
128     void connect();
129     void platformConnect(ProcessLauncher::LaunchOptions&);
130
131     // Called when the web process has crashed or we know that it will terminate soon.
132     // Will potentially cause the WebProcessProxy object to be freed.
133     void disconnect();
134
135     bool sendMessage(CoreIPC::MessageID, PassOwnPtr<CoreIPC::MessageEncoder>, unsigned messageSendFlags);
136
137     // CoreIPC message handlers.
138     void addBackForwardItem(uint64_t itemID, const String& originalURLString, const String& urlString, const String& title, const CoreIPC::DataReference& backForwardData);
139     void didDestroyFrame(uint64_t);
140     
141     void shouldTerminate(bool& shouldTerminate);
142
143     // Plugins
144     void getPlugins(CoreIPC::Connection*, uint64_t requestID, bool refresh);
145     void getPluginPath(const String& mimeType, const String& urlString, String& pluginPath, bool& blocked);
146 #if ENABLE(PLUGIN_PROCESS)
147     void getPluginProcessConnection(const String& pluginPath, PassRefPtr<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply>);
148 #else
149     void didGetSitesWithPluginData(const Vector<String>& sites, uint64_t callbackID);
150     void didClearPluginSiteData(uint64_t callbackID);
151 #endif
152
153     void handleGetPlugins(uint64_t requestID, bool refresh);
154     void sendDidGetPlugins(uint64_t requestID, PassOwnPtr<Vector<WebCore::PluginInfo> >);
155
156     void getSharedWorkerProcessConnection(const String& url, const String& name, PassRefPtr<Messages::WebProcessProxy::GetSharedWorkerProcessConnection::DelayedReply>);
157
158 #if USE(SECURITY_FRAMEWORK)
159     void secItemRequest(CoreIPC::Connection*, uint64_t requestID, const SecItemRequestData&);
160     void secKeychainItemRequest(CoreIPC::Connection*, uint64_t requestID, const SecKeychainItemRequestData&);
161 #endif
162
163     // CoreIPC::Connection::Client
164     friend class WebConnectionToWebProcess;
165     virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&);
166     virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&, OwnPtr<CoreIPC::MessageEncoder>&);
167     virtual void didClose(CoreIPC::Connection*);
168     virtual void didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::MessageID);
169 #if PLATFORM(WIN)
170     virtual Vector<HWND> windowsToReceiveSentMessagesWhileWaitingForSyncReply();
171 #endif
172
173     // CoreIPC::Connection::QueueClient
174     virtual void didReceiveMessageOnConnectionWorkQueue(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&, bool& didHandleMessage) OVERRIDE;
175
176     // ResponsivenessTimer::Client
177     void didBecomeUnresponsive(ResponsivenessTimer*) OVERRIDE;
178     void interactionOccurredWhileUnresponsive(ResponsivenessTimer*) OVERRIDE;
179     void didBecomeResponsive(ResponsivenessTimer*) OVERRIDE;
180
181     // ProcessLauncher::Client
182     virtual void didFinishLaunching(ProcessLauncher*, CoreIPC::Connection::Identifier);
183
184     void didFinishLaunching(CoreIPC::Connection::Identifier);
185
186     // History client
187     void didNavigateWithNavigationData(uint64_t pageID, const WebNavigationDataStore&, uint64_t frameID);
188     void didPerformClientRedirect(uint64_t pageID, const String& sourceURLString, const String& destinationURLString, uint64_t frameID);
189     void didPerformServerRedirect(uint64_t pageID, const String& sourceURLString, const String& destinationURLString, uint64_t frameID);
190     void didUpdateHistoryTitle(uint64_t pageID, const String& title, const String& url, uint64_t frameID);
191
192     // Implemented in generated WebProcessProxyMessageReceiver.cpp
193     void didReceiveWebProcessProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&);
194     void didReceiveSyncWebProcessProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&, OwnPtr<CoreIPC::MessageEncoder>&);
195     void didReceiveWebProcessProxyMessageOnConnectionWorkQueue(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&, bool& didHandleMessage);
196
197     ResponsivenessTimer m_responsivenessTimer;
198     
199     // This is not a CoreIPC::Connection so that we can wrap the CoreIPC::Connection in
200     // an API object.
201     RefPtr<WebConnectionToWebProcess> m_connection;
202
203     Vector<std::pair<CoreIPC::Connection::OutgoingMessage, unsigned> > m_pendingMessages;
204     RefPtr<ProcessLauncher> m_processLauncher;
205
206     RefPtr<WebContext> m_context;
207
208     bool m_mayHaveUniversalFileReadSandboxExtension; // True if a read extension for "/" was ever granted - we don't track whether WebProcess still has it.
209     HashSet<String> m_localPathsWithAssumedReadAccess;
210
211     HashMap<uint64_t, WebPageProxy*> m_pageMap;
212     WebFrameProxyMap m_frameMap;
213     WebBackForwardListItemMap m_backForwardListItemMap;
214 };
215
216 template<typename E, typename T>
217 bool WebProcessProxy::deprecatedSend(E messageID, uint64_t destinationID, const T& arguments)
218 {
219     OwnPtr<CoreIPC::MessageEncoder> encoder = CoreIPC::MessageEncoder::create("", "", destinationID);
220     encoder->encode(arguments);
221
222     return sendMessage(CoreIPC::MessageID(messageID), encoder.release(), 0);
223 }
224
225 template<typename T>
226 bool WebProcessProxy::send(const T& message, uint64_t destinationID, unsigned messageSendFlags)
227 {
228     OwnPtr<CoreIPC::MessageEncoder> encoder = CoreIPC::MessageEncoder::create("", "", destinationID);
229     encoder->encode(message);
230
231     return sendMessage(CoreIPC::MessageID(T::messageID), encoder.release(), messageSendFlags);
232 }
233
234 template<typename U> 
235 bool WebProcessProxy::sendSync(const U& message, const typename U::Reply& reply, uint64_t destinationID, double timeout)
236 {
237     if (!m_connection)
238         return false;
239
240     return connection()->sendSync(message, reply, destinationID, timeout);
241 }
242     
243 } // namespace WebKit
244
245 #endif // WebProcessProxy_h