Web Inspector: only allow evaluateForTestInFrontend for front-ends under test.
[WebKit-https.git] / Source / WebCore / inspector / InspectorFrontendClientLocal.cpp
1 /*
2  * Copyright (C) 2010 Google 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 are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32
33 #if ENABLE(INSPECTOR)
34
35 #include "InspectorFrontendClientLocal.h"
36
37 #include "Chrome.h"
38 #include "Document.h"
39 #include "FloatRect.h"
40 #include "Frame.h"
41 #include "FrameLoadRequest.h"
42 #include "FrameLoader.h"
43 #include "FrameView.h"
44 #include "InspectorBackendDispatcher.h"
45 #include "InspectorController.h"
46 #include "InspectorFrontendHost.h"
47 #include "InspectorPageAgent.h"
48 #include "Page.h"
49 #include "ScriptFunctionCall.h"
50 #include "ScriptObject.h"
51 #include "ScriptState.h"
52 #include "Settings.h"
53 #include "Timer.h"
54 #include "UserGestureIndicator.h"
55 #include "WindowFeatures.h"
56 #include <wtf/Deque.h>
57 #include <wtf/text/CString.h>
58 #include <wtf/text/WTFString.h>
59
60 namespace WebCore {
61
62 static const char* inspectorAttachedHeightSetting = "inspectorAttachedHeight";
63 static const unsigned defaultAttachedHeight = 300;
64 static const float minimumAttachedHeight = 250.0f;
65 static const float maximumAttachedHeightRatio = 0.75f;
66
67 class InspectorBackendDispatchTask {
68     WTF_MAKE_FAST_ALLOCATED;
69 public:
70     InspectorBackendDispatchTask(InspectorController* inspectorController)
71         : m_inspectorController(inspectorController)
72         , m_timer(this, &InspectorBackendDispatchTask::onTimer)
73     {
74     }
75
76     void dispatch(const String& message)
77     {
78         m_messages.append(message);
79         if (!m_timer.isActive())
80             m_timer.startOneShot(0);
81     }
82
83     void reset()
84     {
85         m_messages.clear();
86         m_timer.stop();
87     }
88
89     void onTimer(Timer<InspectorBackendDispatchTask>*)
90     {
91         if (!m_messages.isEmpty()) {
92             // Dispatch can lead to the timer destruction -> schedule the next shot first.
93             m_timer.startOneShot(0);
94             m_inspectorController->dispatchMessageFromFrontend(m_messages.takeFirst());
95         }
96     }
97
98 private:
99     InspectorController* m_inspectorController;
100     Timer<InspectorBackendDispatchTask> m_timer;
101     Deque<String> m_messages;
102 };
103
104 String InspectorFrontendClientLocal::Settings::getProperty(const String&)
105 {
106     return String();
107 }
108
109 void InspectorFrontendClientLocal::Settings::setProperty(const String&, const String&)
110 {
111 }
112
113 InspectorFrontendClientLocal::InspectorFrontendClientLocal(InspectorController* inspectorController, Page* frontendPage, PassOwnPtr<Settings> settings)
114     : m_inspectorController(inspectorController)
115     , m_frontendPage(frontendPage)
116     , m_settings(settings)
117     , m_frontendLoaded(false)
118 {
119     m_frontendPage->settings()->setAllowFileAccessFromFileURLs(true);
120     m_dispatchTask = adoptPtr(new InspectorBackendDispatchTask(inspectorController));
121 }
122
123 InspectorFrontendClientLocal::~InspectorFrontendClientLocal()
124 {
125     if (m_frontendHost)
126         m_frontendHost->disconnectClient();
127     m_frontendPage = 0;
128     m_inspectorController = 0;
129 }
130
131 void InspectorFrontendClientLocal::windowObjectCleared()
132 {
133     if (m_frontendHost)
134         m_frontendHost->disconnectClient();
135     
136     ScriptState* frontendScriptState = scriptStateFromPage(debuggerWorld(), m_frontendPage);
137     m_frontendHost = InspectorFrontendHost::create(this, m_frontendPage);
138     ScriptGlobalObject::set(frontendScriptState, "InspectorFrontendHost", m_frontendHost.get());
139 }
140
141 void InspectorFrontendClientLocal::frontendLoaded()
142 {
143     // Call setDockingUnavailable before bringToFront. If we display the inspector window via bringToFront first it causes the call to canAttachWindow to return the wrong result on Windows.
144     // Calling bringToFront first causes the visibleHeight of the inspected page to always return 0 immediately after. 
145     // Thus if we call canAttachWindow first we can avoid this problem. This change does not cause any regressions on Mac.
146     setDockingUnavailable(!canAttachWindow());
147     bringToFront();
148     m_frontendLoaded = true;
149     for (Vector<String>::iterator it = m_evaluateOnLoad.begin(); it != m_evaluateOnLoad.end(); ++it)
150         evaluateOnLoad(*it);
151     m_evaluateOnLoad.clear();
152 }
153
154 void InspectorFrontendClientLocal::requestSetDockSide(DockSide dockSide)
155 {
156     if (dockSide == UNDOCKED) {
157         detachWindow();
158         setAttachedWindow(false);
159     } else if (canAttachWindow()) {
160         attachWindow();
161         setAttachedWindow(true);
162     }
163 }
164
165 bool InspectorFrontendClientLocal::canAttachWindow()
166 {
167     // Don't allow the attach if the window would be too small to accommodate the minimum inspector height.
168     // Also don't allow attaching to another inspector -- two inspectors in one window is too much!
169     bool isInspectorPage = m_inspectorController->hasInspectorFrontendClient();
170     unsigned inspectedPageHeight = m_inspectorController->inspectedPage()->mainFrame()->view()->visibleHeight();
171     unsigned maximumAttachedHeight = inspectedPageHeight * maximumAttachedHeightRatio;
172     return minimumAttachedHeight <= maximumAttachedHeight && !isInspectorPage;
173 }
174
175 void InspectorFrontendClientLocal::setDockingUnavailable(bool unavailable)
176 {
177     evaluateOnLoad(String::format("[\"setDockingUnavailable\", %s]", unavailable ? "true" : "false"));
178 }
179
180 void InspectorFrontendClientLocal::changeAttachedWindowHeight(unsigned height)
181 {
182     unsigned totalHeight = m_frontendPage->mainFrame()->view()->visibleHeight() + m_inspectorController->inspectedPage()->mainFrame()->view()->visibleHeight();
183     unsigned attachedHeight = constrainedAttachedWindowHeight(height, totalHeight);
184     m_settings->setProperty(inspectorAttachedHeightSetting, String::number(attachedHeight));
185     setAttachedWindowHeight(attachedHeight);
186 }
187
188 void InspectorFrontendClientLocal::openInNewTab(const String& url)
189 {
190     UserGestureIndicator indicator(DefinitelyProcessingUserGesture);
191     Page* page = m_inspectorController->inspectedPage();
192     Frame* mainFrame = page->mainFrame();
193     FrameLoadRequest request(mainFrame->document()->securityOrigin(), ResourceRequest(), "_blank");
194
195     bool created;
196     WindowFeatures windowFeatures;
197     Frame* frame = WebCore::createWindow(mainFrame, mainFrame, request, windowFeatures, created);
198     if (!frame)
199         return;
200
201     frame->loader()->setOpener(mainFrame);
202     frame->page()->setOpenedByDOM();
203
204     // FIXME: Why does one use mainFrame and the other frame?
205     frame->loader()->changeLocation(mainFrame->document()->securityOrigin(), frame->document()->completeURL(url), "", false, false);
206 }
207
208 void InspectorFrontendClientLocal::moveWindowBy(float x, float y)
209 {
210     FloatRect frameRect = m_frontendPage->chrome()->windowRect();
211     frameRect.move(x, y);
212     m_frontendPage->chrome()->setWindowRect(frameRect);
213 }
214
215 void InspectorFrontendClientLocal::setAttachedWindow(bool attached)
216 {
217     evaluateOnLoad(String::format("[\"setDockSide\", \"%s\"]", attached ? "bottom" : "undocked"));
218 }
219
220 void InspectorFrontendClientLocal::restoreAttachedWindowHeight()
221 {
222     unsigned inspectedPageHeight = m_inspectorController->inspectedPage()->mainFrame()->view()->visibleHeight();
223     String value = m_settings->getProperty(inspectorAttachedHeightSetting);
224     unsigned preferredHeight = value.isEmpty() ? defaultAttachedHeight : value.toUInt();
225     
226     // This call might not go through (if the window starts out detached), but if the window is initially created attached,
227     // InspectorController::attachWindow is never called, so we need to make sure to set the attachedWindowHeight.
228     // FIXME: Clean up code so we only have to call setAttachedWindowHeight in InspectorController::attachWindow
229     setAttachedWindowHeight(constrainedAttachedWindowHeight(preferredHeight, inspectedPageHeight));
230 }
231
232 bool InspectorFrontendClientLocal::isDebuggingEnabled()
233 {
234     if (m_frontendLoaded)
235         return evaluateAsBoolean("[\"isDebuggingEnabled\"]");
236     return false;
237 }
238
239 void InspectorFrontendClientLocal::setDebuggingEnabled(bool enabled)
240 {
241     evaluateOnLoad(String::format("[\"setDebuggingEnabled\", %s]", enabled ? "true" : "false"));
242 }
243
244 bool InspectorFrontendClientLocal::isTimelineProfilingEnabled()
245 {
246     if (m_frontendLoaded)
247         return evaluateAsBoolean("[\"isTimelineProfilingEnabled\"]");
248     return false;
249 }
250
251 void InspectorFrontendClientLocal::setTimelineProfilingEnabled(bool enabled)
252 {
253     evaluateOnLoad(String::format("[\"setTimelineProfilingEnabled\", %s]", enabled ? "true" : "false"));
254 }
255
256 bool InspectorFrontendClientLocal::isProfilingJavaScript()
257 {
258     if (m_frontendLoaded)
259         return evaluateAsBoolean("[\"isProfilingJavaScript\"]");
260     return false;
261 }
262
263 void InspectorFrontendClientLocal::startProfilingJavaScript()
264 {
265     evaluateOnLoad("[\"startProfilingJavaScript\"]");
266 }
267
268 void InspectorFrontendClientLocal::stopProfilingJavaScript()
269 {
270     evaluateOnLoad("[\"stopProfilingJavaScript\"]");
271 }
272
273 void InspectorFrontendClientLocal::showConsole()
274 {
275     evaluateOnLoad("[\"showConsole\"]");
276 }
277
278 void InspectorFrontendClientLocal::showResources()
279 {
280     evaluateOnLoad("[\"showResources\"]");
281 }
282
283 void InspectorFrontendClientLocal::showMainResourceForFrame(Frame* frame)
284 {
285     String frameId = m_inspectorController->pageAgent()->frameId(frame);
286     evaluateOnLoad(String::format("[\"showMainResourceForFrame\", \"%s\"]", frameId.ascii().data()));
287 }
288
289 unsigned InspectorFrontendClientLocal::constrainedAttachedWindowHeight(unsigned preferredHeight, unsigned totalWindowHeight)
290 {
291     using namespace std;
292     return roundf(max(minimumAttachedHeight, min<float>(preferredHeight, totalWindowHeight * maximumAttachedHeightRatio)));
293 }
294
295 void InspectorFrontendClientLocal::sendMessageToBackend(const String& message)
296 {
297     m_dispatchTask->dispatch(message);
298 }
299
300 bool InspectorFrontendClientLocal::isUnderTest()
301 {
302     return m_inspectorController->isUnderTest();
303 }
304
305 bool InspectorFrontendClientLocal::evaluateAsBoolean(const String& expression)
306 {
307     if (!m_frontendPage->mainFrame())
308         return false;
309     ScriptValue value = m_frontendPage->mainFrame()->script()->executeScript(expression);
310     return value.toString(mainWorldScriptState(m_frontendPage->mainFrame())) == "true";
311 }
312
313 void InspectorFrontendClientLocal::evaluateOnLoad(const String& expression)
314 {
315     if (m_frontendLoaded)
316         m_frontendPage->mainFrame()->script()->executeScript("InspectorFrontendAPI.dispatch(" + expression + ")");
317     else
318         m_evaluateOnLoad.append(expression);
319 }
320
321 } // namespace WebCore
322
323 #endif