https://bugs.webkit.org/show_bug.cgi?id=138236
Reviewed by Brian Burg.
Source/JavaScriptCore:
Inform the frontend about any extra domains the backend may have
above and beyond the default list of domains for the debuggable type.
This approach means there is almost no cost to normal debugging.
When a JSContext is debugged with extra agents, a message is sent
to the frontend letting it know which domains to then activate,
and perform any initialization work that may be required.
* inspector/InspectorAgentBase.h:
(Inspector::InspectorAgentBase::domainName):
* inspector/InspectorAgentRegistry.cpp:
(Inspector::InspectorAgentRegistry::appendExtraAgent):
* inspector/InspectorAgentRegistry.h:
* inspector/scripts/codegen/generator_templates.py:
Provide a way to get a list of just the extra domains.
To aggregate this list provide a different "append"
specifically for extra agents.
* inspector/JSGlobalObjectInspectorController.h:
* inspector/JSGlobalObjectInspectorController.cpp:
(Inspector::JSGlobalObjectInspectorController::JSGlobalObjectInspectorController):
(Inspector::JSGlobalObjectInspectorController::connectFrontend):
When a frontend connects, inform it of the extra domains.
* inspector/protocol/Inspector.json:
* inspector/agents/InspectorAgent.h:
* inspector/agents/InspectorAgent.cpp:
(Inspector::InspectorAgent::enable):
(Inspector::InspectorAgent::activateExtraDomains):
Send an event with the extra domains to activate.
Source/WebInspectorUI:
* UserInterface/Protocol/InspectorBackend.js:
(InspectorBackendClass.prototype.activateDomain):
* UserInterface/Protocol/InspectorObserver.js:
(WebInspector.InspectorObserver.prototype.activateExtraDomains):
* UserInterface/Base/Object.js:
* UserInterface/Base/Test.js:
* UserInterface/Base/Main.js:
(WebInspector.activateExtraDomains):
Default state is that there are no extra domains. When extra domains
are activated, some agents need to be re-initialized. Dispatch a
model event so views also know to re-initialize.
* UserInterface/Controllers/ApplicationCacheManager.js:
(WebInspector.ApplicationCacheManager.prototype._mainResourceDidChange):
* UserInterface/Controllers/DOMTreeManager.js:
Be more careful about direct agent use during main resource changes.
That can happen with a JSContext extended with a Page agent.
* UserInterface/Controllers/FrameResourceManager.js:
(WebInspector.FrameResourceManager):
(WebInspector.FrameResourceManager.prototype._mainFrameDidChange):
(WebInspector.FrameResourceManager.prototype._extraDomainsActivated):
* UserInterface/Controllers/StorageManager.js:
(WebInspector.StorageManager):
(WebInspector.StorageManager.prototype._databaseForIdentifier):
(WebInspector.StorageManager.prototype._extraDomainsActivated):
It is possible new window.FooAgent's are available. Perform expected
initialization re-checking if the agents are now available.
* UserInterface/Models/CSSCompletions.js:
Avoid re-initialization if we already did it. This should never
happen but this is just to be safe.
* UserInterface/Views/ResourceSidebarPanel.js:
(WebInspector.ResourceSidebarPanel):
(WebInspector.ResourceSidebarPanel.prototype._extraDomainsActivated):
Don't disallow expandable tree elements if this is a JSContext with
extra domains. If that JSContext has resources, we would have been
unable to see child resources.
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@175478
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2014-11-03 Joseph Pecoraro <pecoraro@apple.com>
+
+ Web Inspector: ALTERNATE_DISPATCHERS Let the frontend know about extra agents
+ https://bugs.webkit.org/show_bug.cgi?id=138236
+
+ Reviewed by Brian Burg.
+
+ Inform the frontend about any extra domains the backend may have
+ above and beyond the default list of domains for the debuggable type.
+ This approach means there is almost no cost to normal debugging.
+ When a JSContext is debugged with extra agents, a message is sent
+ to the frontend letting it know which domains to then activate,
+ and perform any initialization work that may be required.
+
+ * inspector/InspectorAgentBase.h:
+ (Inspector::InspectorAgentBase::domainName):
+ * inspector/InspectorAgentRegistry.cpp:
+ (Inspector::InspectorAgentRegistry::appendExtraAgent):
+ * inspector/InspectorAgentRegistry.h:
+ * inspector/scripts/codegen/generator_templates.py:
+ Provide a way to get a list of just the extra domains.
+ To aggregate this list provide a different "append"
+ specifically for extra agents.
+
+ * inspector/JSGlobalObjectInspectorController.h:
+ * inspector/JSGlobalObjectInspectorController.cpp:
+ (Inspector::JSGlobalObjectInspectorController::JSGlobalObjectInspectorController):
+ (Inspector::JSGlobalObjectInspectorController::connectFrontend):
+ When a frontend connects, inform it of the extra domains.
+
+ * inspector/protocol/Inspector.json:
+ * inspector/agents/InspectorAgent.h:
+ * inspector/agents/InspectorAgent.cpp:
+ (Inspector::InspectorAgent::enable):
+ (Inspector::InspectorAgent::activateExtraDomains):
+ Send an event with the extra domains to activate.
+
2014-11-01 Michael Saboff <msaboff@apple.com>
Add scope operand to op_resolve_scope
public:
virtual ~InspectorAgentBase() { }
+ String domainName() const { return m_name; }
+
virtual void didCreateFrontendAndBackend(InspectorFrontendChannel*, InspectorBackendDispatcher*) = 0;
virtual void willDestroyFrontendAndBackend(InspectorDisconnectReason reason) = 0;
virtual void discardAgent() { }
m_agents.append(WTF::move(agent));
}
+#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
+void InspectorAgentRegistry::appendExtraAgent(std::unique_ptr<InspectorAgentBase> agent)
+{
+ m_extraDomains.append(agent->domainName());
+
+ append(WTF::move(agent));
+}
+#endif
+
void InspectorAgentRegistry::didCreateFrontendAndBackend(InspectorFrontendChannel* frontendChannel, InspectorBackendDispatcher* backendDispatcher)
{
for (size_t i = 0; i < m_agents.size(); i++)
#define InspectorAgentRegistry_h
#include <wtf/Vector.h>
+#include <wtf/text/WTFString.h>
namespace Inspector {
void willDestroyFrontendAndBackend(InspectorDisconnectReason reason);
void discardAgents();
+#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
+ void appendExtraAgent(std::unique_ptr<InspectorAgentBase>);
+ Vector<String> extraDomains() const { return m_extraDomains; }
+#endif
+
private:
// These are declared here to avoid MSVC from trying to create default iplementations which would
// involve generating a copy constructor and copy assignment operator for the Vector of std::unique_ptrs.
InspectorAgentRegistry& operator=(const InspectorAgentRegistry&) = delete;
Vector<std::unique_ptr<InspectorAgentBase>> m_agents;
+#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
+ Vector<String> m_extraDomains;
+#endif
};
} // namespace Inspector
, m_augmentingClient(nullptr)
#endif
{
+ auto inspectorAgent = std::make_unique<InspectorAgent>(*this);
auto runtimeAgent = std::make_unique<JSGlobalObjectRuntimeAgent>(m_injectedScriptManager.get(), m_globalObject);
auto consoleAgent = std::make_unique<JSGlobalObjectConsoleAgent>(m_injectedScriptManager.get());
auto debuggerAgent = std::make_unique<JSGlobalObjectDebuggerAgent>(m_injectedScriptManager.get(), m_globalObject, consoleAgent.get());
+ m_inspectorAgent = inspectorAgent.get();
m_debuggerAgent = debuggerAgent.get();
m_consoleAgent = consoleAgent.get();
m_consoleClient = std::make_unique<JSGlobalObjectConsoleClient>(m_consoleAgent);
runtimeAgent->setScriptDebugServer(&debuggerAgent->scriptDebugServer());
- m_agents.append(std::make_unique<InspectorAgent>(*this));
+ m_agents.append(WTF::move(inspectorAgent));
m_agents.append(WTF::move(runtimeAgent));
m_agents.append(WTF::move(consoleAgent));
m_agents.append(WTF::move(debuggerAgent));
m_agents.didCreateFrontendAndBackend(frontendChannel, m_inspectorBackendDispatcher.get());
#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
+ m_inspectorAgent->activateExtraDomains(m_agents.extraDomains());
+
if (m_augmentingClient)
m_augmentingClient->inspectorConnected();
#endif
namespace Inspector {
class InjectedScriptManager;
-class InspectorConsoleAgent;
+class InspectorAgent;
class InspectorBackendDispatcher;
class InspectorConsoleAgent;
class InspectorDebuggerAgent;
JSC::JSGlobalObject& m_globalObject;
std::unique_ptr<InjectedScriptManager> m_injectedScriptManager;
std::unique_ptr<JSGlobalObjectConsoleClient> m_consoleClient;
+ InspectorAgent* m_inspectorAgent;
InspectorConsoleAgent* m_consoleAgent;
InspectorDebuggerAgent* m_debuggerAgent;
InspectorAgentRegistry m_agents;
if (m_pendingInspectData.first)
inspect(m_pendingInspectData.first, m_pendingInspectData.second);
+#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
+ if (m_pendingExtraDomainsData)
+ m_frontendDispatcher->activateExtraDomains(m_pendingExtraDomainsData);
+#endif
+
for (auto& testCommand : m_pendingEvaluateTestCommands) {
if (!m_frontendDispatcher)
break;
m_pendingEvaluateTestCommands.append(script);
}
+#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
+void InspectorAgent::activateExtraDomains(const Vector<String>& extraDomains)
+{
+ if (extraDomains.isEmpty())
+ return;
+
+ RefPtr<Inspector::Protocol::Array<String>> domainNames = Inspector::Protocol::Array<String>::create();
+ for (auto domainName : extraDomains)
+ domainNames->addItem(domainName);
+
+ if (!m_enabled)
+ m_pendingExtraDomainsData = domainNames.release();
+ else
+ m_frontendDispatcher->activateExtraDomains(domainNames.release());
+}
+#endif
+
} // namespace Inspector
#endif // ENABLE(INSPECTOR)
void inspect(PassRefPtr<Protocol::Runtime::RemoteObject> objectToInspect, PassRefPtr<InspectorObject> hints);
void evaluateForTestInFrontend(const String& script);
+#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
+ void activateExtraDomains(const Vector<String>&);
+#endif
+
private:
InspectorEnvironment& m_environment;
std::unique_ptr<InspectorInspectorFrontendDispatcher> m_frontendDispatcher;
RefPtr<InspectorInspectorBackendDispatcher> m_backendDispatcher;
Vector<String> m_pendingEvaluateTestCommands;
std::pair<RefPtr<Protocol::Runtime::RemoteObject>, RefPtr<InspectorObject>> m_pendingInspectData;
+#if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
+ RefPtr<Inspector::Protocol::Array<String>> m_pendingExtraDomainsData;
+#endif
bool m_enabled;
};
]
},
{
+ "name": "activateExtraDomains",
+ "description": "Fired when the backend has alternate domains that need to be activated.",
+ "parameters": [
+ { "name": "domains", "type": "array", "items": { "type": "string" }, "description": "Domain names that need activation" }
+ ]
+ },
+ {
"name": "targetCrashed",
"description": "Fired when debugging target has crashed"
}
if category is ObjCTypeCategory.Array:
protocol_type = ObjCGenerator.protocol_type_for_type(var_type.element_type)
objc_class = ObjCGenerator.objc_class_for_type(var_type.element_type)
- if protocol_type is 'Inspector::Protocol::Array<String>':
+ if protocol_type == 'Inspector::Protocol::Array<String>':
return 'inspectorStringArrayArray(%s)' % var_name
if protocol_type is 'String' and objc_class is 'NSString':
return 'inspectorStringArray(%s)' % var_name
auto alternateDispatcher = std::make_unique<ObjCInspector${domainName}BackendDispatcher>(handler);
auto alternateAgent = std::make_unique<AlternateDispatchableAgent<Inspector${domainName}BackendDispatcher, AlternateInspector${domainName}BackendDispatcher>>(ASCIILiteral("${domainName}"), WTF::move(alternateDispatcher));
- _controller->agentRegistry().append(WTF::move(alternateAgent));
+ _controller->agentRegistry().appendExtraAgent(WTF::move(alternateAgent));
}
- (id<${objcPrefix}${domainName}DomainHandler>)${variableNamePrefix}Handler
auto alternateDispatcher = std::make_unique<ObjCInspectorDatabaseBackendDispatcher>(handler);
auto alternateAgent = std::make_unique<AlternateDispatchableAgent<InspectorDatabaseBackendDispatcher, AlternateInspectorDatabaseBackendDispatcher>>(ASCIILiteral("Database"), WTF::move(alternateDispatcher));
- _controller->agentRegistry().append(WTF::move(alternateAgent));
+ _controller->agentRegistry().appendExtraAgent(WTF::move(alternateAgent));
}
- (id<RWIProtocolDatabaseDomainHandler>)databaseHandler
auto alternateDispatcher = std::make_unique<ObjCInspectorDatabaseBackendDispatcher>(handler);
auto alternateAgent = std::make_unique<AlternateDispatchableAgent<InspectorDatabaseBackendDispatcher, AlternateInspectorDatabaseBackendDispatcher>>(ASCIILiteral("Database"), WTF::move(alternateDispatcher));
- _controller->agentRegistry().append(WTF::move(alternateAgent));
+ _controller->agentRegistry().appendExtraAgent(WTF::move(alternateAgent));
}
- (id<RWIProtocolDatabaseDomainHandler>)databaseHandler
auto alternateDispatcher = std::make_unique<ObjCInspectorNetwork1BackendDispatcher>(handler);
auto alternateAgent = std::make_unique<AlternateDispatchableAgent<InspectorNetwork1BackendDispatcher, AlternateInspectorNetwork1BackendDispatcher>>(ASCIILiteral("Network1"), WTF::move(alternateDispatcher));
- _controller->agentRegistry().append(WTF::move(alternateAgent));
+ _controller->agentRegistry().appendExtraAgent(WTF::move(alternateAgent));
}
- (id<RWIProtocolNetwork1DomainHandler>)network1Handler
auto alternateDispatcher = std::make_unique<ObjCInspectorNetwork3BackendDispatcher>(handler);
auto alternateAgent = std::make_unique<AlternateDispatchableAgent<InspectorNetwork3BackendDispatcher, AlternateInspectorNetwork3BackendDispatcher>>(ASCIILiteral("Network3"), WTF::move(alternateDispatcher));
- _controller->agentRegistry().append(WTF::move(alternateAgent));
+ _controller->agentRegistry().appendExtraAgent(WTF::move(alternateAgent));
}
- (id<RWIProtocolNetwork3DomainHandler>)network3Handler
auto alternateDispatcher = std::make_unique<ObjCInspectorNetwork1BackendDispatcher>(handler);
auto alternateAgent = std::make_unique<AlternateDispatchableAgent<InspectorNetwork1BackendDispatcher, AlternateInspectorNetwork1BackendDispatcher>>(ASCIILiteral("Network1"), WTF::move(alternateDispatcher));
- _controller->agentRegistry().append(WTF::move(alternateAgent));
+ _controller->agentRegistry().appendExtraAgent(WTF::move(alternateAgent));
}
- (id<RWIProtocolNetwork1DomainHandler>)network1Handler
+2014-11-03 Joseph Pecoraro <pecoraro@apple.com>
+
+ Web Inspector: ALTERNATE_DISPATCHERS Let the frontend know about extra agents
+ https://bugs.webkit.org/show_bug.cgi?id=138236
+
+ Reviewed by Brian Burg.
+
+ * UserInterface/Protocol/InspectorBackend.js:
+ (InspectorBackendClass.prototype.activateDomain):
+ * UserInterface/Protocol/InspectorObserver.js:
+ (WebInspector.InspectorObserver.prototype.activateExtraDomains):
+ * UserInterface/Base/Object.js:
+ * UserInterface/Base/Test.js:
+ * UserInterface/Base/Main.js:
+ (WebInspector.activateExtraDomains):
+ Default state is that there are no extra domains. When extra domains
+ are activated, some agents need to be re-initialized. Dispatch a
+ model event so views also know to re-initialize.
+
+ * UserInterface/Controllers/ApplicationCacheManager.js:
+ (WebInspector.ApplicationCacheManager.prototype._mainResourceDidChange):
+ * UserInterface/Controllers/DOMTreeManager.js:
+ Be more careful about direct agent use during main resource changes.
+ That can happen with a JSContext extended with a Page agent.
+
+ * UserInterface/Controllers/FrameResourceManager.js:
+ (WebInspector.FrameResourceManager):
+ (WebInspector.FrameResourceManager.prototype._mainFrameDidChange):
+ (WebInspector.FrameResourceManager.prototype._extraDomainsActivated):
+ * UserInterface/Controllers/StorageManager.js:
+ (WebInspector.StorageManager):
+ (WebInspector.StorageManager.prototype._databaseForIdentifier):
+ (WebInspector.StorageManager.prototype._extraDomainsActivated):
+ It is possible new window.FooAgent's are available. Perform expected
+ initialization re-checking if the agents are now available.
+
+ * UserInterface/Models/CSSCompletions.js:
+ Avoid re-initialization if we already did it. This should never
+ happen but this is just to be safe.
+
+ * UserInterface/Views/ResourceSidebarPanel.js:
+ (WebInspector.ResourceSidebarPanel):
+ (WebInspector.ResourceSidebarPanel.prototype._extraDomainsActivated):
+ Don't disallow expandable tree elements if this is a JSContext with
+ extra domains. If that JSContext has resources, we would have been
+ unable to see child resources.
+
2014-10-30 Dana Burkart <dburkart@apple.com>
<rdar://problem/18821260> Prepare for the mysterious future
* THE POSSIBILITY OF SUCH DAMAGE.
*/
-WebInspector.Notification = {
- GlobalModifierKeysDidChange: "global-modifiers-did-change",
- PageArchiveStarted: "page-archive-started",
- PageArchiveEnded: "page-archive-ended"
-};
-
WebInspector.ContentViewCookieType = {
ApplicationCache: "application-cache",
CookieStorage: "cookie-storage",
this._initializeWebSocketIfNeeded();
this.debuggableType = InspectorFrontendHost.debuggableType() === "web" ? WebInspector.DebuggableType.Web : WebInspector.DebuggableType.JavaScript;
+ this.hasExtraDomains = false;
// Register observers for events from the InspectorBackend.
if (InspectorBackend.registerInspectorDispatcher)
this._contentLoaded = true;
}
+WebInspector.activateExtraDomains = function(domains)
+{
+ console.assert(!this.hasExtraDomains);
+ this.hasExtraDomains = true;
+
+ for (var domain of domains) {
+ var agent = InspectorBackend.activateDomain(domain);
+ if (agent.enable)
+ agent.enable();
+ }
+
+ this.notifications.dispatchEventToListeners(WebInspector.Notification.ExtraDomainsActivated);
+
+ WebInspector.CSSCompletions.requestCSSNameCompletions();
+}
+
WebInspector.sidebarPanelForCurrentContentView = function()
{
var currentContentView = this.contentBrowser.currentContentView;
};
WebInspector.notifications = new WebInspector.Object;
+
+WebInspector.Notification = {
+ GlobalModifierKeysDidChange: "global-modifiers-did-change",
+ PageArchiveStarted: "page-archive-started",
+ PageArchiveEnded: "page-archive-ended",
+ ExtraDomainsActivated: "extra-domains-activated",
+};
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+WebInspector.DebuggableType = {
+ Web: "web",
+ JavaScript: "javascript"
+};
+
WebInspector.loaded = function()
{
+ this.debuggableType = WebInspector.DebuggableType.Web;
+ this.hasExtraDomains = false;
+
// Register observers for events from the InspectorBackend.
// The initialization order should match the same in Main.js.
InspectorBackend.registerInspectorDispatcher(new WebInspector.InspectorObserver);
return;
}
- ApplicationCacheAgent.getManifestForFrame(event.target.id, this._manifestForFrameLoaded.bind(this, event.target.id));
+ if (window.ApplicationCacheAgent)
+ ApplicationCacheAgent.getManifestForFrame(event.target.id, this._manifestForFrameLoaded.bind(this, event.target.id));
},
_childFrameWasRemoved: function(event)
this.dispatchEventToListeners(WebInspector.DOMTreeManager.Event.ContentFlowListWasUpdated, {documentNodeIdentifier: documentNodeIdentifier, flows: contentFlows});
}
- if (CSSAgent.getNamedFlowCollection)
+ if (window.CSSAgent && CSSAgent.getNamedFlowCollection)
CSSAgent.getNamedFlowCollection(documentNodeIdentifier, onNamedFlowCollectionAvailable.bind(this));
},
if (window.NetworkAgent)
NetworkAgent.enable();
+ WebInspector.notifications.addEventListener(WebInspector.Notification.ExtraDomainsActivated, this._extraDomainsActivated, this);
+
this.initialize();
};
if (this._mainFrame)
this._mainFrame.markAsMainFrame();
this.dispatchEventToListeners(WebInspector.FrameResourceManager.Event.MainFrameDidChange, {oldMainFrame: oldMainFrame});
+ },
+
+ _extraDomainsActivated: function()
+ {
+ if (window.PageAgent)
+ PageAgent.getResourceTree(this._processMainFrameResourceTreePayload.bind(this));
}
};
WebInspector.Frame.addEventListener(WebInspector.Frame.Event.MainResourceDidChange, this._mainResourceDidChange, this);
+ WebInspector.notifications.addEventListener(WebInspector.Notification.ExtraDomainsActivated, this._extraDomainsActivated, this);
+
// COMPATIBILITY (iOS 6): DOMStorage was discovered via a DOMStorageObserver event. Now DOM Storage
// is added whenever a new securityOrigin is discovered. Check for DOMStorageAgent.getDOMStorageItems,
// which was renamed at the same time the change to start using securityOrigin was made.
}
return null;
+ },
+
+ _extraDomainsActivated: function()
+ {
+ if (window.DOMStorageAgent && DOMStorageAgent.getDOMStorageItems)
+ WebInspector.Frame.addEventListener(WebInspector.Frame.Event.SecurityOriginDidChange, this._securityOriginDidChange, this);
}
};
WebInspector.CSSCompletions.requestCSSNameCompletions = function()
{
+ if (WebInspector.CSSCompletions.cssNameCompletions)
+ return;
+
function propertyNamesCallback(error, names)
{
if (error)
activateDomain: function(domainName, activationDebuggableType)
{
- if (!activationDebuggableType || InspectorFrontendHost.debuggableType() === activationDebuggableType)
- this._agents[domainName].activate();
+ if (!activationDebuggableType || InspectorFrontendHost.debuggableType() === activationDebuggableType) {
+ var agent = this._agents[domainName];
+ agent.activate();
+ return agent;
+ }
+
+ return null;
},
// Private
detached: function(reason)
{
// FIXME: Not implemented.
+ },
+
+ activateExtraDomains: function(domains)
+ {
+ WebInspector.activateExtraDomains(domains);
}
};
WebInspector.debuggerManager.addEventListener(WebInspector.DebuggerManager.Event.ScriptAdded, this._scriptWasAdded, this);
WebInspector.debuggerManager.addEventListener(WebInspector.DebuggerManager.Event.ScriptsCleared, this._scriptsCleared, this);
+ WebInspector.notifications.addEventListener(WebInspector.Notification.ExtraDomainsActivated, this._extraDomainsActivated, this);
+
this._resourcesContentTreeOutline = this.contentTreeOutline;
this._searchContentTreeOutline = this.createContentTreeOutline();
this._extensionScriptsFolderTreeElement = new WebInspector.FolderTreeElement(WebInspector.UIString("Extension Scripts"));
var parentFolderTreeElement = this._extensionScriptsFolderTreeElement;
} else {
- if (WebInspector.debuggableType === WebInspector.DebuggableType.JavaScript)
+ if (WebInspector.debuggableType === WebInspector.DebuggableType.JavaScript && !WebInspector.hasExtraDomains)
insertIntoTopLevel = true;
else {
if (!this._extraScriptsFolderTreeElement)
this._cookieStorageRootTreeElement = null;
this._applicationCacheRootTreeElement = null;
this._applicationCacheURLTreeElementMap = {};
+ },
+
+ _extraDomainsActivated: function()
+ {
+ if (WebInspector.debuggableType === WebInspector.DebuggableType.JavaScript)
+ this._resourcesContentTreeOutline.element.classList.remove(WebInspector.NavigationSidebarPanel.HideDisclosureButtonsStyleClassName);
}
};
git://git.webkit.org / WebKit-https.git / commitdiff