Web Inspector: Remove unused and untested Page.setTouchEmulationEnabled command

[WebKit-https.git] / Source / WebInspectorUI / ChangeLog

2016-11-15  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Remove unused and untested Page.setTouchEmulationEnabled command
        https://bugs.webkit.org/show_bug.cgi?id=164793

        Reviewed by Matt Baker.

        * UserInterface/Protocol/Legacy/10.0/InspectorBackendCommands.js:
        * UserInterface/Protocol/Legacy/7.0/InspectorBackendCommands.js:
        * UserInterface/Protocol/Legacy/8.0/InspectorBackendCommands.js:
        * UserInterface/Protocol/Legacy/9.0/InspectorBackendCommands.js:
        * UserInterface/Protocol/Legacy/9.3/InspectorBackendCommands.js:
        * Versions/Inspector-iOS-10.0.json:
        * Versions/Inspector-iOS-7.0.json:
        * Versions/Inspector-iOS-8.0.json:
        * Versions/Inspector-iOS-9.0.json:
        * Versions/Inspector-iOS-9.3.json:

2016-11-15  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: URL Breakpoints that resolve in multiple workers should only appear in the UI once
        https://bugs.webkit.org/show_bug.cgi?id=164334
        <rdar://problem/29073523>

        Reviewed by Matt Baker.

        * UserInterface/Views/DebuggerSidebarPanel.js:
        (WebInspector.DebuggerSidebarPanel.prototype._addBreakpoint):
        Don't add a duplicate BreakpointTreeElements for the same Breakpoint.

2016-11-14  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Worker debugging should pause all targets and view call frames in all targets
        https://bugs.webkit.org/show_bug.cgi?id=164305
        <rdar://problem/29056192>

        Reviewed by Timothy Hatcher.

        This implements a policy where, when one Target ("Thread") pauses
        the frontend triggers a pause in all other Targets. The intended
        user experience is "all threads pause" whenever the frontend shows
        the debugger paused UI.

        DebuggerManager has a few straight forward changes:

            - The paused state reflects if any target is paused.
            - The Paused Event is fired when going from !paused -> paused.
              This means when the first target pauses.
            - The Resumed Event is fired when going from paused -> !paused.
              This means only after all targets have resumed.
            - The CallFrameDidChange Event now includes the Target that updated.

        When a Target first pauses the frontend then immediately pauses all
        other Targets. This puts them into a "pausing" state (we display as
        Idle) and they will pause as soon as they start executing JavaScript.

        When a Target steps the "paused" state isn't changing. So this is
        just a CallFramesDidChange update.

        When clicking Resume we resume all targets. This is will be the normal,
        expected way users resume execution. Note that one of the threads may
        then hit a breakpoint and re-pause all threads.

        Sometimes when multiple threads are paused you may want to run an
        individual thread to completion but keep other threads paused. There
        is a context menu on the ThreadTreeElement to resume just that
        single thread. It will continue and pause for its next run loop.

        * Localizations/en.lproj/localizedStrings.js:
        * UserInterface/Images/Thread.svg: Added.
        * UserInterface/Images/gtk/Thread.svg: Added.
        * UserInterface/Main.html:
        New strings and files.

        * UserInterface/Base/Main.js:
        (WebInspector.loaded):
        * UserInterface/Test/Test.js:
        (WebInspector.loaded):
        Place the TargetManager first since other managers may want to listen
        for TargetAdded / TargetRemoved events.

        * UserInterface/Controllers/DebuggerManager.js:
        (WebInspector.DebuggerManager.prototype.get paused):
        This is now a computed state.

        (WebInspector.DebuggerManager.prototype.pause):
        (WebInspector.DebuggerManager.prototype.resume):
        Affect all targets.

        (WebInspector.DebuggerManager.prototype.stepOver):
        (WebInspector.DebuggerManager.prototype.stepInto):
        (WebInspector.DebuggerManager.prototype.stepOut):
        (WebInspector.DebuggerManager.prototype.reset):
        Update to use the paused computed property.

        (WebInspector.DebuggerManager.prototype.continueUntilNextRunLoop):
        Issue the new Debugger.continueUntilNextRunLoop command
        on a given target.

        (WebInspector.DebuggerManager.prototype.initializeTarget):
        When a new Target is created and we were already paused,
        then start that Worker in a paused state.

        (WebInspector.DebuggerManager.prototype.debuggerDidPause):
        Recover from bad cases where the backend informs the frontend about
        internal JavaScript that it shouldn't know about. Legacy backend do
        this but also there are corner cases we need to handle.
        Dispatch events appropriately now that multiple targets may be paused.

        (WebInspector.DebuggerManager.prototype._didResumeInternal):
        Dispatch events appropriately now that multiple targets may be paused.

        (WebInspector.DebuggerManager.prototype._targetRemoved):
        Remove debugger data for targets that go away to avoid leaks.

        * UserInterface/Models/DebuggerData.js:
        (WebInspector.DebuggerData):
        (WebInspector.DebuggerData.prototype.get paused):
        (WebInspector.DebuggerData.prototype.get pausing):
        Move some more per-Target state into DebuggerData.

        (WebInspector.DebuggerData.prototype.pauseIfNeeded):
        (WebInspector.DebuggerData.prototype.resumeIfNeeded):
        (WebInspector.DebuggerData.prototype.continueUntilNextRunLoop):
        These should only be called by DebuggerManager. They correctly
        update the state of the DebuggerData for this Target, and also
        issue the underlying command to the target.

        (WebInspector.DebuggerData.prototype.updateForPause):
        (WebInspector.DebuggerData.prototype.updateForResume):
        Handle a special case where continueUntilNextRunLoop triggers
        an invisible "pause" on the backend that we should mirror.

        * UserInterface/Protocol/Target.js:
        (WebInspector.MainTarget):
        (WebInspector.MainTarget.prototype.get displayName):
        (WebInspector.MainTarget.prototype.initialize):
        Better display names.

        * UserInterface/Views/DebuggerSidebarPanel.js:
        (WebInspector.DebuggerSidebarPanel):
        (WebInspector.DebuggerSidebarPanel.prototype._debuggerDidPause):
        (WebInspector.DebuggerSidebarPanel.prototype._debuggerDidResume):
        (WebInspector.DebuggerSidebarPanel.prototype._updateSingleThreadCallStacks):
        (WebInspector.DebuggerSidebarPanel.prototype._selectActiveCallFrameTreeElement):
        (WebInspector.DebuggerSidebarPanel.prototype._showSingleThreadCallStacks):
        (WebInspector.DebuggerSidebarPanel.prototype._showMultipleThreadCallStacks):
        (WebInspector.DebuggerSidebarPanel.prototype._findThreadTreeElementForTarget):
        (WebInspector.DebuggerSidebarPanel.prototype._targetAdded):
        (WebInspector.DebuggerSidebarPanel.prototype._targetRemoved):
        (WebInspector.DebuggerSidebarPanel.prototype._debuggerCallFramesDidChange):
        (WebInspector.DebuggerSidebarPanel.prototype._debuggerActiveCallFrameDidChange):
        The DebuggerSidebar still has a single "Call Stacks" section, but maintains
        two TreeOutlines and only shows one at a time. The Single Thread view shows
        a flat list of the call frames for the Main Target when it is the only target.
        The Multiple Threads view shows a list of Threads and their call frames.
        We always keep both up to date, because we may need to swap between them
        purely as Targets are added / removed. There is a bit of extra logic to
        ensure we select elements properly based only on the visible tree outline.

        * UserInterface/Views/LogContentView.js:
        (WebInspector.LogContentView.prototype.didAppendConsoleMessageView):
        When evaluating in a particular target, "runAfterPendingDispatches"
        must wait for all other commands in that particular target to have
        completed. So use the target specific version.

        * UserInterface/Views/NavigationSidebarPanel.js:
        (WebInspector.NavigationSidebarPanel.prototype._isTreeElementWithoutRepresentedObject):
        Gracefully handle a few more TreeElements without a represented object.

        * UserInterface/Views/IdleTreeElement.css: Added.
        (.details-section.call-stack .idle .icon):
        * UserInterface/Views/IdleTreeElement.js: Added.
        (WebInspector.IdleTreeElement):
        Very basic tree element to encapsulate an Idle call frame with an
        empty represented object.

        * UserInterface/Views/ThreadTreeElement.css: Added.
        (.details-section.call-stack .thread .icon):
        * UserInterface/Views/ThreadTreeElement.js: Added.
        (WebInspector.ThreadTreeElement):
        (WebInspector.ThreadTreeElement.prototype.get target):
        (WebInspector.ThreadTreeElement.prototype.refresh):
        (WebInspector.ThreadTreeElement.prototype.onattach):
        (WebInspector.ThreadTreeElement.prototype.oncontextmenu):
        ThreadTreeElement has no represented object, but makes it easy
        to refresh a list of CallFrameTreeElements for a given target.

2016-11-14  Timothy Hatcher  <timothy@apple.com>

        Web Inspector: Disable Warning Filter in Debugger Tab By Default
        https://bugs.webkit.org/show_bug.cgi?id=164723
        rdar://problem/29251780

        Reviewed by Joseph Pecoraro.

        * UserInterface/Views/DebuggerSidebarPanel.js:
        (WebInspector.DebuggerSidebarPanel): Made "debugger-show-resources-with-issues-only" false by default.

2016-11-14  Nikita Vasilyev  <nvasilyev@apple.com>

        Web Inspector: Settings tab should look more like a native macOS view
        https://bugs.webkit.org/show_bug.cgi?id=164708
        <rdar://problem/29241296>

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/SettingsTabContentView.css:
        (.content-view.settings):
        (.content-view.settings > .header):
        (.content-view.settings > .setting-container):
        Match macOS Sierra default font size for settings view.

        (.content-view.settings > .setting-container > .setting-name):
        (.content-view.settings > .setting-container > .setting-value-controller):
        (.content-view.settings > .setting-container > .setting-value-controller input):
        (.content-view.settings > .setting-container > .setting-value-controller input[type="checkbox"]):
        Make checkbox larger.

        (.content-view.settings > .setting-container > .setting-value-controller select):
        (.content-view.settings > .setting-container > .setting-value-controller input[type="number"]):
        Decrease the width of the number fields to make them just wide enough to fit 2 digit numbers.

2016-11-12  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Type Profiler and Code Coverage Profiler should work in Workers
        https://bugs.webkit.org/show_bug.cgi?id=164682

        Reviewed by Darin Adler.

        * UserInterface/Controllers/BasicBlockAnnotator.js:
        * UserInterface/Models/ScriptSyntaxTree.js:
        (WebInspector.ScriptSyntaxTree.prototype.updateTypes):
        Use the target associated with the Script.

        * UserInterface/Protocol/Target.js:
        (WebInspector.WorkerTarget.prototype.initialize):
        When initializing a Worker Target, match the existing state
        of the Page for these profilers.

        * UserInterface/Views/ScopeChainDetailsSidebarPanel.js:
        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype._tokenTrackingControllerHighlightedJavaScriptTypeInformation):
        (WebInspector.SourceCodeTextEditor.prototype.willDismissPopover):
        Use the correct target for this Script / Resource.

        (WebInspector.SourceCodeTextEditor.prototype._setTypeTokenAnnotatorEnabledState):
        (WebInspector.SourceCodeTextEditor.prototype.set _basicBlockAnnotatorEnabled):
        Enable / disable for all targets when toggling profilers.

2016-11-11  Anthony Ricaud  <rik@webkit.org>

        Web Inspector: Whitespace in Editor should be less visible than regular content
        https://bugs.webkit.org/show_bug.cgi?id=164660

        Reviewed by Matt Baker.

        * UserInterface/Views/CodeMirrorOverrides.css:
        (.show-whitespace-characters .CodeMirror .cm-whitespace::before):

2016-11-11  Nikita Vasilyev  <nvasilyev@apple.com>

        Web Inspector: Call RuntimeAgent.disableControlFlowProfiler when Code Coverage Profiler is turned off
        https://bugs.webkit.org/show_bug.cgi?id=163407
        <rdar://problem/28764230>

        Reviewed by Timothy Hatcher.

        Turning Type Profiler off by clicking [T] icon now disables its backend by calling RuntimeAgent.disableTypeProfiler().

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype._setTypeTokenAnnotatorEnabledState):

2016-11-11  Nikita Vasilyev  <nvasilyev@apple.com>

        Web Inspector: Settings tab: make the header smaller to fit more content
        https://bugs.webkit.org/show_bug.cgi?id=164613
        <rdar://problem/29206007>

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/SettingsTabContentView.css:
        (.content-view.settings > .header):
        Use hv units for margin. 1vh = 1% of viewport height. When Web Inspector window is taller, the margin is larger.

        (.content-view.settings > .setting-container):
        Convert padding to margin to make spacing between the header and the first section better.

2016-11-10  Nikita Vasilyev  <nvasilyev@apple.com>

        Web Inspector: Call RuntimeAgent.disableControlFlowProfiler when Code Coverage Profiler is turned off
        https://bugs.webkit.org/show_bug.cgi?id=163407
        <rdar://problem/28764230>

        Reviewed by Joseph Pecoraro.

        Turning Code Coverage off by clicking [C] icon now disables its backend by calling RuntimeAgent.disableControlFlowProfiler().

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype.set _basicBlockAnnotatorEnabled):

