Web Inspector: Keep Web Inspector window alive across process swaps (PSON) (Remote...
authorjoepeck@webkit.org <joepeck@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 14 Nov 2018 21:03:49 +0000 (21:03 +0000)
committerjoepeck@webkit.org <joepeck@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 14 Nov 2018 21:03:49 +0000 (21:03 +0000)
commit9442478d2a930913bbf3d06a550d6016a521fc8d
treee46120be945114351d0ff98febc8ece9135b6e22
parent779a9b1ef79dfacbc9ea709552586c1697a56c11
Web Inspector: Keep Web Inspector window alive across process swaps (PSON) (Remote Inspector)
https://bugs.webkit.org/show_bug.cgi?id=191494
<rdar://problem/45469854>

Reviewed by Devin Rousso.

Source/JavaScriptCore:

* CMakeLists.txt:
* DerivedSources.make:
* JavaScriptCore.xcodeproj/project.pbxproj:
* Sources.txt:
New domain and resources.

* inspector/protocol/Target.json: Added.
New protocol domain, modeled after Worker.json, to allow for
multiplexing between different targets.

* inspector/InspectorTarget.h:
Each target will instantiate an InspectorTarget and must
provide an identifier, type, and means of connecting/disconnecting
to a frontend channel.

* inspector/agents/InspectorTargetAgent.cpp: Added.
(Inspector::InspectorTargetAgent::InspectorTargetAgent):
(Inspector::InspectorTargetAgent::didCreateFrontendAndBackend):
(Inspector::InspectorTargetAgent::willDestroyFrontendAndBackend):
(Inspector::InspectorTargetAgent::exists):
(Inspector::InspectorTargetAgent::initialized):
(Inspector::InspectorTargetAgent::sendMessageToTarget):
(Inspector::InspectorTargetAgent::sendMessageFromTargetToFrontend):
(Inspector::targetTypeToProtocolType):
(Inspector::buildTargetInfoObject):
(Inspector::InspectorTargetAgent::targetCreated):
(Inspector::InspectorTargetAgent::targetTerminated):
(Inspector::InspectorTargetAgent::connectToTargets):
(Inspector::InspectorTargetAgent::disconnectFromTargets):
* inspector/agents/InspectorTargetAgent.h: Added.
TargetAgent holds a list of targets, and connects/disconnects to each
of the targets when a frontend connects/disconnects.

* inspector/scripts/codegen/generator.py:
Better enum casing of ServiceWorker.

Source/WebCore:

* inspector/InspectorClient.h:
(WebCore::InspectorClient::allowRemoteInspectionToPageDirectly const):
Provide a hook so that a client may wish to allow direct remote inspection of the Page.
This is used by WebKitLegacy only.

* page/Page.cpp:
(Page::Page):
Only enable the PageDebuggable if the client wishes remote inspection of the Page directly.
This is used by WebKitLegacy only.

* inspector/InspectorController.cpp:
(WebCore::InspectorController::connectFrontend):
* inspector/InspectorController.h:
* page/PageDebuggable.cpp:
(WebCore::PageDebuggable::connect):
(WebCore::PageDebuggable::disconnect):
* page/PageDebuggable.h:
When a frontend connects, always enable the developer extras for the Page.
This is pretty much only for the remote path, which allows inspection if developer
extras were not already enabled (iOS). This simplifies the logic, and toggling
developer extras after it was already enabled is not really important.

Source/WebInspectorUI:

This starts introducing multi-target support into the Web Inspector frontend.
Specifically a backend connection that is persistent, but has the ability to
connect to and transition between Page targets received through that backend
connection.

This patch introduces the concept of a "Backend Target" which is the single
connection that the frontend contains to a backend. The old way of connecting
directly to a target is still supported. In that case the frontend constructs
a DirectBackendTarget for the debuggable type the frontend was spawns for.
However, if the frontend opens and has a TargetAgent, then it is likely
connected to a multi-target supporting backend and instead constructs a
MultiplexingBackendTarget, and will receive further information about
sub-targets to connect to. The only sub-target at the moment is a Page
sub-target.

As part of bringing up multi-target support this adds a few measures to
handle situations where the frontend is playing fast and loose with agents.
When the frontend does `FooAgent.method` it intends that to be performed
on the "main" target being debugged. Likewise when the frontend loops
over targets it expects them to be the debuggable targets. This patch
profiles a new implementation of `WI.mainTarget` and `WI.targets` to
match the assumptions being made by the frontend.

  - In a direct-target world, there is a single target which
    should be used for global agents and in WI.targets.

  - In a multi-target world, the page target is the one that
    should be used for global agents and WI.targets is the list
    of sub-targets (excluding the MultiplexingBackendTarget).

In a multi-target world, there are now commonly two Targets. The
MultiplexingBackendTarget and a PageTarget sub-target. In the future
this may include more targets, such as ServiceWorkers, DedicatedWorkers,
and perhaps even frames.

In a multi-target world, the frontend is immediately told about targets
as soon as it opens (via Target.targetCreated). In order to support
this, frontend initialization happens without a main target being available.
So this makes a few small changes to frontend initialization to perform
a bit of work once we know what the main target is.

During a page transition the frontend is told to destroy existing targets
and is soon after told about any new page targets (via Target.targetDestroyed
and Target.targetCreated). The frontend special cases this page transition.
It expects only one Page target to be alive at any time, accessible through
WI.pageTarget. When a page transition happens the WI.pageTarget changes, and
the frontend performs a bit of work to prepare the UI to handle the transition:
`<Manager>.transitionPageTarget` / WI.Notification.TransitionPageTarget.
For the most part the UI behaves fine as long once there are main frame
change and main resource change events, but those other events allow
the frontend to respond to the specific page transition cases.

* UserInterface/Base/Main.js:
(WI.loaded):
(WI.initializeBackendTarget):
(WI.initializePageTarget):
(WI.transitionPageTarget):
(WI.terminatePageTarget):
(WI.resetMainExecutionContext):
(WI.redirectGlobalAgentsToConnection):
(WI.contentLoaded):
New global functions for target initialization
and page transitioning.

* UserInterface/Test/Test.js:
(WI.loaded):
(WI.initializeBackendTarget):
(WI.initializePageTarget):
(WI.transitionPageTarget):
(WI.terminatePageTarget):
(WI.resetMainExecutionContext):
(WI.redirectGlobalAgentsToConnection):
New global functions for target initialization.
Tests continue to be a direct connection to the Page.

* UserInterface/Protocol/TargetObserver.js:
(WI.TargetObserver.prototype.targetCreated):
(WI.TargetObserver.prototype.targetDestroyed):
(WI.TargetObserver.prototype.dispatchMessageFromTarget):
New observer goes to the manager.

* UserInterface/Controllers/TargetManager.js:
(WI.TargetManager):
(WI.TargetManager.prototype.get targets):
(WI.TargetManager.prototype.get allTargets):
(WI.TargetManager.prototype.targetForIdentifier):
(WI.TargetManager.prototype.targetCreated):
(WI.TargetManager.prototype.targetDestroyed):
(WI.TargetManager.prototype.dispatchMessageFromTarget):
(WI.TargetManager.prototype.createMultiplexingBackendTarget):
(WI.TargetManager.prototype.createDirectBackendTarget):
(WI.TargetManager.prototype._addTarget):
(WI.TargetManager.prototype._removeTarget):
(WI.TargetManager.prototype._createTarget):
(WI.TargetManager.prototype._checkAndHandlePageTargetTransition):
(WI.TargetManager.prototype._checkAndHandlePageTargetTermination):
(WI.TargetManager.prototype.addTarget): Deleted.
(WI.TargetManager.prototype.removeTarget): Deleted.
(WI.TargetManager.prototype.initializeMainTarget): Deleted.
TargetManager is where we handle creating and destroying targets
and their connections. In order to simplify things a bit we make
`WI.targets`, which goes through `get targets()` an array instead
of a Set. And this includes only the sub-targets.

* UserInterface/Controllers/WorkerManager.js:
(WI.WorkerManager.prototype.workerCreated):
(WI.WorkerManager.prototype.workerTerminated):
Workers are still special-target-like things that multiplex through
WorkerAgent instead of TargetAgent. We'd like to promote these to
be full targets in the future.

* UserInterface/Protocol/DirectBackendTarget.js: Renamed from Source/WebInspectorUI/UserInterface/Protocol/MainTarget.js.
(WI.DirectBackendTarget):
(WI.DirectBackendTarget.connectionInfoForDebuggable):
(WI.DirectBackendTarget.prototype.get mainResource):
(WI.DirectBackendTarget.prototype.set mainResource):
This is the only "MainTarget" class. It is the backend target for a direct connection.

* UserInterface/Protocol/MultiplexingBackendTarget.js:
(WI.MultiplexingBackendTarget):
(WI.MultiplexingBackendTarget.prototype.initialize):
(WI.MultiplexingBackendTarget.prototype.get name):
(WI.MultiplexingBackendTarget.prototype.get executionContext):
(WI.MultiplexingBackendTarget.prototype.get mainResource):
This is the new backend target for a multi-target connection.
We don't expect it to be treated like other targets, so we don't
expect anyone to ask it for resources/executionContext/name info.

* UserInterface/Controllers/RuntimeManager.js:
(WI.TargetManager.prototype.evaluateInInspectedWindow):
This can be triggered by watch expressions before any target, and
therefore execution context, is available. Just return null, when
an execution context is available those clients will try again.

* UserInterface/Debug/Bootstrap.js:
Provide an WI.isEngineeringBuild boolean that can be used for various
debugging features.

* UserInterface/Main.html:
* UserInterface/Test.html:
New resources.

* UserInterface/Protocol/InspectorBackend.js:
(InspectorBackendClass.prototype.dispatch):
(InspectorBackendClass.prototype.runAfterPendingDispatches):
(InspectorBackend.Agent):
`InspectorBackend.mainConnection` was renamed `InspectorBackend.backendConnection`.

* UserInterface/Protocol/Connection.js:
(InspectorBackend.Connection):
(InspectorBackend.Connection.prototype._dispatchResponse):
(InspectorBackend.Connection.prototype._sendCommandToBackendWithCallback):
(InspectorBackend.Connection.prototype._sendCommandToBackendExpectingPromise):
(InspectorBackend.BackendConnection):
(InspectorBackend.BackendConnection.prototype.sendMessageToBackend):
(InspectorBackend.WorkerConnection):
(InspectorBackend.TargetConnection):
(InspectorBackend.TargetConnection.sendMessageToBackend):
Use a global sequence id to make filtering a bit easier in protocol tracing.
TargetConnection is identical to WorkerConnection except it uses TargetAgent
instead of WorkerAgent to perform multiplexing.

* UserInterface/Protocol/JavaScriptContextTarget.js:
(WI.JavaScriptContextTarget):
* UserInterface/Protocol/PageTarget.js:
(WI.PageTarget):
(WI.PageTarget.prototype.get displayName):
Specialized target types.

* UserInterface/Views/DebuggerSidebarPanel.js:
(WI.DebuggerSidebarPanel):
(WI.DebuggerSidebarPanel.prototype._targetAdded):
(WI.DebuggerSidebarPanel.prototype._targetRemoved):
(WI.DebuggerSidebarPanel.prototype._updateCallStackTreeOutline):
* UserInterface/Views/SourceCodeTextEditor.js:
(WI.SourceCodeTextEditor.prototype._targetAdded):
(WI.SourceCodeTextEditor.prototype._targetRemoved):
(WI.SourceCodeTextEditor.prototype._callFramesDidChange):
(WI.SourceCodeTextEditor.prototype._updateThreadIndicatorWidget):
(WI.SourceCodeTextEditor.prototype._reinsertAllThreadIndicators):
* UserInterface/Views/QuickConsole.js:
(WI.QuickConsole.prototype.initializeMainExecutionContextPathComponent):
(WI.QuickConsole.prototype._targetAdded):
(WI.QuickConsole.prototype._targetRemoved):
We make target added get called with all targets, including the
MultiplexingBackendTarget and PageTargets, both of which would
not have happened before. Before it was only WorkerTargets. Make
these sites a little more robust for the type of target they expect
to be able to handle.

* UserInterface/Base/Object.js:
* UserInterface/Controllers/DOMManager.js:
(WI.DOMManager):
(WI.DOMManager.prototype.transitionPageTarget):
(WI.DOMManager.prototype.requestDocument):
(WI.DOMManager.prototype._setDocument):
* UserInterface/Controllers/NetworkManager.js:
(WI.NetworkManager):
(WI.NetworkManager.prototype.transitionPageTarget):
(WI.NetworkManager.prototype.executionContextCreated):
(WI.NetworkManager.prototype._processMainFrameResourceTreePayload):
* UserInterface/Models/DefaultDashboard.js:
(WI.DefaultDashboard):
(WI.DefaultDashboard.prototype._mainResourceDidChange):
(WI.DefaultDashboard.prototype._transitionPageTarget):
* UserInterface/Views/NetworkTableContentView.js:
(WI.NetworkTableContentView):
(WI.NetworkTableContentView.prototype._mainResourceDidChange):
(WI.NetworkTableContentView.prototype._transitionPageTarget):
Special case handling when performing a page transition.

* UserInterface/Views/SettingsTabContentView.js:
* UserInterface/Debug/UncaughtExceptionReporter.js:
Document reloads are not supported right now.

Source/WebKit:

To support process swapping a slim Web Inspector backend lives in the UIProcess.
The Web Inspector frontend connects to it and is told about sub-targets, namely
pages, that it can further connect to. When performing a process swap the backend
tells the frontend to destroy existing targets and create new targets.

In the UIProcess the WebPageProxy has a WebPageInspectorController, with a single
TargetAgent holding InspectorTargetProxies to targets it knows about. Inspector
protocol messages go through this inspector controller and are routed to the
WebPage and its WebCore::Page's InspectorController. The WebPageProxy decides
when to close and expose new page targets during process swap, or basically
any time it reconnects to a WebProcess. So this patch also makes Web Inspector
stay alive and reconnect to a page when the inspected page crashes!

In the WebContentProcess the WebPage has a WebPageInspectorTarget. It also
has a WebPageInspectorTargetController in anticipation of further sub-targets
within the page (workers, frames) but none exist at the moment. The WebPage
relies on the WebPageProxy to know when to expose this target as a debuggable.

* Sources.txt:
* WebKit.xcodeproj/project.pbxproj:
New files.

* Shared/WebPageCreationParameters.cpp:
(WebKit::WebPageCreationParameters::encode const):
(WebKit::WebPageCreationParameters::decode):
* Shared/WebPageCreationParameters.h:
Remote inspector state can now stay in the UIProcess and does not need to
be passed down to the WebContentProcess.

* UIProcess/WebPageDebuggable.cpp: Copied from Source/WebCore/page/PageDebuggable.cpp.
(WebKit::WebPageDebuggable::WebPageDebuggable):
(WebKit::WebPageDebuggable::name const):
(WebKit::WebPageDebuggable::url const):
(WebKit::WebPageDebuggable::hasLocalDebugger const):
(WebKit::WebPageDebuggable::connect):
(WebKit::WebPageDebuggable::disconnect):
(WebKit::WebPageDebuggable::dispatchMessageFromRemote):
(WebKit::WebPageDebuggable::setIndicating):
(WebKit::WebPageDebuggable::setNameOverride):
* UIProcess/WebPageDebuggable.h: Copied from Source/WebCore/page/PageDebuggable.h.
Remote debuggable entry point into the UIProcess for a page.
This is pretty much identical to the PageDebuggable in WebCore.

* Scripts/webkit/messages.py:
* UIProcess/WebPageProxy.messages.in:
* UIProcess/WebPageProxy.cpp:
(WebKit::m_resetRecentCrashCountTimer):
(WebKit::WebPageProxy::finishAttachingToWebProcess):
(WebKit::WebPageProxy::close):
(WebKit::WebPageProxy::createInspectorTarget):
(WebKit::WebPageProxy::destroyInspectorTarget):
(WebKit::WebPageProxy::sendMessageToInspectorFrontend):
(WebKit::WebPageProxy::setIndicating):
(WebKit::WebPageProxy::allowsRemoteInspection const):
(WebKit::WebPageProxy::setAllowsRemoteInspection):
(WebKit::WebPageProxy::remoteInspectionNameOverride const):
(WebKit::WebPageProxy::setRemoteInspectionNameOverride):
(WebKit::WebPageProxy::remoteInspectorInformationDidChange):
(WebKit::WebPageProxy::clearInspectorTargets):
(WebKit::WebPageProxy::createInspectorTargets):
(WebKit::WebPageProxy::didCommitLoadForFrame):
(WebKit::WebPageProxy::didReceiveTitleForFrame):
(WebKit::WebPageProxy::creationParameters):
* UIProcess/WebPageProxy.h:
(WebKit::WebPageProxy::inspectorController):
(WebKit::WebPageProxy::allowsRemoteInspection const): Deleted.
(WebKit::WebPageProxy::remoteInspectionNameOverride const): Deleted.
Own more inspector state in the UIProcess including a debuggable and inspector controller.

* UIProcess/WebPageInspectorController.h: Added.
* UIProcess/WebPageInspectorController.cpp: Added.
(WebKit::WebPageInspectorController::WebPageInspectorController):
(WebKit::WebPageInspectorController::pageClosed):
(WebKit::WebPageInspectorController::hasLocalFrontend const):
(WebKit::WebPageInspectorController::hasRemoteFrontend const):
(WebKit::WebPageInspectorController::connectFrontend):
(WebKit::WebPageInspectorController::disconnectFrontend):
(WebKit::WebPageInspectorController::disconnectAllFrontends):
(WebKit::WebPageInspectorController::dispatchMessageFromFrontend):
(WebKit::WebPageInspectorController::setIndicating):
(WebKit::WebPageInspectorController::clearTargets):
(WebKit::WebPageInspectorController::createInspectorTarget):
(WebKit::WebPageInspectorController::destroyInspectorTarget):
(WebKit::WebPageInspectorController::sendMessageToInspectorFrontend):
InspectorController with a single TargetAgent in the UIProcess.

* UIProcess/WebPageInspectorTargetAgent.h:
* UIProcess/WebPageInspectorTargetAgent.cpp:
(WebKit::WebPageInspectorTargetAgent::WebPageInspectorTargetAgent):
(WebKit::WebPageInspectorTargetAgent::frontendChannel):
Target agent implementation.

* UIProcess/InspectorTargetProxy.cpp:
(WebKit::InspectorTargetProxy::create):
(WebKit::InspectorTargetProxy::InspectorTargetProxy):
(WebKit::InspectorTargetProxy::connect):
(WebKit::InspectorTargetProxy::disconnect):
(WebKit::InspectorTargetProxy::sendMessageToTargetBackend):
* UIProcess/InspectorTargetProxy.h:
UIProcess proxy for an InspectorTarget in the WebContentProcess.

* UIProcess/WebProcessPool.cpp:
(WebKit::WebProcessPool::processForNavigationInternal):

* WebProcess/WebPage/WebPage.cpp:
(WebKit::m_shouldAttachDrawingAreaOnPageTransition):
(WebKit::WebPage::connectInspector):
(WebKit::WebPage::disconnectInspector):
(WebKit::WebPage::sendMessageToTargetBackend):
(WebKit::WebPage::setIndicating):
(WebKit::WebPage::setAllowsRemoteInspection): Deleted.
(WebKit::WebPage::setRemoteInspectionNameOverride): Deleted.
* WebProcess/WebPage/WebPage.h:
* WebProcess/WebPage/WebPage.messages.in:

* WebProcess/WebPage/WebPageInspectorTarget.h:
* WebProcess/WebPage/WebPageInspectorTarget.cpp:
(WebKit::WebPageInspectorTarget::WebPageInspectorTarget):
(WebKit::WebPageInspectorTarget::identifier const):
(WebKit::WebPageInspectorTarget::connect):
(WebKit::WebPageInspectorTarget::disconnect):
(WebKit::WebPageInspectorTarget::sendMessageToTargetBackend):
InspectorTarget for this WebPage.

* WebProcess/WebPage/WebPageInspectorTargetController.cpp: Added.
(WebKit::WebPageInspectorTargetController::WebPageInspectorTargetController):
(WebKit::WebPageInspectorTargetController::~WebPageInspectorTargetController):
(WebKit::WebPageInspectorTargetController::addTarget):
(WebKit::WebPageInspectorTargetController::removeTarget):
(WebKit::WebPageInspectorTargetController::connectInspector):
(WebKit::WebPageInspectorTargetController::disconnectInspector):
(WebKit::WebPageInspectorTargetController::sendMessageToTargetBackend):
(WebKit::WebPageInspectorTargetController::sendMessageToTargetFrontend):
* WebProcess/WebPage/WebPageInspectorTargetController.h:
* WebProcess/WebPage/WebPageInspectorTargetFrontendChannel.h:
* WebProcess/WebPage/WebPageInspectorTargetFrontendChannel.cpp:
(WebKit::WebPageInspectorTargetFrontendChannel::create):
(WebKit::WebPageInspectorTargetFrontendChannel::WebPageInspectorTargetFrontendChannel):
(WebKit::WebPageInspectorTargetFrontendChannel::sendMessageToFrontend):
Preparation for more target managment in the WebContentProcess.

Source/WebKitLegacy/mac:

* WebCoreSupport/WebInspectorClient.h:
WebKitLegacy will still have remote inspection of the Page directly.

LayoutTests:

* inspector/unit-tests/target-manager.html:
WI.targets has switched to being an array instead of a set.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@238192 268f45cc-cd09-0410-ab3c-d52691b4dbfc
77 files changed:
LayoutTests/ChangeLog
LayoutTests/inspector/unit-tests/target-manager.html
Source/JavaScriptCore/CMakeLists.txt
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/DerivedSources.make
Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
Source/JavaScriptCore/Sources.txt
Source/JavaScriptCore/inspector/InspectorTarget.h [new file with mode: 0644]
Source/JavaScriptCore/inspector/agents/InspectorTargetAgent.cpp [new file with mode: 0644]
Source/JavaScriptCore/inspector/agents/InspectorTargetAgent.h [new file with mode: 0644]
Source/JavaScriptCore/inspector/protocol/Target.json [new file with mode: 0644]
Source/JavaScriptCore/inspector/scripts/codegen/generator.py
Source/WebCore/ChangeLog
Source/WebCore/inspector/InspectorClient.h
Source/WebCore/inspector/InspectorController.cpp
Source/WebCore/inspector/InspectorController.h
Source/WebCore/page/Page.cpp
Source/WebCore/page/PageDebuggable.cpp
Source/WebCore/page/PageDebuggable.h
Source/WebInspectorUI/ChangeLog
Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js
Source/WebInspectorUI/UserInterface/Base/Main.js
Source/WebInspectorUI/UserInterface/Base/Object.js
Source/WebInspectorUI/UserInterface/Base/Setting.js
Source/WebInspectorUI/UserInterface/Controllers/DOMManager.js
Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js
Source/WebInspectorUI/UserInterface/Controllers/RuntimeManager.js
Source/WebInspectorUI/UserInterface/Controllers/TargetManager.js
Source/WebInspectorUI/UserInterface/Controllers/WorkerManager.js
Source/WebInspectorUI/UserInterface/Debug/Bootstrap.js
Source/WebInspectorUI/UserInterface/Debug/UncaughtExceptionReporter.js
Source/WebInspectorUI/UserInterface/Main.html
Source/WebInspectorUI/UserInterface/Models/DefaultDashboard.js
Source/WebInspectorUI/UserInterface/Protocol/Connection.js
Source/WebInspectorUI/UserInterface/Protocol/DirectBackendTarget.js [moved from Source/WebInspectorUI/UserInterface/Protocol/MainTarget.js with 81% similarity]
Source/WebInspectorUI/UserInterface/Protocol/InspectorBackend.js
Source/WebInspectorUI/UserInterface/Protocol/JavaScriptContextTarget.js [new file with mode: 0644]
Source/WebInspectorUI/UserInterface/Protocol/MultiplexingBackendTarget.js [new file with mode: 0644]
Source/WebInspectorUI/UserInterface/Protocol/PageTarget.js [new file with mode: 0644]
Source/WebInspectorUI/UserInterface/Protocol/TargetObserver.js [new file with mode: 0644]
Source/WebInspectorUI/UserInterface/Protocol/WorkerTarget.js
Source/WebInspectorUI/UserInterface/Test.html
Source/WebInspectorUI/UserInterface/Test/Test.js
Source/WebInspectorUI/UserInterface/Views/DebuggerSidebarPanel.js
Source/WebInspectorUI/UserInterface/Views/NetworkTableContentView.js
Source/WebInspectorUI/UserInterface/Views/QuickConsole.js
Source/WebInspectorUI/UserInterface/Views/SettingsTabContentView.js
Source/WebInspectorUI/UserInterface/Views/SourceCodeTextEditor.js
Source/WebKit/ChangeLog
Source/WebKit/Scripts/webkit/messages.py
Source/WebKit/Shared/WebPageCreationParameters.cpp
Source/WebKit/Shared/WebPageCreationParameters.h
Source/WebKit/Sources.txt
Source/WebKit/UIProcess/InspectorTargetProxy.cpp [new file with mode: 0644]
Source/WebKit/UIProcess/InspectorTargetProxy.h [new file with mode: 0644]
Source/WebKit/UIProcess/WebPageDebuggable.cpp [new file with mode: 0644]
Source/WebKit/UIProcess/WebPageDebuggable.h [new file with mode: 0644]
Source/WebKit/UIProcess/WebPageInspectorController.cpp [new file with mode: 0644]
Source/WebKit/UIProcess/WebPageInspectorController.h [new file with mode: 0644]
Source/WebKit/UIProcess/WebPageInspectorTargetAgent.cpp [new file with mode: 0644]
Source/WebKit/UIProcess/WebPageInspectorTargetAgent.h [new file with mode: 0644]
Source/WebKit/UIProcess/WebPageProxy.cpp
Source/WebKit/UIProcess/WebPageProxy.h
Source/WebKit/UIProcess/WebPageProxy.messages.in
Source/WebKit/UIProcess/WebProcessPool.cpp
Source/WebKit/WebKit.xcodeproj/project.pbxproj
Source/WebKit/WebProcess/WebPage/WebPage.cpp
Source/WebKit/WebProcess/WebPage/WebPage.h
Source/WebKit/WebProcess/WebPage/WebPage.messages.in
Source/WebKit/WebProcess/WebPage/WebPageInspectorTarget.cpp [new file with mode: 0644]
Source/WebKit/WebProcess/WebPage/WebPageInspectorTarget.h [new file with mode: 0644]
Source/WebKit/WebProcess/WebPage/WebPageInspectorTargetController.cpp [new file with mode: 0644]
Source/WebKit/WebProcess/WebPage/WebPageInspectorTargetController.h [new file with mode: 0644]
Source/WebKit/WebProcess/WebPage/WebPageInspectorTargetFrontendChannel.cpp [new file with mode: 0644]
Source/WebKit/WebProcess/WebPage/WebPageInspectorTargetFrontendChannel.h [new file with mode: 0644]
Source/WebKitLegacy/mac/ChangeLog
Source/WebKitLegacy/mac/WebCoreSupport/WebInspectorClient.h