1 // Copyright (c) 2013 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_TEST_CHROMEDRIVER_CHROME_WEB_VIEW_IMPL_H_
6 #define CHROME_TEST_CHROMEDRIVER_CHROME_WEB_VIEW_IMPL_H_
7 
8 #include <memory>
9 #include <string>
10 
11 #include "base/callback.h"
12 #include "base/compiler_specific.h"
13 #include "base/containers/flat_map.h"
14 #include "chrome/test/chromedriver/chrome/web_view.h"
15 
16 namespace base {
17 class DictionaryValue;
18 class ListValue;
19 class Value;
20 }
21 
22 struct BrowserInfo;
23 struct DeviceMetrics;
24 class DevToolsClient;
25 class DomTracker;
26 class DownloadDirectoryOverrideManager;
27 class FrameTracker;
28 class GeolocationOverrideManager;
29 class MobileEmulationOverrideManager;
30 class NetworkConditionsOverrideManager;
31 class HeapSnapshotTaker;
32 struct KeyEvent;
33 struct MouseEvent;
34 class PageLoadStrategy;
35 class Status;
36 class CastTracker;
37 
38 class WebViewImpl : public WebView {
39  public:
40   WebViewImpl(const std::string& id,
41               const bool w3c_compliant,
42               const WebViewImpl* parent,
43               const BrowserInfo* browser_info,
44               std::unique_ptr<DevToolsClient> client,
45               const DeviceMetrics* device_metrics,
46               std::string page_load_strategy);
47   ~WebViewImpl() override;
48   WebViewImpl* CreateChild(const std::string& session_id,
49                            const std::string& target_id) const;
50 
51   // Overridden from WebView:
52   std::string GetId() override;
53   bool WasCrashed() override;
54   Status ConnectIfNecessary() override;
55   Status SetUpDevTools() override;
56   Status HandleReceivedEvents() override;
57   Status GetUrl(std::string* url) override;
58   Status Load(const std::string& url, const Timeout* timeout) override;
59   Status Reload(const Timeout* timeout) override;
60   Status Freeze(const Timeout* timeout) override;
61   Status Resume(const Timeout* timeout) override;
62   Status SendCommand(const std::string& cmd,
63                      const base::DictionaryValue& params) override;
64   Status SendCommandFromWebSocket(const std::string& cmd,
65                                   const base::DictionaryValue& params,
66                                   const int client_cmd_id) override;
67   Status SendCommandAndGetResult(const std::string& cmd,
68                                  const base::DictionaryValue& params,
69                                  std::unique_ptr<base::Value>* value) override;
70   Status TraverseHistory(int delta, const Timeout* timeout) override;
71   Status EvaluateScriptWithTimeout(const std::string& frame,
72                                    const std::string& expression,
73                                    const base::TimeDelta& timeout,
74                                    const bool awaitPromise,
75                                    std::unique_ptr<base::Value>* result);
76   Status EvaluateScript(const std::string& frame,
77                         const std::string& expression,
78                         const bool awaitPromise,
79                         std::unique_ptr<base::Value>* result) override;
80   Status CallFunctionWithTimeout(const std::string& frame,
81                                  const std::string& function,
82                                  const base::ListValue& args,
83                                  const base::TimeDelta& timeout,
84                                  std::unique_ptr<base::Value>* result);
85   Status CallFunction(const std::string& frame,
86                       const std::string& function,
87                       const base::ListValue& args,
88                       std::unique_ptr<base::Value>* result) override;
89   Status CallAsyncFunction(const std::string& frame,
90                            const std::string& function,
91                            const base::ListValue& args,
92                            const base::TimeDelta& timeout,
93                            std::unique_ptr<base::Value>* result) override;
94   Status CallUserSyncScript(const std::string& frame,
95                             const std::string& script,
96                             const base::ListValue& args,
97                             const base::TimeDelta& timeout,
98                             std::unique_ptr<base::Value>* result) override;
99   Status CallUserAsyncFunction(const std::string& frame,
100                                const std::string& function,
101                                const base::ListValue& args,
102                                const base::TimeDelta& timeout,
103                                std::unique_ptr<base::Value>* result) override;
104   Status GetFrameByFunction(const std::string& frame,
105                             const std::string& function,
106                             const base::ListValue& args,
107                             std::string* out_frame) override;
108   Status DispatchMouseEvents(const std::vector<MouseEvent>& events,
109                              const std::string& frame,
110                              bool async_dispatch_events = false) override;
111   Status DispatchTouchEvent(const TouchEvent& event,
112                             bool async_dispatch_events = false) override;
113   Status DispatchTouchEvents(const std::vector<TouchEvent>& events,
114                              bool async_dispatch_events = false) override;
115   Status DispatchTouchEventWithMultiPoints(
116       const std::vector<TouchEvent>& events,
117       bool async_dispatch_events = false) override;
118   Status DispatchKeyEvents(const std::vector<KeyEvent>& events,
119                            bool async_dispatch_events = false) override;
120   Status GetCookies(std::unique_ptr<base::ListValue>* cookies,
121                     const std::string& current_page_url) override;
122   Status DeleteCookie(const std::string& name,
123                       const std::string& url,
124                       const std::string& domain,
125                       const std::string& path) override;
126   Status AddCookie(const std::string& name,
127                    const std::string& url,
128                    const std::string& value,
129                    const std::string& domain,
130                    const std::string& path,
131                    const std::string& sameSite,
132                    bool secure,
133                    bool httpOnly,
134                    double expiry) override;
135   Status WaitForPendingNavigations(const std::string& frame_id,
136                                    const Timeout& timeout,
137                                    bool stop_load_on_timeout) override;
138   Status IsPendingNavigation(const Timeout* timeout,
139                              bool* is_pending) const override;
140   JavaScriptDialogManager* GetJavaScriptDialogManager() override;
141   MobileEmulationOverrideManager* GetMobileEmulationOverrideManager()
142       const override;
143   Status OverrideGeolocation(const Geoposition& geoposition) override;
144   Status OverrideNetworkConditions(
145       const NetworkConditions& network_conditions) override;
146   Status OverrideDownloadDirectoryIfNeeded(
147       const std::string& download_directory) override;
148   Status CaptureScreenshot(
149       std::string* screenshot,
150       const base::DictionaryValue& params) override;
151   Status PrintToPDF(const base::DictionaryValue& params,
152                     std::string* pdf) override;
153   Status SetFileInputFiles(const std::string& frame,
154                            const base::DictionaryValue& element,
155                            const std::vector<base::FilePath>& files,
156                            const bool append) override;
157   Status TakeHeapSnapshot(std::unique_ptr<base::Value>* snapshot) override;
158   Status StartProfile() override;
159   Status EndProfile(std::unique_ptr<base::Value>* profile_data) override;
160   Status SynthesizeTapGesture(int x,
161                               int y,
162                               int tap_count,
163                               bool is_long_press) override;
164   Status SynthesizeScrollGesture(int x,
165                                  int y,
166                                  int xoffset,
167                                  int yoffset) override;
168   Status GetNodeIdByElement(const std::string& frame,
169                             const base::DictionaryValue& element,
170                             int* node_id) override;
171 
172   bool IsNonBlocking() const override;
173   bool IsOOPIF(const std::string& frame_id) override;
174   FrameTracker* GetFrameTracker() const override;
175   std::unique_ptr<base::Value> GetCastSinks() override;
176   std::unique_ptr<base::Value> GetCastIssueMessage() override;
177   void SetFrame(const std::string& new_frame_id) override;
178 
179   const WebViewImpl* GetParent() const;
180   bool Lock();
181   void Unlock();
182   bool IsLocked() const;
183   void SetDetached();
184   bool IsDetached() const;
185 
186  private:
187   Status TraverseHistoryWithJavaScript(int delta);
188   Status CallAsyncFunctionInternal(const std::string& frame,
189                                    const std::string& function,
190                                    const base::ListValue& args,
191                                    bool is_user_supplied,
192                                    const base::TimeDelta& timeout,
193                                    std::unique_ptr<base::Value>* result);
194   Status IsNotPendingNavigation(const std::string& frame_id,
195                                 const Timeout* timeout,
196                                 bool* is_not_pending);
197 
198   Status InitProfileInternal();
199   Status StopProfileInternal();
200   Status DispatchTouchEventsForMouseEvents(
201       const std::vector<MouseEvent>& events,
202       const std::string& frame);
203 
204   std::string id_;
205   bool w3c_compliant_;
206   const BrowserInfo* browser_info_;
207   // Data for WebViewImplHolder to support delayed destruction of WebViewImpl.
208   bool is_locked_;
209   bool is_detached_;
210   const WebViewImpl* parent_;
211   // Many trackers hold pointers to DevToolsClient, so client_ must be declared
212   // before the trackers, to ensured trackers are destructed before client_.
213   std::unique_ptr<DevToolsClient> client_;
214   std::unique_ptr<DomTracker> dom_tracker_;
215   std::unique_ptr<FrameTracker> frame_tracker_;
216   std::unique_ptr<JavaScriptDialogManager> dialog_manager_;
217   std::unique_ptr<PageLoadStrategy> navigation_tracker_;
218   std::unique_ptr<MobileEmulationOverrideManager>
219       mobile_emulation_override_manager_;
220   std::unique_ptr<GeolocationOverrideManager> geolocation_override_manager_;
221   std::unique_ptr<NetworkConditionsOverrideManager>
222       network_conditions_override_manager_;
223   std::unique_ptr<DownloadDirectoryOverrideManager>
224       download_directory_override_manager_;
225   std::unique_ptr<HeapSnapshotTaker> heap_snapshot_taker_;
226   std::unique_ptr<CastTracker> cast_tracker_;
227 };
228 
229 // Responsible for locking a WebViewImpl and its associated data structure to
230 // prevent them from being freed which they are still in use.
231 class WebViewImplHolder {
232  public:
233   explicit WebViewImplHolder(WebViewImpl* web_view);
234   ~WebViewImplHolder();
235 
236  private:
237   struct Item {
238     WebViewImpl* web_view;
239     bool was_locked;
240   };
241   std::vector<Item> items_;
242 
243   DISALLOW_COPY_AND_ASSIGN(WebViewImplHolder);
244 };
245 
246 namespace internal {
247 
248 enum EvaluateScriptReturnType {
249   ReturnByValue,
250   ReturnByObject
251 };
252 Status EvaluateScript(DevToolsClient* client,
253                       int context_id,
254                       const std::string& expression,
255                       EvaluateScriptReturnType return_type,
256                       const base::TimeDelta& timeout,
257                       const bool awaitPromise,
258                       std::unique_ptr<base::DictionaryValue>* result);
259 Status EvaluateScriptAndGetObject(DevToolsClient* client,
260                                   int context_id,
261                                   const std::string& expression,
262                                   const base::TimeDelta& timeout,
263                                   const bool awaitPromise,
264                                   bool* got_object,
265                                   std::string* object_id);
266 Status EvaluateScriptAndGetValue(DevToolsClient* client,
267                                  int context_id,
268                                  const std::string& expression,
269                                  const base::TimeDelta& timeout,
270                                  const bool awaitPromise,
271                                  std::unique_ptr<base::Value>* result);
272 Status ParseCallFunctionResult(const base::Value& temp_result,
273                                std::unique_ptr<base::Value>* result);
274 Status GetNodeIdFromFunction(DevToolsClient* client,
275                              int context_id,
276                              const std::string& function,
277                              const base::ListValue& args,
278                              bool* found_node,
279                              int* node_id,
280                              bool w3c_compliant);
281 }  // namespace internal
282 
283 #endif  // CHROME_TEST_CHROMEDRIVER_CHROME_WEB_VIEW_IMPL_H_
284