2016-11-10  Aaron Chu  <aaron_chu@apple.com>

        Web Inspector: AXI: clarify button roles (e.g. toggle or popup button)
        https://bugs.webkit.org/show_bug.cgi?id=130726
        <rdar://problem/16420420>

        Reviewed by Brian Burg.

        Updated Inspector to show the button type using the new mapping information.

        * Localizations/en.lproj/localizedStrings.js:
        * UserInterface/Models/DOMNode.js:
        (WebInspector.DOMNode.prototype.accessibilityProperties.accessibilityPropertiesCallback):
        (WebInspector.DOMNode.prototype.accessibilityProperties):
        * UserInterface/Views/DOMNodeDetailsSidebarPanel.js:
        (WebInspector.DOMNodeDetailsSidebarPanel.prototype._refreshAccessibility.accessibilityPropertiesCallback):
        (WebInspector.DOMNodeDetailsSidebarPanel.prototype._refreshAccessibility):

2016-11-09  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: DebuggerManager.Event.Resumed introduces test flakiness
        https://bugs.webkit.org/show_bug.cgi?id=161951
        <rdar://problem/28295767>

        Reviewed by Brian Burg.

        * UserInterface/Controllers/DebuggerManager.js:
        (WebInspector.DebuggerManager.prototype.debuggerDidResume):
        Now, Debugger.resumed events really mean the debugger resumed,
        so act immediately instead of guessing. We must still guess
        in legacy backends.

        * UserInterface/Test/Test.js:
        When the inspector frontend encounters an issue, log it.

        * UserInterface/Views/DebuggerSidebarPanel.js:
        (WebInspector.DebuggerSidebarPanel.prototype._debuggerDidPause):
        (WebInspector.DebuggerSidebarPanel.prototype._debuggerActiveCallFrameDidChange):
        Always enable the step out button. I don't think it makes sense to disable
        it sometimes, and if there are issues with this we should solve the issues
        instead of hiding them.

2016-11-09  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Associate Worker Resources with the Worker and not the Page
        https://bugs.webkit.org/show_bug.cgi?id=164342
        <rdar://problem/29075775>

        Reviewed by Timothy Hatcher.

        A Target may have its own list of Resource. For example, Workers may
        request any resources via XHR/Fetch. So we associate a ResourceCollection
        with a Target, and ensure we show them in Web Inspector as you would expect.
        At this point, Target starts acting like Frame. Target has a resourceCollection
        and extraScriptsCollection just like Frame. Target has events for ResourceAdded
        just like Frame.

        Even though Resource loads are happening in Workers, the Network data
        still comes from the Page's Network agent. The added "targetId" data
        with the Resource will let us associate a Resoure with a Target.

        When opening inspector after a page has loaded, the frontend loads Resources
        via the Page.getResourceTree path. In this case, the frontend may be
        informed of Resources for a Target that it does not know about yet. In
        these cases, it sets them aside as Orphaned resources for a target. Later,
        when that Target is created, it will adopt its Orphaned resources.

        Places that used to listen to just Frame.Event.ResourceWasAdded should now
        also listen for Target.Event.ResourceAdded to ensure it sees the resources
        associated with non-page targets.

        * UserInterface/Protocol/Target.js:
        (WebInspector.Target):
        (WebInspector.Target.prototype.get identifier):
        (WebInspector.Target.prototype.get resourceCollection):
        (WebInspector.Target.prototype.get extraScriptCollection):
        (WebInspector.Target.prototype.addResource):
        (WebInspector.Target.prototype.adoptResource):
        (WebInspector.Target.prototype.addScript):
        Give Target resource collections.

        (WebInspector.MainTarget):
        (WebInspector.MainTarget.prototype.get mainResource):
        Pass through to the FrameResourceManager for the MainTarget.

        (WebInspector.WorkerTarget):
        (WebInspector.WorkerTarget.prototype.initialize):
        Adopt orphaned resources on creation.

        * UserInterface/Models/Resource.js:
        (WebInspector.Resource):
        (WebInspector.Resource.prototype.get target):
        (WebInspector.Resource.prototype.get type):
        Resource now has a Target. During creation, if there is a targetId
        then we must produce a Target or null (orphaned).

        (WebInspector.Resource.prototype.associateWithScript):
        When associating a Resource with a Script, we can use this opportunity
        to convert from an XML / Other type to Script.

        * UserInterface/Models/Script.js:
        (WebInspector.Script.prototype._resolveResource):
        When associating Scripts with a resource we must associate resources
        from within the proper Target. If it is the Main target we still use
        the FrameResourceManager which keep searches across all Frames.

        * UserInterface/Protocol/NetworkObserver.js:
        (WebInspector.NetworkObserver.prototype.requestWillBeSent):
        * UserInterface/Controllers/FrameResourceManager.js:
        (WebInspector.FrameResourceManager.prototype.initialize):
        (WebInspector.FrameResourceManager.prototype.frameDidNavigate):
        (WebInspector.FrameResourceManager.prototype.resourceRequestWillBeSent):
        (WebInspector.FrameResourceManager.prototype.resourceRequestWasServedFromMemoryCache):
        (WebInspector.FrameResourceManager.prototype.resourceRequestDidReceiveResponse):
        (WebInspector.FrameResourceManager.prototype.adoptOrphanedResourcesForTarget):
        (WebInspector.FrameResourceManager.prototype._addNewResourceToFrameOrTarget):
        (WebInspector.FrameResourceManager.prototype._addResourceToTarget):
        (WebInspector.FrameResourceManager.prototype._createResource):
        (WebInspector.FrameResourceManager.prototype._addFrameTreeFromFrameResourceTreePayload):
        (WebInspector.FrameResourceManager.prototype._addOrphanedResource):
        (WebInspector.FrameResourceManager.prototype._mainFrameDidChange):
        (WebInspector.FrameResourceManager.prototype._addNewResourceToFrame): Deleted.
        When creating Resources from Network events we may now have a targetId.
        Once created a Resource must be associated with a Frame, Target, or orphaned.

        * UserInterface/Main.html:
        * UserInterface/Views/TargetTreeElement.js: Removed.
        * UserInterface/Views/WorkerTreeElement.js: Added.
        (WebInspector.WorkerTreeElement):
        (WebInspector.WorkerTreeElement.prototype.get target):
        (WebInspector.WorkerTreeElement.prototype.onexpand):
        (WebInspector.WorkerTreeElement.prototype.oncollapse):
        (WebInspector.WorkerTreeElement.prototype.onpopulate):
        (WebInspector.WorkerTreeElement.prototype.updateSourceMapResources):
        (WebInspector.WorkerTreeElement.prototype.onattach):
        (WebInspector.WorkerTreeElement.prototype.compareChildTreeElements):
        (WebInspector.WorkerTreeElement.prototype._handleContextMenuEvent):
        (WebInspector.WorkerTreeElement.prototype._scriptAdded):
        (WebInspector.WorkerTreeElement.prototype._resourceAdded):
        Convert TargetTreeElement to WorkerTreeElement as that is clearer.
        Behave like FrameTreeElement and populate resources on creation,
        handle SourceMapResource, etc.

        * UserInterface/Views/FolderizedTreeElement.js:
        (WebInspector.FolderizedTreeElement.prototype.registerFolderizeSettings):
        (WebInspector.FolderizedTreeElement.prototype._compareTreeElementsByMainTitle):
        (WebInspector.FolderizedTreeElement.prototype._parentTreeElementForRepresentedObject):
        If the display name for a folder is `null` then there is no folder,
        and place such child tree elements at the top level. This will be
        the case for a Worker's Script's, which we choose not to folderize.

        * UserInterface/Controllers/DebuggerManager.js:
        (WebInspector.DebuggerManager.prototype.scriptDidParse):
        * UserInterface/Controllers/TargetManager.js:
        (WebInspector.TargetManager.prototype.targetForIdentifier):

        * UserInterface/Models/DefaultDashboard.js:
        (WebInspector.DefaultDashboard):
        * UserInterface/Controllers/TimelineManager.js:
        (WebInspector.TimelineManager):
        * UserInterface/Controllers/WorkerManager.js:
        (WebInspector.WorkerManager.prototype.workerCreated):
        * UserInterface/Views/OpenResourceDialog.js:
        (WebInspector.OpenResourceDialog.prototype.didDismissDialog):
        (WebInspector.OpenResourceDialog.prototype.didPresentDialog):
        (WebInspector.OpenResourceDialog.prototype._addScriptsForTarget): Deleted.
        (WebInspector.OpenResourceDialog.prototype._addResourcesForTarget): Added.
        Ensure those that listen for Frame.Event.ResourceWasAdded now also
        listen for Target.Event.ResourceAdded.

        * UserInterface/Views/ContextMenuUtilities.js:
        (WebInspector.appendContextMenuItemsForSourceCode):
        (WebInspector.appendContextMenuItemsForResource): Deleted.
        * UserInterface/Views/ResourceTimelineDataGridNode.js:
        (WebInspector.ResourceTimelineDataGridNode.prototype.appendContextMenuItems):
        * UserInterface/Views/ResourceTreeElement.js:
        (WebInspector.ResourceTreeElement.prototype._updateTitles):
        (WebInspector.ResourceTreeElement.prototype._handleContextMenuEvent):
        Generalize ContextMenu helper to SourceCode so it can be used on a Script or Resource.

        * UserInterface/Views/ResourceDetailsSidebarPanel.js:
        (WebInspector.ResourceDetailsSidebarPanel.prototype.inspect):
        When looking at a WorkerTarget's mainResource (Script) show the
        Resource Details sidebar for its Resource.

        * UserInterface/Views/ResourceSidebarPanel.js:
        (WebInspector.ResourceSidebarPanel):
        (WebInspector.ResourceSidebarPanel.prototype._scriptWasAdded):
        (WebInspector.ResourceSidebarPanel.prototype._scriptsCleared):
        (WebInspector.ResourceSidebarPanel.prototype._addTargetWithMainResource):
        (WebInspector.ResourceSidebarPanel.prototype._targetRemoved):
        (WebInspector.ResourceSidebarPanel.prototype._addScriptForNonMainTarget): Deleted.
        Simplify ResourceSidebarPanel to only handle adding WorkerTreeElements,
        which will do the rest of the work for their Resources/Scripts.

        * UserInterface/Views/SourceCodeTreeElement.js:
        (WebInspector.SourceCodeTreeElement.prototype.descendantResourceTreeElementTypeDidChange):
        When we were changing the type of a resource, it would remove and re-insert.
        This would collapse the parent if it was the only child in removal, and not
        expand the parent when re-inserting. This ensures we re-expand.

2016-11-09  Nikita Vasilyev  <nvasilyev@apple.com>

        Web Inspector: Settings tab sections overlap each other in docked Inspector window
        https://bugs.webkit.org/show_bug.cgi?id=164564

        Reviewed by Joseph Pecoraro.

        * UserInterface/Views/SettingsTabContentView.css:
        (.content-view.settings):
        Make settings sections non-shrinkable and make the content view vertically scrollable.

        (.content-view.settings > .setting-container):
        Set vertical padding that looks good for non-shrinkable sections.

2016-11-09  Nikita Vasilyev  <nvasilyev@apple.com>

        Web Inspector: Settings tab: Checkbox labels should be clickable
        https://bugs.webkit.org/show_bug.cgi?id=164470
        <rdar://problem/29133787>

        Reviewed by Matt Baker.

        * UserInterface/Views/SettingsTabContentView.js:
        (WebInspector.SettingsTabContentView.prototype.initialLayout):
        Add a label element to make checkboxes clickable.

2016-11-09  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Allow FolderTreeElement to display content when selected
        https://bugs.webkit.org/show_bug.cgi?id=164407

        Reviewed by Timothy Hatcher.

        * UserInterface/Main.html:
        Add CollectionContentView and TitleView.

        * UserInterface/Base/Main.js:
        * UserInterface/Views/ContentView.js:
        (WebInspector.ContentView.createFromRepresentedObject):
        (WebInspector.ContentView.isViewable):
        Add support for Collection as the representedObject of a content view.

        * UserInterface/Views/CollectionContentView.css: Added.
        (.content-view.collection):
        (.content-view.collection > .content-view):
        * UserInterface/Views/CollectionContentView.js: Added.
        (WebInspector.CollectionContentView):
        (WebInspector.CollectionContentView.prototype.initialLayout):
        (WebInspector.CollectionContentView.prototype._addContentViewForItem):
        (WebInspector.CollectionContentView.prototype._removeContentViewForItem):
        (WebInspector.CollectionContentView.prototype._handleItemAdded):
        (WebInspector.CollectionContentView.prototype._handleItemRemoved):
        (WebInspector.CollectionContentView.prototype._handleContentError):
        Takes in a Collection when constructed, and attempts to display a sub-ContentView for each
        item in the collection if the type of the collection is viewable en masse.  Currently, this
        is only supported for WebInspector.Resource.Type.Image collections.

        * UserInterface/Views/ResourceContentView.js:
        (WebInspector.ResourceContentView.prototype._contentError):
        Dispatch an event whenever the content fails to load.

        * UserInterface/Views/ResourceSidebarPanel.js:
        (WebInspector.ResourceSidebarPanel.prototype._treeSelectionDidChange):
        * UserInterface/Views/ResourcesTabContentView.js:
        (WebInspector.ResourcesTabContentView.prototype.canShowRepresentedObject):
        Allow FolderTreeElements to be selected.

        * UserInterface/Views/TitleView.css: Added.
        (.title-view):
        * UserInterface/Views/TitleView.js: Added.
        (WebInspector.TitleView):
        Basic view that displays the given text in the center of the viewable area.

