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 "DOMWrapperWorld.h"
  39 #include "Document.h"
  40 #include "FloatRect.h"
  41 #include "Frame.h"
  42 #include "FrameLoadRequest.h"
  43 #include "FrameLoader.h"
  44 #include "FrameView.h"
  45 #include "InspectorBackendDispatcher.h"
  46 #include "InspectorController.h"
  47 #include "InspectorFrontendHost.h"
  48 #include "InspectorPageAgent.h"
  49 #include "Page.h"
  50 #include "ScriptController.h"
  51 #include "ScriptFunctionCall.h"
  52 #include "ScriptObject.h"
  53 #include "ScriptState.h"
  54 #include "Settings.h"
  55 #include "Timer.h"
  56 #include "UserGestureIndicator.h"
  57 #include "WindowFeatures.h"
  58 #include <wtf/Deque.h>
  59 #include <wtf/text/CString.h>
  60 #include <wtf/text/WTFString.h>
  61
  62 namespace WebCore {
  63
  64 static const char* inspectorAttachedHeightSetting = "inspectorAttachedHeight";
  65 static const unsigned defaultAttachedHeight = 300;
  66 static const float minimumAttachedHeight = 250.0f;
  67 static const float maximumAttachedHeightRatio = 0.75f;
  68 static const float minimumAttachedWidth = 750.0f;
  69 static const float minimumAttachedInspectedWidth = 320.0f;
  70
  71 class InspectorBackendDispatchTask {
  72     WTF_MAKE_FAST_ALLOCATED;
  73 public:
  74     InspectorBackendDispatchTask(InspectorController* inspectorController)
  75         : m_inspectorController(inspectorController)
  76         , m_timer(this, &InspectorBackendDispatchTask::onTimer)
  77     {
  78     }
  79
  80     void dispatch(const String& message)
  81     {
  82         m_messages.append(message);
  83         if (!m_timer.isActive())
  84             m_timer.startOneShot(0);
  85     }
  86
  87     void reset()
  88     {
  89         m_messages.clear();
  90         m_timer.stop();
  91     }
  92
  93     void onTimer(Timer<InspectorBackendDispatchTask>*)
  94     {
  95         if (!m_messages.isEmpty()) {
  96             // Dispatch can lead to the timer destruction -> schedule the next shot first.
  97             m_timer.startOneShot(0);
  98             m_inspectorController->dispatchMessageFromFrontend(m_messages.takeFirst());
  99         }
 100     }
 101
 102 private:
 103     InspectorController* m_inspectorController;
 104     Timer<InspectorBackendDispatchTask> m_timer;
 105     Deque<String> m_messages;
 106 };
 107
 108 String InspectorFrontendClientLocal::Settings::getProperty(const String&)
 109 {
 110     return String();
 111 }
 112
 113 void InspectorFrontendClientLocal::Settings::setProperty(const String&, const String&)
 114 {
 115 }
 116
 117 InspectorFrontendClientLocal::InspectorFrontendClientLocal(InspectorController* inspectorController, Page* frontendPage, PassOwnPtr<Settings> settings)
 118     : m_inspectorController(inspectorController)
 119     , m_frontendPage(frontendPage)
 120     , m_settings(settings)
 121     , m_frontendLoaded(false)
 122     , m_dockSide(UNDOCKED)
 123 {
 124     m_frontendPage->settings()->setAllowFileAccessFromFileURLs(true);
 125     m_dispatchTask = adoptPtr(new InspectorBackendDispatchTask(inspectorController));
 126 }
 127
 128 InspectorFrontendClientLocal::~InspectorFrontendClientLocal()
 129 {
 130     if (m_frontendHost)
 131         m_frontendHost->disconnectClient();
 132     m_frontendPage = 0;
 133     m_inspectorController = 0;
 134 }
 135
 136 void InspectorFrontendClientLocal::windowObjectCleared()
 137 {
 138     if (m_frontendHost)
 139         m_frontendHost->disconnectClient();
 140
 141     ScriptState* frontendScriptState = scriptStateFromPage(debuggerWorld(), m_frontendPage);
 142     m_frontendHost = InspectorFrontendHost::create(this, m_frontendPage);
 143     ScriptGlobalObject::set(frontendScriptState, "InspectorFrontendHost", m_frontendHost.get());
 144 }
 145
 146 void InspectorFrontendClientLocal::frontendLoaded()
 147 {
 148     // Call setDockingUnavailable before bringToFront. If we display the inspector window via bringToFront first it causes
 149     // the call to canAttachWindow to return the wrong result on Windows.
 150     // Calling bringToFront first causes the visibleHeight of the inspected page to always return 0 immediately after.
 151     // Thus if we call canAttachWindow first we can avoid this problem. This change does not cause any regressions on Mac.
 152     setDockingUnavailable(!canAttachWindow());
 153     bringToFront();
 154     m_frontendLoaded = true;
 155     for (Vector<String>::iterator it = m_evaluateOnLoad.begin(); it != m_evaluateOnLoad.end(); ++it)
 156         evaluateOnLoad(*it);
 157     m_evaluateOnLoad.clear();
 158 }
 159
 160 void InspectorFrontendClientLocal::requestSetDockSide(DockSide dockSide)
 161 {
 162     if (dockSide == UNDOCKED) {
 163         detachWindow();
 164         setAttachedWindow(dockSide);
 165     } else if (canAttachWindow()) {
 166         attachWindow(dockSide);
 167         setAttachedWindow(dockSide);
 168     }
 169 }
 170
 171 bool InspectorFrontendClientLocal::canAttachWindow()
 172 {
 173     // Don't allow attaching to another inspector -- two inspectors in one window is too much!
 174     bool isInspectorPage = m_inspectorController->hasInspectorFrontendClient();
 175     if (isInspectorPage)
 176         return false;
 177
 178     // If we are already attached, allow attaching again to allow switching sides.
 179     if (m_dockSide != UNDOCKED)
 180         return true;
 181
 182     // Don't allow the attach if the window would be too small to accommodate the minimum inspector size.
 183     unsigned inspectedPageHeight = m_inspectorController->inspectedPage()->mainFrame()->view()->visibleHeight();
 184     unsigned inspectedPageWidth = m_inspectorController->inspectedPage()->mainFrame()->view()->visibleWidth();
 185     unsigned maximumAttachedHeight = inspectedPageHeight * maximumAttachedHeightRatio;
 186     return minimumAttachedHeight <= maximumAttachedHeight && minimumAttachedWidth <= inspectedPageWidth;
 187 }
 188
 189 void InspectorFrontendClientLocal::setDockingUnavailable(bool unavailable)
 190 {
 191     evaluateOnLoad(String::format("[\"setDockingUnavailable\", %s]", unavailable ? "true" : "false"));
 192 }
 193
 194 void InspectorFrontendClientLocal::changeAttachedWindowHeight(unsigned height)
 195 {
 196     unsigned totalHeight = m_frontendPage->mainFrame()->view()->visibleHeight() + m_inspectorController->inspectedPage()->mainFrame()->view()->visibleHeight();
 197     unsigned attachedHeight = constrainedAttachedWindowHeight(height, totalHeight);
 198     m_settings->setProperty(inspectorAttachedHeightSetting, String::number(attachedHeight));
 199     setAttachedWindowHeight(attachedHeight);
 200 }
 201
 202 void InspectorFrontendClientLocal::changeAttachedWindowWidth(unsigned width)
 203 {
 204     unsigned totalWidth = m_frontendPage->mainFrame()->view()->visibleWidth() + m_inspectorController->inspectedPage()->mainFrame()->view()->visibleWidth();
 205     unsigned attachedWidth = constrainedAttachedWindowWidth(width, totalWidth);
 206     setAttachedWindowWidth(attachedWidth);
 207 }
 208
 209 void InspectorFrontendClientLocal::openInNewTab(const String& url)
 210 {
 211     UserGestureIndicator indicator(DefinitelyProcessingNewUserGesture);
 212     Page* page = m_inspectorController->inspectedPage();
 213     Frame* mainFrame = page->mainFrame();
 214     FrameLoadRequest request(mainFrame->document()->securityOrigin(), ResourceRequest(), "_blank");
 215
 216     bool created;
 217     WindowFeatures windowFeatures;
 218     RefPtr<Frame> frame = WebCore::createWindow(mainFrame, mainFrame, request, windowFeatures, created);
 219     if (!frame)
 220         return;
 221
 222     frame->loader()->setOpener(mainFrame);
 223     frame->page()->setOpenedByDOM();
 224
 225     // FIXME: Why does one use mainFrame and the other frame?
 226     frame->loader()->changeLocation(mainFrame->document()->securityOrigin(), frame->document()->completeURL(url), "", false, false);
 227 }
 228
 229 void InspectorFrontendClientLocal::moveWindowBy(float x, float y)
 230 {
 231     FloatRect frameRect = m_frontendPage->chrome().windowRect();
 232     frameRect.move(x, y);
 233     m_frontendPage->chrome().setWindowRect(frameRect);
 234 }
 235
 236 void InspectorFrontendClientLocal::setAttachedWindow(DockSide dockSide)
 237 {
 238     const char* side = "undocked";
 239     switch (dockSide) {
 240     case UNDOCKED:
 241         side = "undocked";
 242         break;
 243     case DOCKED_TO_RIGHT:
 244         side = "right";
 245         break;
 246     case DOCKED_TO_BOTTOM:
 247         side = "bottom";
 248         break;
 249     }
 250
 251     m_dockSide = dockSide;
 252
 253     evaluateOnLoad(String::format("[\"setDockSide\", \"%s\"]", side));
 254 }
 255
 256 void InspectorFrontendClientLocal::restoreAttachedWindowHeight()
 257 {
 258     unsigned inspectedPageHeight = m_inspectorController->inspectedPage()->mainFrame()->view()->visibleHeight();
 259     String value = m_settings->getProperty(inspectorAttachedHeightSetting);
 260     unsigned preferredHeight = value.isEmpty() ? defaultAttachedHeight : value.toUInt();
 261
 262     // This call might not go through (if the window starts out detached), but if the window is initially created attached,
 263     // InspectorController::attachWindow is never called, so we need to make sure to set the attachedWindowHeight.
 264     // FIXME: Clean up code so we only have to call setAttachedWindowHeight in InspectorController::attachWindow
 265     setAttachedWindowHeight(constrainedAttachedWindowHeight(preferredHeight, inspectedPageHeight));
 266 }
 267
 268 bool InspectorFrontendClientLocal::isDebuggingEnabled()
 269 {
 270     if (m_frontendLoaded)
 271         return evaluateAsBoolean("[\"isDebuggingEnabled\"]");
 272     return false;
 273 }
 274
 275 void InspectorFrontendClientLocal::setDebuggingEnabled(bool enabled)
 276 {
 277     evaluateOnLoad(String::format("[\"setDebuggingEnabled\", %s]", enabled ? "true" : "false"));
 278 }
 279
 280 bool InspectorFrontendClientLocal::isTimelineProfilingEnabled()
 281 {
 282     if (m_frontendLoaded)
 283         return evaluateAsBoolean("[\"isTimelineProfilingEnabled\"]");
 284     return false;
 285 }
 286
 287 void InspectorFrontendClientLocal::setTimelineProfilingEnabled(bool enabled)
 288 {
 289     evaluateOnLoad(String::format("[\"setTimelineProfilingEnabled\", %s]", enabled ? "true" : "false"));
 290 }
 291
 292 bool InspectorFrontendClientLocal::isProfilingJavaScript()
 293 {
 294     if (m_frontendLoaded)
 295         return evaluateAsBoolean("[\"isProfilingJavaScript\"]");
 296     return false;
 297 }
 298
 299 void InspectorFrontendClientLocal::startProfilingJavaScript()
 300 {
 301     evaluateOnLoad("[\"startProfilingJavaScript\"]");
 302 }
 303
 304 void InspectorFrontendClientLocal::stopProfilingJavaScript()
 305 {
 306     evaluateOnLoad("[\"stopProfilingJavaScript\"]");
 307 }
 308
 309 void InspectorFrontendClientLocal::showConsole()
 310 {
 311     evaluateOnLoad("[\"showConsole\"]");
 312 }
 313
 314 void InspectorFrontendClientLocal::showResources()
 315 {
 316     evaluateOnLoad("[\"showResources\"]");
 317 }
 318
 319 void InspectorFrontendClientLocal::showMainResourceForFrame(Frame* frame)
 320 {
 321     String frameId = m_inspectorController->pageAgent()->frameId(frame);
 322     evaluateOnLoad(String::format("[\"showMainResourceForFrame\", \"%s\"]", frameId.ascii().data()));
 323 }
 324
 325 unsigned InspectorFrontendClientLocal::constrainedAttachedWindowHeight(unsigned preferredHeight, unsigned totalWindowHeight)
 326 {
 327     return roundf(std::max(minimumAttachedHeight, std::min<float>(preferredHeight, totalWindowHeight * maximumAttachedHeightRatio)));
 328 }
 329
 330 unsigned InspectorFrontendClientLocal::constrainedAttachedWindowWidth(unsigned preferredWidth, unsigned totalWindowWidth)
 331 {
 332     return roundf(std::max(minimumAttachedWidth, std::min<float>(preferredWidth, totalWindowWidth - minimumAttachedInspectedWidth)));
 333 }
 334
 335 void InspectorFrontendClientLocal::sendMessageToBackend(const String& message)
 336 {
 337     m_dispatchTask->dispatch(message);
 338 }
 339
 340 bool InspectorFrontendClientLocal::isUnderTest()
 341 {
 342     return m_inspectorController->isUnderTest();
 343 }
 344
 345 bool InspectorFrontendClientLocal::evaluateAsBoolean(const String& expression)
 346 {
 347     if (!m_frontendPage->mainFrame())
 348         return false;
 349     ScriptValue value = m_frontendPage->mainFrame()->script()->executeScript(expression);
 350     return value.toString(mainWorldScriptState(m_frontendPage->mainFrame())) == "true";
 351 }
 352
 353 void InspectorFrontendClientLocal::evaluateOnLoad(const String& expression)
 354 {
 355     if (m_frontendLoaded)
 356         m_frontendPage->mainFrame()->script()->executeScript("InspectorFrontendAPI.dispatch(" + expression + ")");
 357     else
 358         m_evaluateOnLoad.append(expression);
 359 }
 360
 361 } // namespace WebCore
 362
 363 #endif