2016-11-03  Nikita Vasilyev  <nvasilyev@apple.com>

        Web Inspector: Stack overflow when searching a timeline recording for JS function names
        https://bugs.webkit.org/show_bug.cgi?id=161784
        <rdar://problem/28219498>

        Reviewed by Timothy Hatcher.

        _populate method of ProfileNodeDataGridNode and ProfileDataGridNode traverses
        all children of a given node. makeVisible function of DataGrid#_applyFiltersToNode
        traverses all its parents to expand them. This creates an infinite recursion.
        Remove "populate" event before appending child nodes to prevent it.

        * UserInterface/Views/ProfileDataGridNode.js:
        (WebInspector.ProfileDataGridNode.prototype._populate):
        (WebInspector.ProfileDataGridNode):
        * UserInterface/Views/ProfileNodeDataGridNode.js:
        (WebInspector.ProfileNodeDataGridNode.prototype._populate):
        (WebInspector.ProfileNodeDataGridNode):

2016-11-03  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Modify FolderTreeElement to have a Collection as a its represented object
        https://bugs.webkit.org/show_bug.cgi?id=164349

        Reviewed by Matt Baker.

        * UserInterface/Views/FolderTreeElement.js:
        (WebInspector.FolderTreeElement):
        Now accepts a representedObject parameter, which must be a WebInspector.Collection.

        * UserInterface/Views/FolderizedTreeElement.js:
        (WebInspector.FolderizedTreeElement.prototype.registerFolderizeSettings):
        (WebInspector.FolderizedTreeElement.prototype.updateParentStatus):
        (WebInspector.FolderizedTreeElement.prototype._parentTreeElementForRepresentedObject):
        (WebInspector.FolderizedTreeElement.prototype._settingsForRepresentedObject):
        (WebInspector.FolderizedTreeElement.prototype._shouldGroupIntoFolders):
        (WebInspector.FolderizedTreeElement):
        Rework the logic for creating WebInspector.FolderTreeElement so that items for the
        representedObject parameter may be passed in via registerFolderizeSettings.

        * UserInterface/Views/FrameTreeElement.js:
        (WebInspector.FrameTreeElement):
        (WebInspector.FrameTreeElement.): Deleted.
        (WebInspector.FrameTreeElement.makeChildCountCallback): Deleted.
        Rework logic for calling registerFolderizeSettings to support the representedObject
        parameter.  Also changed calls to WebInspector.Frame to support the
        WebInspector.Collection class.

        * UserInterface/Views/ResourceSidebarPanel.js:
        (WebInspector.ResourceSidebarPanel.prototype.treeElementForRepresentedObject):
        (WebInspector.ResourceSidebarPanel.prototype._scriptWasAdded):
        (WebInspector.ResourceSidebarPanel.prototype._scriptsCleared):
        Create WebInspector.Collection instances of Script model objects for additional folders
        created by the Resources sidebar:
         - Anonymous Scripts
         - Extension Scripts
         - Extra Scripts

2016-11-02  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Include DebuggerAgent in Workers - see, pause, and step through scripts
        https://bugs.webkit.org/show_bug.cgi?id=164136
        <rdar://problem/29028462>

        Reviewed by Brian Burg.
        
        By implementing DebuggerAgent, Workers will inform the frontend about
        Scripts that evaluate in the Worker's VM and the Worker VM can pause
        and send the pausing CallFrames to the frontend. This means that
        WebInspector.Script and WebInspector.CallFrame will need to be made
        target aware. This also means that each Target will have its own
        set of debugger data, such as the list of scripts and pause data
        like the pause reason / call frames. Previously all this data was
        managed by DebuggerManager.

        With this change we split that data out of DebuggerManager to be
        per-target DebuggerData. DebuggerManager keeps `activeCallFrame`
        but the list of scripts and pause data have moved into `DebuggerData`
        which is per-target, accessed through DebuggerManager's new
        dataForTarget(target) method.

        Finally we make a few changes to the UserInterface to make Workers
        and their scripts, appear grouped together. The Resources sidebar
        previously had a single top level item for the Main Frame, which
        has all its resources as its children (potentially grouped into
        folders). With this change, each Worker gets its own top level
        item as well, and the Worker's subresources (imported scripts)
        become its children.

        We also now associate a single mainResource with Targets. In the
        case of Workers, we assume and assert that this is a Script. If
        this were to ever change we would need to adjust the assumptions.

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

        * UserInterface/Base/Main.js:
        * UserInterface/Test/Test.js:
        Add WebInspector.assumingMainTarget to fill in all the places where
        we assume the main target right now, but would need to handle non-main
        targets as other agents are implemented in workers. For example profile
        data that assumes the main target right now could be worker targets
        when we implement ScriptProfiler / Heap agents.

        * UserInterface/Protocol/Connection.js:
        (InspectorBackend.WorkerConnection):
        * UserInterface/Protocol/Target.js:
        (WebInspector.Target):
        (WebInspector.Target.prototype.get DebuggerAgent):
        (WebInspector.Target.prototype.get mainResource):
        (WebInspector.Target.prototype.set mainResource):
        (WebInspector.WorkerTarget.prototype.initialize):
        (WebInspector.WorkerTarget):
        Include DebuggerAgent in Targets.
        Include a mainResource for Worker Targets.

        * UserInterface/Protocol/DebuggerObserver.js:
        (WebInspector.DebuggerObserver.prototype.scriptParsed):
        (WebInspector.DebuggerObserver.prototype.breakpointResolved):
        (WebInspector.DebuggerObserver.prototype.paused):
        (WebInspector.DebuggerObserver.prototype.resumed):
        Pass the target on to managers when necessary.

        * UserInterface/Models/DebuggerData.js: Added.
        (WebInspector.DebuggerData):
        (WebInspector.DebuggerData.prototype.get target):
        (WebInspector.DebuggerData.prototype.get callFrames):
        (WebInspector.DebuggerData.prototype.get pauseReason):
        (WebInspector.DebuggerData.prototype.get pauseData):
        (WebInspector.DebuggerData.prototype.get scripts):
        (WebInspector.DebuggerData.prototype.scriptForIdentifier):
        (WebInspector.DebuggerData.prototype.scriptsForURL):
        (WebInspector.DebuggerData.prototype.reset):
        (WebInspector.DebuggerData.prototype.addScript):
        (WebInspector.DebuggerData.prototype.pause):
        (WebInspector.DebuggerData.prototype.unpause):
        Extract per-target data from DebuggerManager. This includes the list
        of scripts evaluated in a Target, and any pause data for this target
        such as the pause reason and call frames.

        * UserInterface/Controllers/DebuggerManager.js:
        (WebInspector.DebuggerManager.prototype.dataForTarget):
        (WebInspector.DebuggerManager.prototype.get pauseReason): Deleted.
        (WebInspector.DebuggerManager.prototype.get pauseData): Deleted.
        (WebInspector.DebuggerManager.prototype.get callFrames): Deleted.
        (WebInspector.DebuggerManager.prototype.reset):
        New way to access per-target debugger data.

        (WebInspector.DebuggerManager.prototype.initializeTarget):
        When a new Target is created, synchronize frontend state with the target.
        Things like the list of breakpoints and global breakpoint states.

        (WebInspector.DebuggerManager.prototype.scriptForIdentifier):
        (WebInspector.DebuggerManager.prototype.scriptsForURL):
        Convenience accessors for scripts must now provide a Target.

        (WebInspector.DebuggerManager.prototype.get knownNonResourceScripts):
        This is a convenience accessors for a list of all scripts across all targets
        so this handles getting the list across all targets.

        (WebInspector.DebuggerManager.prototype.pause):
        (WebInspector.DebuggerManager.prototype.resume):
        (WebInspector.DebuggerManager.prototype.stepOver):
        (WebInspector.DebuggerManager.prototype.stepInto):
        (WebInspector.DebuggerManager.prototype.stepOut):
        (WebInspector.DebuggerManager.prototype.continueToLocation):
        Stepping commands affect the current target with the active call frame.
        Eventually we will change Pause and Resume behavior to affect all targets.
        
        (WebInspector.DebuggerManager.prototype.addBreakpoint):
        (WebInspector.DebuggerManager.prototype.breakpointResolved):
        (WebInspector.DebuggerManager.prototype._setBreakpoint.didSetBreakpoint):
        (WebInspector.DebuggerManager.prototype._setBreakpoint):
        (WebInspector.DebuggerManager.prototype._removeBreakpoint):
        Breakpoints should be set on all targets, but we need a way
        to set them on a specific target, when initializing an
        individual target when we want to inform that single target
        of all of the breakpoints.

        (WebInspector.DebuggerManager.prototype._breakpointDisabledStateDidChange):
        (WebInspector.DebuggerManager.prototype._updateBreakOnExceptionsState):
        Changing global breakpoint state should inform all targets.

        (WebInspector.DebuggerManager.prototype.scriptDidParse):
        Associate Scripts with a Target. Identify the main resource of a
        Worker Target and set it as soon as we can.

        (WebInspector.DebuggerManager.prototype.debuggerDidPause):
        (WebInspector.DebuggerManager.prototype.debuggerDidResume):
        (WebInspector.DebuggerManager.prototype._sourceCodeLocationFromPayload):
        (WebInspector.DebuggerManager.prototype._scopeChainFromPayload):
        (WebInspector.DebuggerManager.prototype._scopeChainNodeFromPayload):
        (WebInspector.DebuggerManager.prototype._mainResourceDidChange):
        (WebInspector.DebuggerManager.prototype._didResumeInternal):
        Pausing and resuming now happens per-target, so associate
        created model objects (CallFrame, ScopeChain objects) and any
        other necessary data with the target.

        * UserInterface/Models/Breakpoint.js:
        (WebInspector.Breakpoint):
        (WebInspector.Breakpoint.prototype.get target):
        (WebInspector.Breakpoint.prototype.get info):
        * UserInterface/Models/CallFrame.js:
        (WebInspector.CallFrame):
        (WebInspector.CallFrame.prototype.get target):
        (WebInspector.CallFrame.fromDebuggerPayload):
        (WebInspector.CallFrame.fromPayload):
        * UserInterface/Models/ConsoleMessage.js:
        (WebInspector.ConsoleMessage):
        * UserInterface/Models/Script.js:
        (WebInspector.Script):
        (WebInspector.Script.prototype.get target):
        (WebInspector.Script.prototype.isMainResource):
        (WebInspector.Script.prototype.requestContentFromBackend):
        (WebInspector.Script.prototype._resolveResource):
        * UserInterface/Models/StackTrace.js:
        (WebInspector.StackTrace.fromPayload):
        (WebInspector.StackTrace.fromString):
        * UserInterface/Models/ProbeManager.js:
        (WebInspector.ProbeManager.prototype.didSampleProbe):
        * UserInterface/Models/Probe.js:
        (WebInspector.ProbeSample):
        * UserInterface/Views/ConsoleMessageView.js:
        (WebInspector.ConsoleMessageView.prototype._appendLocationLink):
        (WebInspector.ConsoleMessageView.prototype._formatParameterAsString):
        Associate model objects with a specific target where necessary.

        * UserInterface/Views/ObjectTreeBaseTreeElement.js:
        (WebInspector.ObjectTreeBaseTreeElement.prototype._appendMenusItemsForObject):
        * UserInterface/Controllers/RuntimeManager.js:
        (WebInspector.RuntimeManager.prototype.evaluateInInspectedWindow):
        * UserInterface/Protocol/RemoteObject.js:
        (WebInspector.RemoteObject.prototype.findFunctionSourceCodeLocation):
        Use target specific DebuggerAgent where necessary.

        * UserInterface/Controllers/JavaScriptRuntimeCompletionProvider.js:
        * UserInterface/Controllers/TimelineManager.js:
        (WebInspector.TimelineManager.prototype._callFramesFromPayload):
        * UserInterface/Models/ScriptTimelineRecord.js:
        (WebInspector.ScriptTimelineRecord.prototype._initializeProfileFromPayload.profileNodeFromPayload):
        * UserInterface/Views/EventListenerSectionGroup.js:
        (WebInspector.EventListenerSectionGroup.prototype._functionTextOrLink):
        (WebInspector.EventListenerSectionGroup):
        * UserInterface/Views/HeapSnapshotInstanceDataGridNode.js:
        (WebInspector.HeapSnapshotInstanceDataGridNode.logHeapSnapshotNode.node.shortestGCRootPath.):
        (WebInspector.HeapSnapshotInstanceDataGridNode.logHeapSnapshotNode):
        (WebInspector.HeapSnapshotInstanceDataGridNode.prototype._populateWindowPreview):
        (WebInspector.HeapSnapshotInstanceDataGridNode.prototype._populatePreview):
        (WebInspector.HeapSnapshotInstanceDataGridNode.prototype._mouseoverHandler.appendPathRow):
        * UserInterface/Views/ProfileDataGridNode.js:
        (WebInspector.ProfileDataGridNode.prototype.iconClassName):
        (WebInspector.ProfileDataGridNode.prototype.filterableDataForColumn):
        (WebInspector.ProfileDataGridNode.prototype._displayContent):
        Use assumed main target and audit these when the Worker gets more Agents.

        * UserInterface/Controllers/FrameResourceManager.js:
        (WebInspector.FrameResourceManager.prototype._initiatorSourceCodeLocationFromPayload):
        This will always be the main target because only the main target
        has access to the DOM.

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype.get target):
        (WebInspector.SourceCodeTextEditor.prototype.customPerformSearch):
        (WebInspector.SourceCodeTextEditor.prototype.textEditorGutterContextMenu):
        (WebInspector.SourceCodeTextEditor.prototype._tokenTrackingControllerHighlightedJavaScriptExpression.populate):
        (WebInspector.SourceCodeTextEditor.prototype._tokenTrackingControllerHighlightedJavaScriptExpression):
        (WebInspector.SourceCodeTextEditor.prototype._showPopoverForFunction.didGetDetails):
        (WebInspector.SourceCodeTextEditor.prototype._showPopoverForFunction):
        Update target specific actions to use the proper target's agents.

        * UserInterface/Views/TargetTreeElement.js: Added.
        (WebInspector.TargetTreeElement):
        (WebInspector.TargetTreeElement.prototype.get target):
        (WebInspector.TargetTreeElement.prototype.onexpand):
        (WebInspector.TargetTreeElement.prototype.oncollapse):
        Add a new tree element for a Target. We currently assume that the
        main resource for a Target will be a Script right now, as is the
        case for Web Workers. This simply remembers its expanded or
        collapsed state and has a better icon.

        * UserInterface/Views/ResourceIcons.css:
        (body:matches(.mac-platform, .windows-platform) .script.worker-icon .icon):
        (body:matches(.mac-platform, .windows-platform) .large .script.worker-icon .icon):
        * UserInterface/Images/WorkerScript.png: Renamed from Source/WebInspectorUI/UserInterface/Images/WorkerDocument.png.
        * UserInterface/Images/WorkerScript@2x.png: Renamed from Source/WebInspectorUI/UserInterface/Images/WorkerDocument@2x.png.
        * UserInterface/Images/WorkerScriptLarge.png: Renamed from Source/WebInspectorUI/UserInterface/Images/WorkerDocumentLarge.png.
        * UserInterface/Images/WorkerScriptLarge@2x.png: Renamed from Source/WebInspectorUI/UserInterface/Images/WorkerDocumentLarge@2x.png.
        Improve icon for a Worker's main resource script.

        * UserInterface/Views/ResourceSidebarPanel.js:
        (WebInspector.ResourceSidebarPanel):
        (WebInspector.ResourceSidebarPanel.prototype._scriptWasAdded):
        (WebInspector.ResourceSidebarPanel.prototype._scriptsCleared):
        (WebInspector.ResourceSidebarPanel.prototype._addScriptForNonMainTarget):
        (WebInspector.ResourceSidebarPanel.prototype._addTargetWithMainResource):
        (WebInspector.ResourceSidebarPanel.prototype._targetRemoved):
        * UserInterface/Views/SearchSidebarPanel.js:
        (WebInspector.SearchSidebarPanel.prototype.performSearch.searchScripts):
        (WebInspector.SearchSidebarPanel.prototype._searchTreeElementForScript):
        * UserInterface/Views/OpenResourceDialog.js:
        (WebInspector.OpenResourceDialog.prototype._populateResourceTreeOutline.createTreeElement):
        (WebInspector.OpenResourceDialog.prototype._populateResourceTreeOutline):
        (WebInspector.OpenResourceDialog.prototype.didDismissDialog):
        (WebInspector.OpenResourceDialog.prototype.didPresentDialog):
        (WebInspector.OpenResourceDialog.prototype._addResourcesForFrame):
        (WebInspector.OpenResourceDialog.prototype._addScriptsForTarget):
        (WebInspector.OpenResourceDialog.prototype._scriptAdded):
        (WebInspector.OpenResourceDialog):
        * UserInterface/Views/DebuggerSidebarPanel.js:
        (WebInspector.DebuggerSidebarPanel.prototype._addTreeElementForSourceCodeToTreeOutline):
        (WebInspector.DebuggerSidebarPanel.prototype._debuggerCallFramesDidChange):
        (WebInspector.DebuggerSidebarPanel.prototype._debuggerActiveCallFrameDidChange):
        (WebInspector.DebuggerSidebarPanel.prototype._updatePauseReasonSection):
        Include scripts from non-main targets in sidebars.

2016-11-01  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Creating a new pseudo-selector in the Styles sidebar doesn't work on first attempt
        https://bugs.webkit.org/show_bug.cgi?id=164092

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/CSSStyleDeclarationSection.css:
        (.style-declaration-section:not(.invalid-selector).rule-disabled > .header > .icon):
        (.style-declaration-section.invalid-selector > .header > .icon):
        (.style-declaration-section.invalid-selector > .header > .selector,):
        (.style-declaration-section.rule-disabled > .header > .icon): Deleted.

        * UserInterface/Views/CSSStyleDeclarationSection.js:
        (WebInspector.CSSStyleDeclarationSection):
        (WebInspector.CSSStyleDeclarationSection.prototype.refresh):
        (WebInspector.CSSStyleDeclarationSection.prototype._handleIconElementClicked):
        (WebInspector.CSSStyleDeclarationSection.prototype._updateSelectorIcon): Added.
        Re-add logic removed by https://webkit.org/b/159734 for handling invalid selectors.  Instead
        of just refreshing the section whenever the represented CSSRule changes selectors, we only
        need to refresh if the selector no longer applies to the current element.

        (WebInspector.CSSStyleDeclarationSection.prototype._handleMouseMove): Added.
        Fix another issue discovered while adding the invalid selector warnings, where the title
        attribute of each individual selector was no longer visible.  To fix this, whenever the user
        moves their mouse over the selector input, the position is compared to each selector to find
        the first one that matches, whose title is then applied to the input element.

2016-11-01  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Improve debugger highlight in some exception cases
        https://bugs.webkit.org/show_bug.cgi?id=164300

        Reviewed by Matt Baker.

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype.textEditorExecutionHighlightRange):
        When walking up AST nodes and reach a throw statement, use that.

2016-11-01  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Cleanup stale code in NetworkSidebarPanel
        https://bugs.webkit.org/show_bug.cgi?id=164295

        Reviewed by Matt Baker.

        * UserInterface/Views/NetworkSidebarPanel.js:
        (WebInspector.NetworkSidebarPanel.prototype.closed): Deleted.
        This doesn't appear to be needed since NetworkSidebarPanel never
        registered any event listeners.

2016-11-01  Devin Rousso  <dcrousso+webkit@gmail.com>

        REGRESSION (r191419): Web Inspector: Autocomplete is broken
        https://bugs.webkit.org/show_bug.cgi?id=150493

        Reviewed by Timothy Hatcher.

        Fixed CodeMirror.undo() logic rolled out by r191539 <https://webkit.org/b/150537>

        Added calls to CodeMirror.changeGeneration(true) which tells the history stack to "close"
        the current event, preventing it from being consolidated with new changes.  If the user
        typed fast enough, non-completion changes (like adding ":" in CSS) would get merged with
        completion changes, causing calls to CodeMirror.undo() to undo those changes as well.  To
        prevent this, a boolean variable is set to true whenever a completion "activity" is in
        progress, defined by a sequence of completion related events.  When this "activity" first
        starts, call CodeMirror.changeGeneration(true) to freeze the current history.

        See original bug for more information <https://webkit.org/b/147720>.

        * UserInterface/Controllers/CodeMirrorCompletionController.js:
        (WebInspector.CodeMirrorCompletionController):
        (WebInspector.CodeMirrorCompletionController.prototype.updateCompletions):
        (WebInspector.CodeMirrorCompletionController.prototype.isCompletionChange):
        (WebInspector.CodeMirrorCompletionController.prototype.hideCompletions):
        (WebInspector.CodeMirrorCompletionController.prototype.close):
        (WebInspector.CodeMirrorCompletionController.prototype.completionSuggestionsSelectedCompletion):
        (WebInspector.CodeMirrorCompletionController.prototype._applyCompletionHint.update):
        (WebInspector.CodeMirrorCompletionController.prototype._applyCompletionHint):
        (WebInspector.CodeMirrorCompletionController.prototype._commitCompletionHint.update):
        (WebInspector.CodeMirrorCompletionController.prototype._commitCompletionHint):
        (WebInspector.CodeMirrorCompletionController.prototype._removeCompletionHint.update):
        (WebInspector.CodeMirrorCompletionController.prototype._removeCompletionHint):
        (WebInspector.CodeMirrorCompletionController.prototype._completeAtCurrentPosition):
        (WebInspector.CodeMirrorCompletionController.prototype._handleBeforeChange):
        (WebInspector.CodeMirrorCompletionController.prototype._createCompletionHintMarker): Deleted.
        (WebInspector.CodeMirrorCompletionController.prototype._removeLastChangeFromHistory): Deleted.
        (WebInspector.CodeMirrorCompletionController.prototype._removeCompletionHint.clearMarker): Deleted.

2016-11-01  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Replace sublists inside DOM-related model objects with WI.Collection
        https://bugs.webkit.org/show_bug.cgi?id=164098

        Reviewed by Timothy Hatcher.

        * UserInterface/Models/DOMTree.js:
        * UserInterface/Models/Frame.js:
        Add support for WebInspector.Collection.

        * UserInterface/Models/Script.js:
        (WebInspector.Script):
        * UserInterface/Views/DebuggerSidebarPanel.js:
        (WebInspector.DebuggerSidebarPanel.prototype._addResourcesRecursivelyForFrame):
        * UserInterface/Views/FrameTreeElement.js:
        (WebInspector.FrameTreeElement):
        (WebInspector.FrameTreeElement.prototype.onpopulate):
        * UserInterface/Views/OpenResourceDialog.js:
        (WebInspector.OpenResourceDialog.prototype._addResourcesForFrame):
        Use new functions defined by changing to WebInspector.Collection.

2016-11-01  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Fix double remove of ResourceCollection if type changes
        https://bugs.webkit.org/show_bug.cgi?id=164268

        Reviewed by Joseph Pecoraro.

        * UserInterface/Models/ResourceCollection.js:
        (WebInspector.ResourceCollection.prototype._resourceTypeDidChange):
        Change logic so that a non-typed collection will not try to remove a resource that has
        changed types from the sub-collection of its old type, since the sub-collection itself will
        handle the removal inside its own event listener for the type change.

2016-11-01  Ryosuke Niwa  <rniwa@webkit.org>

        Web Inspector: Add the support for custom elements
        https://bugs.webkit.org/show_bug.cgi?id=164266
        <rdar://problem/29038883>

        Reviewed by Joseph Pecoraro.

        Show the custom element state in DOM node's details pane:
         - "Element" for all builtin elements.
         - "Element (Custom)" for any upgraded custom elements.
         - "Element (Waiting to be upgraded)" for any element waiting to be upgraded.
         - "Element (Failed to upgrade)" for any custom element that failed during construction or an upgrade.

        And add "Jump to Definition" to the context menu of an node to find the custom element's definition.

        * Localizations/en.lproj/localizedStrings.js: Added localized strings.
        * UserInterface/Controllers/DOMTreeManager.js:
        (WebInspector.DOMTreeManager.prototype._customElementStateChanged): Added. Update the state and fire
        WebInspector.DOMTreeManager.Event.CustomElementStateChanged to update the node's details pane.
        * UserInterface/Models/DOMNode.js:
        (WebInspector.DOMNode): Set the custom element state or default to "builtin". Use null when the node
        is not an element.
        (WebInspector.DOMNode.prototype.isCustomElement): Added. Returns true if this is a successfully
        constructed or upgraded custom element.
        (WebInspector.DOMNode.prototype.customElementState): Added.
        (WebInspector.DOMNode.CustomElementState): Added.
        * UserInterface/Protocol/DOMObserver.js:
        (WebInspector.DOMObserver.prototype.customElementStateChanged): Added.
        * UserInterface/Protocol/RemoteObject.js:
        (WebInspector.RemoteObject.prototype.getProperty): Added. Retrieves the property of a given name from
        the remote backend.
        * UserInterface/Views/DOMNodeDetailsSidebarPanel.js:
        (WebInspector.DOMNodeDetailsSidebarPanel): Call _customElementStateChanged when the custom element
        state changes by listening to WebInspector.DOMTreeManager.Event.CustomElementStateChanged.
        (WebInspector.DOMNodeDetailsSidebarPanel.prototype.layout):
        (WebInspector.DOMNodeDetailsSidebarPanel.prototype._refreshIdentity): Extracted from layout.
        (WebInspector.DOMNodeDetailsSidebarPanel.prototype._customElementStateChanged): Added. 
        (WebInspector.DOMNodeDetailsSidebarPanel.prototype._nodeTypeDisplayName): Include the custom element
        state when it's not a builtin element (_customElementState returns null in that case).
        (WebInspector.DOMNodeDetailsSidebarPanel.prototype._customElementState): Get the localized string for
        each custom element state.
        * UserInterface/Views/DOMTreeElement.js:
        (WebInspector.DOMTreeElement.prototype._populateNodeContextMenu): Add "Jump to Definition" item in the
        context menu of an element when it's a successfully constructed or upgraded custom element.

2016-10-31  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Shadow DOM scoped styles are missing
        https://bugs.webkit.org/show_bug.cgi?id=164247
        <rdar://problem/29035061>

        Reviewed by Antti Koivisto.

        * UserInterface/Models/DOMNodeStyles.js:
        (WebInspector.DOMNodeStyles.prototype.refresh.fetchedInlineStyles):
        Fix incorrect WrapperPromise usage.

2016-10-31  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Arrows for Styles scope bar item are misaligned
        https://bugs.webkit.org/show_bug.cgi?id=164159

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/ScopeRadioButtonNavigationItem.css:
        (.scope-radio-button-navigation-item > .scope-radio-button-item-select:focus):
        (.scope-radio-button-navigation-item > .arrows):

2016-10-31  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Entering ":n" in Open Resource Dialog, where n > number of lines, should jump to the last line
        https://bugs.webkit.org/show_bug.cgi?id=160840

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/TextEditor.js:
        (WebInspector.TextEditor.prototype.revealPosition):
        Since it is possible for the given position to be outside the bounds of the CodeMirror
        instance, wait to get the line handler for the highlight animation until we have constrained
        the position value.

2016-10-28  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Preferences for Text Editor behavior
        https://bugs.webkit.org/show_bug.cgi?id=149120

        Reviewed by Timothy Hatcher.

        * Localizations/en.lproj/localizedStrings.js:

        * UserInterface/Base/Main.js:
        (WebInspector.loaded):
        (WebInspector.contentLoaded):
        (WebInspector.contentLoaded.setTabSize):
        (WebInspector.contentLoaded.setInvalidCharacterClassName):
        (WebInspector.contentLoaded.setWhitespaceCharacterClassName):
        (WebInspector._tryToRestorePendingTabs):
        (WebInspector.indentString):
        (WebInspector._updateNewTabButtonState): Deleted.
        (WebInspector._newTabItemClicked): Deleted.
        Removed calls to the New Tab tab bar item on the Tab Bar instance.
        Added listener to the indentUnit setting to change the tab-size value on <body>.
        Created helper function to generate the indentString value from settings.

        * UserInterface/Base/Test.js:
        (WebInspector.indentString):
        Assume indent string is "    " for tests.

        * UserInterface/Base/Setting.js:
        Added global WebInspector.settings dictionary for holding settings with UI editors.

        * UserInterface/Main.html:
        Added GeneralTabBarItem, PinnedTabBarItem, and SettingsTabContentView.

        * UserInterface/Models/CSSStyleDeclaration.js:
        (WebInspector.CSSStyleDeclaration.prototype.generateCSSRuleString):
        * UserInterface/Views/CSSStyleDeclarationTextEditor.js:
        (WebInspector.CSSStyleDeclarationTextEditor.prototype._formattedContentFromEditor):
        (WebInspector.CSSStyleDeclarationTextEditor.prototype._resetContent.update):
        * UserInterface/Views/VisualStylePropertyEditor.js:
        (WebInspector.VisualStylePropertyEditor.generateFormattedTextForNewProperty):
        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype._showPopoverForFunction.didGetDetails):
        Now uses WebInspector.indentUnit for indentation values

        * UserInterface/Views/CodeMirrorAdditions.js:
        Added "showWhitespaceCharacter" option to CodeMirror.  When enabled, it adds an overlay to
        the editor that will use pseudo-elements to display whitespace characters (unicode 00B7).

        * UserInterface/Views/CodeMirrorOverrides.css:
        (.CodeMirror .cm-tab):
        (.show-whitespace-characters .CodeMirror .cm-tab::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-1::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-2::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-3::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-4::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-5::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-6::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-7::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-8::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-9::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-10::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-11::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-12::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-13::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-14::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-15::before):
        (.show-whitespace-characters .CodeMirror .cm-whitespace-16::before):
        (.show-invalid-characters .CodeMirror .cm-invalidchar):
        (.CodeMirror .cm-invalidchar): Deleted.
        Use unicode character 00B7 (middle dot) to display a space.  Also uses a grey border for
        visualizing tab characters.

        * UserInterface/Views/ApplicationCacheFrameContentView.js:
        * UserInterface/Views/CSSStyleDeclarationTextEditor.js:
        * UserInterface/Views/ClusterContentView.js:
        * UserInterface/Views/DOMTreeContentView.js:
        * UserInterface/Views/DatabaseContentView.js:
        * UserInterface/Views/IndexedDatabaseObjectStoreContentView.js:
        * UserInterface/Views/NetworkGridContentView.js:
        * UserInterface/Views/ResourceContentView.js:
        * UserInterface/Views/ScriptContentView.js:
        * UserInterface/Views/TabContentView.js:
        * UserInterface/Views/TimelineRecordingContentView.js:
        Add calls to super.shown(), super.hidden(), and super.closed().

        * UserInterface/Views/ConsoleTabContentView.js:
        * UserInterface/Views/DebuggerTabContentView.js:
        * UserInterface/Views/ElementsTabContentView.js:
        * UserInterface/Views/NetworkTabContentView.js:
        * UserInterface/Views/NewTabContentView.js:
        * UserInterface/Views/ResourcesTabContentView.js:
        * UserInterface/Views/SearchTabContentView.js:
        * UserInterface/Views/StorageTabContentView.js:
        * UserInterface/Views/TimelineTabContentView.js:
        Now uses WebInspector.GeneralTabBarItem.

        * UserInterface/Views/GeneralTabBarItem.js: Added.
        (WebInspector.GeneralTabBarItem):
        (WebInspector.GeneralTabBarItem.prototype.set title):
        (WebInspector.GeneralTabBarItem.prototype._handleContextMenuEvent):
        Split from TabBarItem.js to make pinned tab bar items more distinct.

        * UserInterface/Views/Main.css:
        (body):
        Removed tab-size.

        * UserInterface/Views/PinnedTabBarItem.js: Added.
        (WebInspector.PinnedTabBarItem):
        Split from TabBarItem.js to make pinned tab bar items more distinct.

        * UserInterface/Views/SettingsTabContentView.css: Added.
        (.content-view.settings):
        (.content-view.settings > .header):
        (.content-view.settings > .setting-container):
        (.content-view.settings > .setting-container > .setting-name):
        (.content-view.settings > .setting-container > .setting-value-controller):
        (.content-view.settings > .setting-container > .setting-value-controller input[type="number"]):

        * UserInterface/Views/SettingsTabContentView.js:
        (WebInspector.SettingsTabContentView):
        (WebInspector.SettingsTabContentView.tabInfo):
        (WebInspector.SettingsTabContentView.isEphemeral):
        (WebInspector.SettingsTabContentView.shouldSaveTab):
        (WebInspector.SettingsTabContentView.prototype.initialLayout):
        (WebInspector.SettingsTabContentView.isTabAllowed): Deleted.
        (WebInspector.SettingsTabContentView.prototype.get type): Deleted.
        Added logic to display an appropriate editor for each item in WebInspector.settings.

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype.close):
        Add call to super.close().

        * UserInterface/Views/TabBar.css:
        (.tab-bar:not(.animating) > .item:not(.selected, .disabled):hover):
        (.tab-bar > .item:not(.pinned) > .flex-space:last-child):
        (.tab-bar > .item.pinned > .icon):
        (.tab-bar:not(.animating) > .item:not(.selected, .disabled):hover > .icon):
        (.tab-bar:not(.animating) > .item:not(.selected, .disabled):hover,): Deleted.
        (.tab-bar > .item > .flex-space:last-child): Deleted.
        (.tab-bar > .item.new-tab-button > .icon): Deleted.
        (.tab-bar:not(.animating) > .item:not(.selected, .disabled):hover > .icon,): Deleted.
        Removed rules specifically targeting `.new-tab-button`.

        * UserInterface/Views/TabBar.js:
        (WebInspector.TabBar):
        (WebInspector.TabBar.prototype.get newTabTabBarItem):
        (WebInspector.TabBar.prototype.updateNewTabTabBarItemState):
        (WebInspector.TabBar.prototype.insertTabBarItem):
        (WebInspector.TabBar.prototype.removeTabBarItem.animateTabs):
        (WebInspector.TabBar.prototype.removeTabBarItem):
        (WebInspector.TabBar.prototype.selectPreviousTab):
        (WebInspector.TabBar.prototype.selectNextTab):
        (WebInspector.TabBar.prototype.set selectedTabBarItem):
        (WebInspector.TabBar.prototype.hasNormalTab):
        (WebInspector.TabBar.prototype.layout):
        (WebInspector.TabBar.prototype._hasMoreThanOneNormalTab):
        (WebInspector.TabBar.prototype._handleMouseDown):
        (WebInspector.TabBar.prototype._handleMouseMoved):
        (WebInspector.TabBar.prototype._handleMouseLeave):
        (WebInspector.TabBar.prototype._handleNewTabClick):
        (WebInspector.TabBar.prototype._handleNewTabMouseEnter):
        (WebInspector.TabBar.prototype.get newTabItem): Deleted.
        (WebInspector.TabBar.prototype.set newTabItem): Deleted.
        Replaced the newTabItem setter by adding a saved pinned tab bar item (instead of relying
        upon a different object to give it the pinned tab bar item) that changes modes depending on
        whether a new tab is able to be created.

        * UserInterface/Views/TabBarItem.js:
        (WebInspector.TabBarItem):
        (WebInspector.TabBarItem.prototype.get element):
        (WebInspector.TabBarItem.prototype.get representedObject):
        (WebInspector.TabBarItem.prototype.set representedObject):
        (WebInspector.TabBarItem.prototype.get parentTabBar):
        (WebInspector.TabBarItem.prototype.set parentTabBar):
        (WebInspector.TabBarItem.prototype.get image):
        (WebInspector.TabBarItem.prototype.set image):
        (WebInspector.TabBarItem.prototype.get title):
        (WebInspector.TabBarItem.prototype.set title):
        (WebInspector.TabBarItem.prototype.get pinned): Deleted.
        (WebInspector.TabBarItem.prototype._handleContextMenuEvent): Deleted.
        Split into GeneralTabBarItem and PinnedTabBarItem to simplify the logic of the DOM and allow
        for easier checking of whether a tab bar item is pinned or not.

        * UserInterface/Views/TabBrowser.js:
        (WebInspector.TabBrowser):
        (WebInspector.TabBrowser.prototype.addTabForContentView):
        (WebInspector.TabBrowser.prototype.closeTabForContentView):
        (WebInspector.TabBrowser.prototype._tabBarItemSelected):
        (WebInspector.TabBrowser.prototype._tabBarItemRemoved):
        Replaced references to newTabItem with a set number (since each TabBar has a specific number
        of pinned tabs).

        * UserInterface/Views/TextEditor.js:
        (WebInspector.TextEditor):
        (WebInspector.TextEditor.prototype.close):.
        Remove settings update event listeners to allow garbage collection.

        (WebInspector.TextEditor.prototype._startWorkerPrettyPrint):
        (WebInspector.TextEditor.prototype._startCodeMirrorPrettyPrint):
        Now uses the settings values in WebInspector.setting for settings on the CodeMirror
        instance.  Also updates the CodeMirror instance if any setting changes.

2016-10-28  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Include parameter strings for native CustomElementRegistry methods in the console
        https://bugs.webkit.org/show_bug.cgi?id=164147

        Reviewed by Brian Burg.

        * UserInterface/Models/NativeFunctionParameters.js:

2016-10-28  Matt Baker  <mattbaker@apple.com>

        Unreviewed, worker document images added

        * UserInterface/Images/WorkerDocument.png: Added.
        * UserInterface/Images/WorkerDocument@2x.png: Added.
        * UserInterface/Images/WorkerDocumentLarge.png: Added.
        * UserInterface/Images/WorkerDocumentLarge@2x.png: Added.

2016-10-27  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Create general model object Collection class
        https://bugs.webkit.org/show_bug.cgi?id=163995

        Reviewed by Joseph Pecoraro.

        * UserInterface/Models/Collection.js: Added.
        (WebInspector.Collection):
        (WebInspector.Collection.prototype.get items):
        (WebInspector.Collection.prototype.get typeVerifier):
        (WebInspector.Collection.prototype.add):
        (WebInspector.Collection.prototype.remove):
        (WebInspector.Collection.prototype.clear):
        (WebInspector.Collection.prototype.toArray):
        (WebInspector.Collection.prototype.toJSON):
        (WebInspector.Collection.prototype.itemAdded):
        (WebInspector.Collection.prototype.itemRemoved):
        (WebInspector.Collection.prototype.itemsCleared):
        Class that holds multiple model objects.  It can be limited to a specific type by supplying
        a "typeVerifier", which is a function that accepts a single argument (the model object) and
        returns true/false depending on if that argument matches the "type" of the collection.

        * UserInterface/Main.html:
        * UserInterface/Test.html:
        * UserInterface/Models/Frame.js:
        * UserInterface/Views/CookieStorageContentView.js:
        * UserInterface/Views/DebuggerSidebarPanel.js:
        * UserInterface/Views/FrameTreeElement.js:
        * UserInterface/Views/OpenResourceDialog.js:
        Add support for WebInspector.Collection.
        
        * UserInterface/Models/ResourceCollection.js:
        (WebInspector.ResourceCollection):
        (WebInspector.ResourceCollection.verifierForType):
        (WebInspector.ResourceCollection.prototype.resourceCollectionForType):
        (WebInspector.ResourceCollection.prototype.clear):
        (WebInspector.ResourceCollection.prototype.itemAdded):
        (WebInspector.ResourceCollection.prototype.itemRemoved):
        (WebInspector.ResourceCollection.prototype.itemsCleared):
        (WebInspector.ResourceCollection.prototype._associateWithResource):
        (WebInspector.ResourceCollection.prototype._disassociateWithResource):
        (WebInspector.ResourceCollection.prototype._resourceURLDidChange):
        (WebInspector.ResourceCollection.prototype._resourceTypeDidChange):
        (WebInspector.ResourceCollection.prototype.get resources): Deleted.
        (WebInspector.ResourceCollection.prototype.resourcesWithType): Deleted.
        (WebInspector.ResourceCollection.prototype.addResource): Deleted.
        (WebInspector.ResourceCollection.prototype.removeResource): Deleted.
        (WebInspector.ResourceCollection.prototype.removeAllResources): Deleted.
        Now a subclass of WebInspector.Collection.  Retrieving WebInspector.Resource objects by type
        and URL is still supported, but requesting by type now returns another instance of
        WebInspector.ResourceCollection that is configured to only accept the requested type.

2016-10-27  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Include ConsoleAgent in Workers - real console.log support
        https://bugs.webkit.org/show_bug.cgi?id=163844
        <rdar://problem/28903328>

        Reviewed by Brian Burg.

        * UserInterface/Protocol/Target.js:
        (WebInspector.Target.prototype.get ConsoleAgent):
        (WebInspector.Target.prototype._initializeNonMainTarget):
        * UserInterface/Protocol/Connection.js:
        (InspectorBackend.WorkerConnection):
        Add ConsoleAgent.

        * UserInterface/Controllers/LogManager.js:
        (WebInspector.LogManager.prototype.messageWasAdded):
        (WebInspector.LogManager.prototype.requestClearMessages):
        Handle ConsoleAgent calls with multiple targets.

        * UserInterface/Protocol/ConsoleObserver.js:
        (WebInspector.ConsoleObserver.prototype.messageAdded):
        Dispatch with the target in case we create Model objects.

        * UserInterface/Controllers/WorkerManager.js:
        (WebInspector.WorkerManager.prototype.workerCreated):
        The frontend must now call "initialized" on Workers after
        sending our setup messages (enable, set breakpoints, etc).

        * UserInterface/Protocol/RemoteObject.js:
        (WebInspector.RemoteObject.prototype.get target):
        Expose an accessor for tests.

        * UserInterface/Protocol/LoggingProtocolTracer.js:
        (WebInspector.LoggingProtocolTracer.prototype._processEntry):
        Actually output the Exception, useful when debugging failures in tests.

2016-10-27  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Include RuntimeAgent in Workers - evaluate in Worker context
        https://bugs.webkit.org/show_bug.cgi?id=163835
        <rdar://problem/28901465>

        Reviewed by Brian Burg.

        This introduces the idea that the frontend may communication with multiple
        backend "Targets" which each have their own set of Agents.

            - WebInspector.Target
              - has its own list of Agents
              - has a InspectorBackend.Connection to communicate with the backend

            - WebInspector.mainTarget
              - always exists and represents the thing we are debugging (Page or JSContext)

            - WebInspector.targets / WebInspector.targetManager
              - management of all Targets
              - create new Targets for Workers

        This also slowly introduces the concept that Model objects may be tied to
        a specific Target:

            - WebInspector.RemoteObject
              - in order to evaluate JS and interact with this object we must know the target (Page or Worker)
              - when fetching PropertyDescriptors and other RemoteObjects we must continue to pass on the target

        Finally this makes the QuickConsole list Worker execution contexts in
        the context picker so that users can choose a Worker context and
        evaluate JavaScript in that context using the console.

        * Localizations/en.lproj/localizedStrings.js:
        * UserInterface/Main.html:
        * UserInterface/Base/Main.js:
        (WebInspector.loaded):
        * UserInterface/Test.html:
        * UserInterface/Test/Test.js:
        (WebInspector.loaded):
        New files, strings, and managers.
        New global WebInspector.mainTarget.
        New convenience WebInspector.targets.

        * UserInterface/Protocol/Target.js: Added.
        (WebInspector.Target):
        (WebInspector.Target.prototype.get RuntimeAgent):
        (WebInspector.Target.prototype.get name):
        (WebInspector.Target.prototype.get type):
        (WebInspector.Target.prototype.get connection):
        (WebInspector.Target.prototype.get executionContext):
        (WebInspector.Target.prototype.get displayName):
        (WebInspector.Target.prototype._intializeMainTarget):
        (WebInspector.Target.prototype._initializeNonMainTarget):
        Target has some basic properties.

        * UserInterface/Controllers/TargetManager.js:
        (WebInspector.TargetManager):
        (WebInspector.TargetManager.prototype.get targets):
        (WebInspector.TargetManager.prototype.addTarget):
        (WebInspector.TargetManager.prototype.removeTarget):
        Holds the list of Targets and events when created / removed.
        Each target with a RuntimeAgent has an ExecutionContext.

        * UserInterface/Controllers/WorkerManager.js:
        (WebInspector.WorkerManager):
        (WebInspector.WorkerManager.prototype.workerCreated):
        (WebInspector.WorkerManager.prototype.workerTerminated):
        (WebInspector.WorkerManager.prototype.dispatchMessageFromWorker):
        Create / remove / dispatch on a Worker Target.

        * UserInterface/Protocol/InspectorBackend.js:
        (InspectorBackendClass):
        (InspectorBackendClass.prototype.registerCommand):
        (InspectorBackendClass.prototype.dispatch):
        (InspectorBackendClass.prototype.runAfterPendingDispatches):
        (InspectorBackendClass.prototype._agentForDomain):
        Keep the original implementations and just dispatch to the main connection.

        (InspectorBackend.Agent):
        (InspectorBackend.Agent.prototype.get connection):
        (InspectorBackend.Agent.prototype.set connection):
        (InspectorBackend.Agent.prototype.get dispatcher):
        We will share Agent implementations but just give new "copies" a different
        connection and dispatcher.

        (InspectorBackend.Command):
        (InspectorBackend.Command.create):
        (InspectorBackend.Command.prototype.invoke):
        (InspectorBackend.Command.prototype.supports):
        We continue to have a single Command instance on the Agent. However instead
        of using the hardcoded Agent on the Instance when evaluated as a function
        it uses the `this` object which should be an agent. This way:

            target1.RuntimeAgent.evaluate
                - `this` is target1 and we use the connection for that target
            target2.RuntimeAgent.evaluate
                - `this` is target2 and we use the connection for that target

        Unfortunately this breaks `RuntimeAgent.evaluate.invoke`. Currently this
        is solved by providing an extra parameter. In the case where we need to
        invoke on a particular agent we must provide the agent.

            target.RuntimeAgent.evaluate.invoke({options}, target.RuntimeAgent)

        This is unfortunate but only needed in a handful of places right now.

        (InspectorBackendClass.prototype._sendCommandToBackendWithCallback): Deleted.
        (InspectorBackendClass.prototype._sendCommandToBackendExpectingPromise): Deleted.
        (InspectorBackendClass.prototype._sendMessageToBackend): Deleted.
        (InspectorBackendClass.prototype._dispatchResponse): Deleted.
        (InspectorBackendClass.prototype._dispatchResponseToCallback): Deleted.
        (InspectorBackendClass.prototype._dispatchResponseToPromise): Deleted.
        (InspectorBackendClass.prototype._dispatchEvent): Deleted.
        (InspectorBackendClass.prototype._flushPendingScripts): Deleted.
        (InspectorBackend.Agent.prototype.get currentDispatchState): Deleted.
        (InspectorBackend.Command.prototype.deliverFailure): Deleted.
        * UserInterface/Protocol/Connection.js: Added.
        (InspectorBackend.Connection):
        (InspectorBackend.Connection.prototype.get target):
        (InspectorBackend.Connection.prototype.set target):
        (InspectorBackend.Connection.prototype.dispatch):
        (InspectorBackend.Connection.prototype.runAfterPendingDispatches):
        (InspectorBackend.Connection.prototype.sendMessageToBackend):
        (InspectorBackend.Connection.prototype._dispatchResponse):
        (InspectorBackend.Connection.prototype._dispatchResponseToCallback):
        (InspectorBackend.Connection.prototype._dispatchResponseToPromise):
        (InspectorBackend.Connection.prototype._dispatchEvent):
        (InspectorBackend.Connection.prototype._sendCommandToBackendWithCallback):
        (InspectorBackend.Connection.prototype._sendCommandToBackendExpectingPromise):
        (InspectorBackend.Connection.prototype._sendMessageToBackend):
        (InspectorBackend.Connection.prototype._flushPendingScripts):
        This extracts the Connection details into its own class.
        Although we make it appear as though a Target has a list of
        Agents, we actually have the Connection hold the list of Agents.
        Instead of cloning the entire Agent we just create a new object
        extended from the original Agent instance. This allows us to keep
        the same interface but just change the connection / dispatcher
        properties within the Agent.

        (InspectorBackend.MainConnection):
        (InspectorBackend.MainConnection.prototype.sendMessageToBackend):
        (InspectorBackend.WorkerConnection):
        (InspectorBackend.WorkerConnection.sendMessageToBackend):
        Two different kinds of connections. One for the Main connection
        and one for Workers. Currently the list of agents we expose
        on a Worker Target/Connection is hardcoded.

        * UserInterface/Models/ExecutionContext.js:
        (WebInspector.ExecutionContext):
        (WebInspector.ExecutionContext.prototype.get target):
        We may now have ExecutionContexts that mean a Page, Frames, and Workers.
        To do this we include the (target, executionContextId) tuple in this object.
        With this we have everything we need to evaluate JavaScript.

        * UserInterface/Controllers/RuntimeManager.js:
        (WebInspector.RuntimeManager):
        (WebInspector.RuntimeManager.prototype.get activeExecutionContext):
        (WebInspector.RuntimeManager.prototype.set activeExecutionContext):
        (WebInspector.RuntimeManager.prototype.get defaultExecutionContextIdentifier): Deleted.
        (WebInspector.RuntimeManager.prototype.set defaultExecutionContextIdentifier): Deleted.
        Update from contextId to a full ExecutionContext object.

        (WebInspector.RuntimeManager.prototype.evaluateInInspectedWindow.evalCallback):
        (WebInspector.RuntimeManager.prototype.evaluateInInspectedWindow):
        (WebInspector.RuntimeManager.prototype.saveResult):
        (WebInspector.RuntimeManager.prototype.getPropertiesForRemoteObject):
        (WebInspector.RuntimeManager.prototype._frameExecutionContextsCleared):
        * UserInterface/Controllers/FrameResourceManager.js:
        (WebInspector.FrameResourceManager.prototype.executionContextCreated):
        * UserInterface/Controllers/JavaScriptLogViewController.js:
        (WebInspector.JavaScriptLogViewController.prototype.consolePromptShouldCommitText):
        * UserInterface/Controllers/JavaScriptRuntimeCompletionProvider.js:
        Anywhere that wants to use the "activeExecutionContext" must use the
        specific RuntimeAgent tied to that ExecutionContext's Target.

        * UserInterface/Models/PropertyDescriptor.js:
        (WebInspector.PropertyDescriptor.fromPayload):
        * UserInterface/Protocol/RemoteObject.js:
        (WebInspector.RemoteObject):
        (WebInspector.RemoteObject.createFakeRemoteObject):
        (WebInspector.RemoteObject.fromPrimitiveValue):
        (WebInspector.RemoteObject.fromPayload):
        (WebInspector.RemoteObject.prototype.getDisplayablePropertyDescriptors):
        (WebInspector.RemoteObject.prototype.deprecatedGetDisplayableProperties):
        (WebInspector.RemoteObject.prototype.setPropertyValue):
        (WebInspector.RemoteObject.prototype.getCollectionEntries):
        (WebInspector.RemoteObject.prototype.releaseWeakCollectionEntries):
        (WebInspector.RemoteObject.prototype.callFunction):
        (WebInspector.RemoteObject.prototype.callFunctionJSON):
        (WebInspector.RemoteObject.prototype.getOwnPropertyDescriptor.wrappedCallback):
        (WebInspector.RemoteObject.prototype.getOwnPropertyDescriptor):
        (WebInspector.RemoteObject.prototype.release):
        (WebInspector.RemoteObject.prototype._getPropertyDescriptors):
        (WebInspector.RemoteObject.prototype._getPropertyDescriptorsResolver):
        (WebInspector.RemoteObject.prototype._deprecatedGetProperties):
        RemoteObject and related Model Objects now must be tied to a specific
        Target, because we need to know which Target it belongs to in order to
        interact with it further.

        * UserInterface/Views/QuickConsole.js:
        (WebInspector.QuickConsole):
        (WebInspector.QuickConsole.prototype.get selectedExecutionContext):
        (WebInspector.QuickConsole.prototype.set selectedExecutionContext):
        (WebInspector.QuickConsole.prototype._executionContextPathComponentsToDisplay):
        (WebInspector.QuickConsole.prototype._rebuildExecutionContextPathComponents):
        (WebInspector.QuickConsole.prototype._framePageExecutionContextsChanged):
        (WebInspector.QuickConsole.prototype._frameExecutionContextsCleared):
        (WebInspector.QuickConsole.prototype._createExecutionContextPathComponent):
        (WebInspector.QuickConsole.prototype._createExecutionContextPathComponentFromFrame):
        (WebInspector.QuickConsole.prototype._compareExecutionContextPathComponents):
        (WebInspector.QuickConsole.prototype._insertOtherExecutionContextPathComponent):
        (WebInspector.QuickConsole.prototype._removeOtherExecutionContextPathComponent):
        (WebInspector.QuickConsole.prototype._insertExecutionContextPathComponentForFrame):
        (WebInspector.QuickConsole.prototype._removeExecutionContextPathComponentForFrame):
        (WebInspector.QuickConsole.prototype._targetAdded):
        (WebInspector.QuickConsole.prototype._targetRemoved):
        (WebInspector.QuickConsole.prototype._pathComponentSelected):
        (WebInspector.QuickConsole.prototype.get selectedExecutionContextIdentifier): Deleted.
        (WebInspector.QuickConsole.prototype.set selectedExecutionContextIdentifier): Deleted.
        (WebInspector.QuickConsole.prototype._defaultExecutionContextChanged): Deleted.
        Update the code from executionContextId to ExecutionContext objects.
        Update the picker with ExecutionContextPathComponent for Workers (new Targets).
        Generalize and cleanup the code to make it easier to follow.

2016-10-27  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Introduce Page WorkerAgent and Worker InspectorController
        https://bugs.webkit.org/show_bug.cgi?id=163817
        <rdar://problem/28899063>

        Reviewed by Brian Burg.

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

        * UserInterface/Base/Main.js:
        (WebInspector.loaded):
        * UserInterface/Test/Test.js:
        (WebInspector.loaded):
        New Observers and Managers.

        * UserInterface/Protocol/WorkerObserver.js: Added.
        (WebInspector.WorkerObserver.prototype.workerCreated):
        (WebInspector.WorkerObserver.prototype.workerTerminated):
        (WebInspector.WorkerObserver.prototype.dispatchMessageFromWorker):
        (WebInspector.WorkerObserver):
        * UserInterface/Controllers/WorkerManager.js: Added.
        (WebInspector.WorkerManager):
        (WebInspector.WorkerManager.prototype.workerCreated):
        (WebInspector.WorkerManager.prototype.workerTerminated):
        (WebInspector.WorkerManager.prototype.dispatchMessageFromWorker):
        To be implemented with the first Worker agent implementation
        when there is actually something we can do with the Worker.

2016-10-25  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Cmd-+ doesn't "zoom in" to increase text size in the Web Inspector
        https://bugs.webkit.org/show_bug.cgi?id=163961
        <rdar://problem/28895308>

        Reviewed by Brian Burg.

        * UserInterface/Base/Main.js:
        (WebInspector.contentLoaded):
        Add a duplicate set of keyboard shortcuts for the Shift variants.

2016-10-25  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Remove dead code in FrameTreeElement
        https://bugs.webkit.org/show_bug.cgi?id=163914

        Reviewed by Brian Burg.

        * UserInterface/Views/FrameTreeElement.js:

2016-10-24  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Scope chain shouldn't show empty Closure sections
        https://bugs.webkit.org/show_bug.cgi?id=152348

        Reviewed by Joseph Pecoraro.

        * UserInterface/Controllers/DebuggerManager.js:
        (WebInspector.DebuggerManager.prototype._scopeChainNodeFromPayload):
        * UserInterface/Models/ScopeChainNode.js:
        (WebInspector.ScopeChainNode):
        (WebInspector.ScopeChainNode.prototype.get empty):
        Added support for new empty property.

        * UserInterface/Views/ScopeChainDetailsSidebarPanel.js:
        (WebInspector.ScopeChainDetailsSidebarPanel.prototype._generateCallFramesSection):
        Only create and display a DetailsSection if the scope is not empty (via empty).

2016-10-24  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Improve Quick Open sorting algorithm
        https://bugs.webkit.org/show_bug.cgi?id=163705

        Reviewed by Joseph Pecoraro.

        * UserInterface/Models/ResourceQueryResult.js:
        (WebInspector.ResourceQueryResult.prototype._calculateRank.getMultiplier):
        (WebInspector.ResourceQueryResult.prototype._calculateRank):
        Added logic to multiply the ranking increment/decrement based on whether the current match
        is part of a sequence, whether that sequence began with a special character, and the length
        of the current sequence.

2016-10-19  Dean Jackson  <dino@apple.com>

        Support CSS Shapes Level 1 without a prefix
        https://bugs.webkit.org/show_bug.cgi?id=163709
        <rdar://problem/28859369>

        Reviewed by Myles Maxfield.

        Replace -webkit-shape-outside with shape-outside.

        * UserInterface/Models/CSSKeywordCompletions.js:

2016-10-19  Aaron Chu  <aaron_chu@apple.com>

        Web Inspector: AXI: expose computed tree node and heading level
        https://bugs.webkit.org/show_bug.cgi?id=130825
        <rdar://problem/16442349>

        Reviewed by Joseph Pecoraro.

        Updating the Web Accessibility Inspector to display Heading Level and Hierarchical Level.

        * Localizations/en.lproj/localizedStrings.js:
        * UserInterface/Models/DOMNode.js:
        (WebInspector.DOMNode.prototype.accessibilityProperties.accessibilityPropertiesCallback):
        (WebInspector.DOMNode.prototype.accessibilityProperties):
        * UserInterface/Views/DOMNodeDetailsSidebarPanel.js:
        (WebInspector.DOMNodeDetailsSidebarPanel):
        (WebInspector.DOMNodeDetailsSidebarPanel.prototype._refreshAccessibility.accessibilityPropertiesCallback):
        (WebInspector.DOMNodeDetailsSidebarPanel.prototype._refreshAccessibility):

2016-10-18  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Styles Sidebar highlights "translate" but not "translateX"
        https://bugs.webkit.org/show_bug.cgi?id=163613
        <rdar://problem/28829610>

        Reviewed by Timothy Hatcher.

        * UserInterface/Models/CSSCompletions.js:
        (WebInspector.CSSCompletions.requestCSSCompletions):
        The hash table objects we pass to CodeMirror expects keys to be lowercased.

2016-10-18  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: CSS Autocompletion sometimes adds extra unexpected characters
        https://bugs.webkit.org/show_bug.cgi?id=163612
        <rdar://problem/28829557>

        Reviewed by Timothy Hatcher.

        * UserInterface/Controllers/CodeMirrorCompletionController.js:
        (WebInspector.CodeMirrorCompletionController.prototype._generateCSSCompletions):
        Better handle completions in cases where we are in the middle of a property
        to avoid orphaned characters, or at the end of a function name to avoid creating
        duplicate parenthesis.

2016-10-18  Joseph Pecoraro  <pecoraro@apple.com>

        REGRESSION(r201171): Web Inspector: Timeline Recording playhead should always start immediately, not wait until first event
        https://bugs.webkit.org/show_bug.cgi?id=163583
        <rdar://problem/28815882>

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/TimelineRecordingContentView.js:
        (WebInspector.TimelineRecordingContentView.prototype._startUpdatingCurrentTime):
        Revert logic change introduced by r201171 with no explanation.
        Whenever we get a start time we should use it, regardless of
        of what the current time is, precisely because the backend is
        informing us of the start time to use.

2016-10-17  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Add toggles for debugger pauses at console.assert failures
        https://bugs.webkit.org/show_bug.cgi?id=139542
        <rdar://problem/19281600>

        Reviewed by Timothy Hatcher.

        * UserInterface/Controllers/DebuggerManager.js:
        (WebInspector.DebuggerManager.prototype.get assertionsBreakpoint):
        (WebInspector.DebuggerManager.prototype.isBreakpointRemovable):
        (WebInspector.DebuggerManager.prototype._breakpointDisabledStateDidChange):
        New breakpoint and toggling behavior.

        * Localizations/en.lproj/localizedStrings.js:
        * UserInterface/Views/DebuggerSidebarPanel.js:
        (WebInspector.DebuggerSidebarPanel):
        (WebInspector.DebuggerSidebarPanel.prototype._breakpointTreeOutlineDeleteTreeElement):
        (WebInspector.DebuggerSidebarPanel.prototype._compareTopLevelTreeElements.isSpecialBreakpoint):
        (WebInspector.DebuggerSidebarPanel.prototype._compareTopLevelTreeElements):
        New breakpoint tree element behavior.

        (WebInspector.DebuggerSidebarPanel.prototype.saveStateToCookie):
        (WebInspector.DebuggerSidebarPanel.prototype.restoreStateFromCookie):
        Sidebar restoration if it was selected.

        * UserInterface/Images/Assertion.svg: Added.
        * UserInterface/Images/gtk/Assertion.svg: Added.
        * UserInterface/Views/BreakpointTreeElement.css:
        (.breakpoint-assertion-icon .icon):
        New sidebar icon for the global breakpoint.

2016-10-15  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Cleanup parts of DebuggerManager
        https://bugs.webkit.org/show_bug.cgi?id=163400

        Reviewed by Timothy Hatcher.

        * UserInterface/Controllers/DebuggerManager.js:
        (WebInspector.DebuggerManager.restoreBreakpointsSoon):

        (WebInspector.DebuggerManager.prototype.get paused):
        (WebInspector.DebuggerManager.prototype.get pauseReason):
        (WebInspector.DebuggerManager.prototype.get pauseData):
        (WebInspector.DebuggerManager.prototype.get callFrames):
        (WebInspector.DebuggerManager.prototype.get activeCallFrame):
        (WebInspector.DebuggerManager.prototype.set activeCallFrame):
        Put simple accessors at the top.

        (WebInspector.DebuggerManager.prototype.get allExceptionsBreakpoint):
        (WebInspector.DebuggerManager.prototype.get allUncaughtExceptionsBreakpoint):
        (WebInspector.DebuggerManager.prototype.get breakpoints):
        (WebInspector.DebuggerManager.prototype.breakpointForIdentifier):
        (WebInspector.DebuggerManager.prototype.breakpointsForSourceCode):
        (WebInspector.DebuggerManager.prototype.isBreakpointRemovable):
        (WebInspector.DebuggerManager.prototype.isBreakpointEditable):
        (WebInspector.DebuggerManager.prototype.get breakpointsDisabledTemporarily):
        Group public breakpoint state and access methods.

        (WebInspector.DebuggerManager.prototype.scriptForIdentifier):
        (WebInspector.DebuggerManager.prototype.scriptsForURL):
        (WebInspector.DebuggerManager.prototype.get searchableScripts):
        (WebInspector.DebuggerManager.prototype.get knownNonResourceScripts):
        Group public script access methods.

        (WebInspector.DebuggerManager.prototype.pause):
        (WebInspector.DebuggerManager.prototype.resume):
        (WebInspector.DebuggerManager.prototype.stepOver):
        (WebInspector.DebuggerManager.prototype.stepInto):
        (WebInspector.DebuggerManager.prototype.stepOut):
        (WebInspector.DebuggerManager.prototype.continueToLocation):
        (WebInspector.DebuggerManager.prototype.addBreakpoint):
        (WebInspector.DebuggerManager.prototype.removeBreakpoint):
        Group and modernize public methods that perform actions.

        (WebInspector.DebuggerManager.prototype.nextBreakpointActionIdentifier):
        Misc. methods.

        (WebInspector.DebuggerManager.prototype.breakpointResolved):
        (WebInspector.DebuggerManager.prototype.reset):
        (WebInspector.DebuggerManager.prototype.playBreakpointActionSound):
        (WebInspector.DebuggerManager.prototype.scriptDidParse):
        (WebInspector.DebuggerManager.prototype._setBreakpoint.didSetBreakpoint):
        (WebInspector.DebuggerManager.prototype._setBreakpoint):
        (WebInspector.DebuggerManager.prototype._breakpointEditablePropertyDidChange):
        (WebInspector.DebuggerManager.prototype._updateBreakOnExceptionsState):
        (WebInspector.DebuggerManager.prototype._associateBreakpointsWithSourceCode):
        Minor cleanup in protected and private methods.

        * UserInterface/Models/BreakpointAction.js:
        (WebInspector.BreakpointAction):
        Getting the next identifier is an action so it should be a function call.

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype.textEditorBreakpointAdded):
        Remove unused parameter.

2016-10-14  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Dragging to delete a Breakpoint should never trigger a ContentView change
        https://bugs.webkit.org/show_bug.cgi?id=163403
        <rdar://problem/28762930>

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/BreakpointTreeElement.js:
        (WebInspector.BreakpointTreeElement.prototype.ondelete):
        Signal when a breakpoint tree element will be going away because it was
        deleted via the keyboard operation within the TreeOutline. This is a dirty
        way to do the signal but we remove BreakpointTreeElements asynchronously
        when the Breakpoint actually gets removed from the backend.

        * UserInterface/Views/DebuggerSidebarPanel.js:
        (WebInspector.DebuggerSidebarPanel.prototype._removeDebuggerTreeElement):
        Deselect a BreakpointTreeElement if it was deleted in a way other then
        the delete keyboard shortcut. This ensures another TreeElement selection
        doesn't force ContentView changes.

2016-10-14  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Improve debugger highlight when inside of getter/setter calls
        https://bugs.webkit.org/show_bug.cgi?id=163428
        <rdar://problem/28769061>

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype.textEditorExecutionHighlightRange):
        When in the middle of a member expression at a '.' or '[' get the best member
        expression range.

        * UserInterface/Views/TextEditor.js:
        (WebInspector.TextEditor.prototype._updateExecutionRangeHighlight):
        Include the character at the current position. This is useful since AST Nodes
        don't give us token info but we would like to know if we are at particular tokens.

2016-10-14  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Unused Breakpoint getter/setter for "id" - should be "identifier"
        https://bugs.webkit.org/show_bug.cgi?id=163395

        Reviewed by Timothy Hatcher.

        * UserInterface/Models/Breakpoint.js:
        (WebInspector.Breakpoint.prototype.get identifier): Renamed.
        (WebInspector.Breakpoint.prototype.set identifier): Renamed.
        The only user is DebuggerManager which sets and gets. Previously
        it was unexpectedly setting a direct property on the Breakpoint
        instead of using these methods to set the member variable.

2016-10-14  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Remove uses of delete in SourceCodeTextEditor
        https://bugs.webkit.org/show_bug.cgi?id=163379

        Reviewed by Timothy Hatcher.

        Remove uses of delete and better group member variables.
        One of the deletes was deleting an incorrect property.

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor):
        (WebInspector.SourceCodeTextEditor.prototype.textEditorBreakpointAdded):
        (WebInspector.SourceCodeTextEditor.prototype.textEditorBreakpointRemoved):
        (WebInspector.SourceCodeTextEditor.prototype.textEditorBreakpointMoved):
        (WebInspector.SourceCodeTextEditor.prototype._tokenTrackingControllerHighlightedMarkedExpression):
        (WebInspector.SourceCodeTextEditor.prototype._dismissEditingController):
        (WebInspector.SourceCodeTextEditor.prototype.editingControllerDidFinishEditing):

2016-10-14  Joseph Pecoraro  <pecoraro@apple.com>

        Uncaught Exception: TypeError: this.positionToOffset is not a function - seen hovering expressions with Type Profiler enabled
        https://bugs.webkit.org/show_bug.cgi?id=163405
        <rdar://problem/28763953>

        Reviewed by Matt Baker.

        * UserInterface/Views/SourceCodeTextEditor.js:
        Use correct method name, the old one must have gone away.

2016-10-12  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Improve support for logging Proxy objects in console
        https://bugs.webkit.org/show_bug.cgi?id=163323
        <rdar://problem/28432553>

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/ConsoleMessageView.js:
        (WebInspector.ConsoleMessageView.prototype._formatParameter):
        Treat a Proxy like any other object.

2016-10-12  Joseph Pecoraro  <pecoraro@apple.com>

        Emit DebugHooks uniformly with pause locations instead of having separate pause locations and op_debug emits
        https://bugs.webkit.org/show_bug.cgi?id=162809

        Reviewed by Geoffrey Garen.

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype.textEditorExecutionHighlightRange):
        When pausing on the variable assignment inside for..of and for..in don't just
        highlight "var foo" but include the right hand side "var foo in ..." or
        "var foo of ...".

2016-10-12  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Whole program sometimes highlighted instead of just first statement
        https://bugs.webkit.org/show_bug.cgi?id=163300
        <rdar://problem/28723162>

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype.textEditorExecutionHighlightRange):
        Avoid highlighting the entire program by skipping a Program type Node.

        * UserInterface/Views/TextEditor.js:
        (WebInspector.TextEditor.prototype.setExecutionLineAndColumn):
        Avoid unnecessary work before content has loaded.

        (WebInspector.TextEditor.prototype.currentPositionToOriginalOffset):
        Avoid unnecessary indirection to get the CodeMirror editor.

2016-10-11  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Remove line highlight on primary execution line while stepping because it is distracting
        https://bugs.webkit.org/show_bug.cgi?id=163294
        <rdar://problem/28721176>

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/TextEditor.js:
        (WebInspector.TextEditor.prototype._updateExecutionLine):
        When setting the primary execution line, remove default line highlights.

2016-10-10  Matt Baker  <mattbaker@apple.com>

        Web Inspector: Revealed line not highlighted in TextEditor while debugger paused
        https://bugs.webkit.org/show_bug.cgi?id=163197

        Reviewed by Timothy Hatcher.

        * UserInterface/Views/TextEditor.js:
        (WebInspector.TextEditor.prototype.revealPosition.revealAndHighlightLine):
        Avoid highlighting the execution line while debugging, but allow
        other lines to be highlighted.

2016-10-06  Devin Rousso  <dcrousso+webkit@gmail.com>

        Inspector exception in `parseTextForRule()` when pasting into CSS rule selector
        https://bugs.webkit.org/show_bug.cgi?id=162792

        Reviewed by Matt Baker.

        * UserInterface/Views/CSSStyleDeclarationSection.js:
        (WebInspector.CSSStyleDeclarationSection.prototype._handleSelectorPaste.parseTextForRule):
        Changed regular expression for matching CSS rules to allow newlines in pasted text.

2016-10-02  Devin Rousso  <dcrousso+webkit@gmail.com>

        Web Inspector: Clicking twice on the color swatch square should hide the color picker
        https://bugs.webkit.org/show_bug.cgi?id=162759

        Reviewed by Matt Baker.

        * UserInterface/Views/InlineSwatch.js:
        (WebInspector.InlineSwatch):
        (WebInspector.InlineSwatch.prototype.didDismissPopover):
        (WebInspector.InlineSwatch.prototype._swatchElementClicked):
        Remove the "click" event listener when a popover is presented to prevent improper
        interaction.  Add the event listener back when the popover is dismissed.

2016-10-02  Matt Baker  <mattbaker@apple.com>

        Web Inspector: Exception thrown when hovering network waterfall graphs during reload
        https://bugs.webkit.org/show_bug.cgi?id=162850
        <rdar://problem/28579653>

        Reviewed by Brian Burg.

        * UserInterface/Views/ResourceTimelineDataGridNode.js:
        (WebInspector.ResourceTimelineDataGridNode.prototype._mouseoverRecordBar):
        Check that the node's data grid reference is valid before use.
        (WebInspector.ResourceTimelineDataGridNode):

2016-10-01  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Selection does not show up over execution highlight ranges
        https://bugs.webkit.org/show_bug.cgi?id=162844
        <rdar://problem/28579121>

        Reviewed by Matt Baker.

        * Scripts/update-codemirror-resources.rb:
        * UserInterface/External/CodeMirror/mark-selection.js: Added.
        * UserInterface/Main.html:
        New add-on that makes selection a text marker so it can be styled
        at the same level as other text markers.

        * UserInterface/Views/TextEditor.css:
        (.text-editor > .CodeMirror .execution-range-highlight:not(.CodeMirror-selectedtext)):
        Don't use execution-range-highlight styles if the text is selected.

        * UserInterface/Views/TextEditor.js:
        (WebInspector.TextEditor):
        Enable the text selection as text markers addon.

2016-09-30  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Make debugger stepping highlights work in inline <script>s
        https://bugs.webkit.org/show_bug.cgi?id=162753
        <rdar://problem/28551332>

        Reviewed by Brian Burg.

        * UserInterface/Models/TextRange.js:
        (WebInspector.TextRange.prototype.contains):
        Check if a given line/column falls within this range.

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor.prototype._getAssociatedScript):
        If we are in a Document resource find the associated script at a given position.

        (WebInspector.SourceCodeTextEditor.prototype.textEditorExecutionHighlightRange):
        When comparing offsets to SyntaxTree offsets, the SyntaxTree's offset of 0 is the
        first character of the Script, which differs from the current SourceCode's offset.
        Adjust the offset by the Script's startOffset.

        * UserInterface/Views/TextEditor.js:
        (WebInspector.TextEditor.prototype.currentPositionToOriginalPosition):
        (WebInspector.TextEditor.prototype._updateExecutionRangeHighlight):
        Pass both the original offset and original position to the delegate.

2016-09-30  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Stepping through `a(); b(); c();` it is unclear where we are and what is about to execute
        https://bugs.webkit.org/show_bug.cgi?id=161658
        <rdar://problem/28181254>

        Reviewed by Geoffrey Garen.

        * UserInterface/Models/Script.js:
        (WebInspector.Script.prototype.requestScriptSyntaxTree):
        Fix first calls to requestScriptSyntaxTree. They were getting an uncaught
        exception because the content argument was missing.

        * UserInterface/Models/ScriptSyntaxTree.js:
        (WebInspector.ScriptSyntaxTree.prototype.containersOfOffset):
        Find all AST nodes that contain a particular offset.

        * UserInterface/Views/SourceCodeTextEditor.js:
        (WebInspector.SourceCodeTextEditor):
        (WebInspector.SourceCodeTextEditor.prototype.close):
        (WebInspector.SourceCodeTextEditor.prototype._activeCallFrameDidChange):
        (WebInspector.SourceCodeTextEditor.prototype._activeCallFrameSourceCodeLocationChanged):
        (WebInspector.SourceCodeTextEditor.prototype.textEditorExecutionHighlightRange):
        Provide a good highlight range for a given offset. This is normally the start
        of a statement/expression, inside a statement/expression, or the closing brace
        of a function (leaving a function). Provide good ranges for each of these.

        * UserInterface/Views/TextEditor.js:
        (WebInspector.TextEditor):
        (WebInspector.TextEditor.set string.update):
        (WebInspector.TextEditor.prototype.set string):
        (WebInspector.TextEditor.prototype.setExecutionLineAndColumn):
        (WebInspector.TextEditor.prototype.revealPosition.revealAndHighlightLine):
        (WebInspector.TextEditor.prototype.revealPosition):
        (WebInspector.TextEditor.prototype.currentPositionToOriginalOffset):
        (WebInspector.TextEditor.prototype._updateAfterFormatting):
        (WebInspector.TextEditor.prototype.set executionLineNumber): Deleted.
        (WebInspector.TextEditor.prototype.set executionColumnNumber): Deleted.
        (WebInspector.TextEditor.prototype._updateExecutionLine.update): Deleted.
        Always set the execution line and column together, to simplify how we update highlights.

        (WebInspector.TextEditor.prototype._clearMultilineExecutionLineHighlights):
        (WebInspector.TextEditor.prototype._updateExecutionLine):
        When updating the main highlight clear any multi-line highlights.

        (WebInspector.TextEditor.prototype._updateExecutionRangeHighlight):
        Ask the delegate for a specific highlight range. If provided use that range,
        otherwise just highlight the end of the line. Once we know the range, if it
        is multiple lines, give the extra lines the full line highlight as well.
        Also make adjustments, such as not highlighting trailing whitespace.

        * UserInterface/Views/TextEditor.css:
        (.text-editor > .CodeMirror .execution-line.primary .CodeMirror-linenumber::after):
        (.text-editor > .CodeMirror .execution-line):
        (.text-editor > .CodeMirror .execution-line .CodeMirror-matchingbracket):
        (.text-editor > .CodeMirror .execution-range-highlight):
        Styles for execution lines and execution range highlights.

2016-09-29  Aaron Chu  <aaron_chu@apple.com>

        Web Inspector: AXI: linkified refs to #document and #text are not usually navigable nodes; consider delinkifying them
        https://bugs.webkit.org/show_bug.cgi?id=130600
        <rdar://problem/16391333>

        Reviewed by Brian Burg.

        Removing link style for non-navigable nodes by first
        checking nodeType of the node.

        * UserInterface/Base/DOMUtilities.js:
        (WebInspector.linkifyNodeReference):

2016-09-27  Matt Baker  <mattbaker@apple.com>

        Web Inspector: Refreshing while in Timelines-tab causes negative timestamps in Network-tab
        https://bugs.webkit.org/show_bug.cgi?id=160051
        <rdar://problem/27480122>

        Reviewed by Brian Burg.

        * UserInterface/Views/NetworkGridContentView.js:
        (WebInspector.NetworkGridContentView.prototype.get startTime):
        (WebInspector.NetworkGridContentView.prototype.get zeroTime):
        Use the cached start time for graph data source properties instead of
        relying on the ruler, which requires a layout in order to be updated
        for the first time.

2016-09-27  Matt Baker  <mattbaker@apple.com>

        Web Inspector: Unfocusing / Focusing inspector window should not change ContentView
        https://bugs.webkit.org/show_bug.cgi?id=162572
        <rdar://problem/28479562>

        Reviewed by Brian Burg.

        Improve NavigationSidebarPanel logic for coordinating selection between trees.
        When tree selection changes, the most recent selection should be restored
        the next time the tree is focused.

        The sidebar should also handle focusing a tree for the first time, in
        which no previous selection exists, and focusing a tree that has had its
        previous selection filtered out (hidden).

        * UserInterface/Views/NavigationSidebarPanel.js:
        (WebInspector.NavigationSidebarPanel.prototype._contentTreeOutlineDidFocus):
        (WebInspector.NavigationSidebarPanel.prototype._contentTreeOutlineTreeSelectionDidChange):
        Restoring the last deselected element, instead of the last selected element
        only works when the selection is moving from one tree to another. When
        the elements belong to the same tree the newly selected element won't
        be saved until the next selection change. If the window loses and regains
        the focus before then, the tree will restore the previous selection,
        effectively reverting the last selection change.

2016-09-27  Tomas Popela  <tpopela@redhat.com>

        [GTK] Mac defaults are used for key shortcuts on Linux
        https://bugs.webkit.org/show_bug.cgi?id=162564

        Don't set Mac's default keymap as a fallthrough for CodeMirror when we
        are not on Mac.

        Reviewed by Carlos Garcia Campos.

        * UserInterface/Test.html: Include Platform.js for the
        WebInspector.Platform definition.
        * UserInterface/Views/CodeMirrorAdditions.js:

2016-09-26  Matt Baker  <mattbaker@apple.com>

        Web Inspector: Box Model values not updated when DOM node styles change
        https://bugs.webkit.org/show_bug.cgi?id=162525

        Reviewed by Brian Burg.

        The Box Model section should refresh itself when the selected node's
        computed style changes. This is necessary since the Styles sidebar
        doesn't always refresh its sections on node changes.

        * UserInterface/Views/BoxModelDetailsSectionRow.js:
        (WebInspector.BoxModelDetailsSectionRow.prototype.set nodeStyles):
        Refresh metrics whenever the computed style changes.

        (WebInspector.BoxModelDetailsSectionRow.prototype._getBox):
        (WebInspector.BoxModelDetailsSectionRow.prototype._getComponentSuffix):
        (WebInspector.BoxModelDetailsSectionRow.prototype._updateMetrics.createValueElement):
        (WebInspector.BoxModelDetailsSectionRow.prototype._updateMetrics.createBoxPartElement):
        (WebInspector.BoxModelDetailsSectionRow.prototype._updateMetrics.createContentAreaElement):
        (WebInspector.BoxModelDetailsSectionRow.prototype._updateMetrics):
        Drive-by cleanup to make this large function easier to read.
        (WebInspector.BoxModelDetailsSectionRow.prototype._updateMetrics.createElement): Deleted.
        Renamed createValueElement.
        (WebInspector.BoxModelDetailsSectionRow.prototype._updateMetrics.createContentAreaWidthElement): Deleted.
        (WebInspector.BoxModelDetailsSectionRow.prototype._updateMetrics.createContentAreaHeightElement): Deleted.
        Combined these into a single function taking a property name (width or height).

== Rolled over to ChangeLog-2016-09-26 ==