Web Inspector: Generate Individual InspectorBackendDispatchers, add base InspectorBac...
[WebKit-https.git] / Source / WebCore / inspector / InspectorApplicationCacheAgent.cpp
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  * Copyright (C) 2010 Google Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
21  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
23  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27
28 #if ENABLE(INSPECTOR)
29
30 #include "InspectorApplicationCacheAgent.h"
31
32 #include "ApplicationCacheHost.h"
33 #include "DocumentLoader.h"
34 #include "Frame.h"
35 #include "FrameLoader.h"
36 #include "InspectorAgent.h"
37 #include "InspectorFrontend.h"
38 #include "InspectorPageAgent.h"
39 #include "InspectorValues.h"
40 #include "InstrumentingAgents.h"
41 #include "NetworkStateNotifier.h"
42 #include "Page.h"
43 #include "ResourceResponse.h"
44
45 namespace WebCore {
46
47 InspectorApplicationCacheAgent::InspectorApplicationCacheAgent(InstrumentingAgents* instrumentingAgents, InspectorPageAgent* pageAgent)
48     : InspectorBaseAgent(ASCIILiteral("ApplicationCache"), instrumentingAgents)
49     , m_pageAgent(pageAgent)
50 {
51 }
52
53 void InspectorApplicationCacheAgent::didCreateFrontendAndBackend(InspectorFrontendChannel* frontendChannel, InspectorBackendDispatcher* backendDispatcher)
54 {
55     m_frontendDispatcher = std::make_unique<InspectorApplicationCacheFrontendDispatcher>(frontendChannel);
56     m_backendDispatcher = InspectorApplicationCacheBackendDispatcher::create(backendDispatcher, this);
57 }
58
59 void InspectorApplicationCacheAgent::willDestroyFrontendAndBackend()
60 {
61     m_frontendDispatcher = nullptr;
62     m_backendDispatcher.clear();
63
64     m_instrumentingAgents->setInspectorApplicationCacheAgent(0);
65 }
66
67 void InspectorApplicationCacheAgent::enable(ErrorString*)
68 {
69     m_instrumentingAgents->setInspectorApplicationCacheAgent(this);
70
71     // We need to pass initial navigator.onOnline.
72     networkStateChanged();
73 }
74
75 void InspectorApplicationCacheAgent::updateApplicationCacheStatus(Frame* frame)
76 {
77     DocumentLoader* documentLoader = frame->loader().documentLoader();
78     if (!documentLoader)
79         return;
80
81     ApplicationCacheHost* host = documentLoader->applicationCacheHost();
82     ApplicationCacheHost::Status status = host->status();
83     ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo();
84
85     String manifestURL = info.m_manifest.string();
86     m_frontendDispatcher->applicationCacheStatusUpdated(m_pageAgent->frameId(frame), manifestURL, static_cast<int>(status));
87 }
88
89 void InspectorApplicationCacheAgent::networkStateChanged()
90 {
91     bool isNowOnline = networkStateNotifier().onLine();
92     m_frontendDispatcher->networkStateUpdated(isNowOnline);
93 }
94
95 void InspectorApplicationCacheAgent::getFramesWithManifests(ErrorString*, RefPtr<TypeBuilder::Array<TypeBuilder::ApplicationCache::FrameWithManifest>>& result)
96 {
97     result = TypeBuilder::Array<TypeBuilder::ApplicationCache::FrameWithManifest>::create();
98
99     Frame* mainFrame = m_pageAgent->mainFrame();
100     for (Frame* frame = mainFrame; frame; frame = frame->tree().traverseNext(mainFrame)) {
101         DocumentLoader* documentLoader = frame->loader().documentLoader();
102         if (!documentLoader)
103             continue;
104
105         ApplicationCacheHost* host = documentLoader->applicationCacheHost();
106         ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo();
107         String manifestURL = info.m_manifest.string();
108         if (!manifestURL.isEmpty()) {
109             RefPtr<TypeBuilder::ApplicationCache::FrameWithManifest> value = TypeBuilder::ApplicationCache::FrameWithManifest::create()
110                 .setFrameId(m_pageAgent->frameId(frame))
111                 .setManifestURL(manifestURL)
112                 .setStatus(static_cast<int>(host->status()));
113             result->addItem(value);
114         }
115     }
116 }
117
118 DocumentLoader* InspectorApplicationCacheAgent::assertFrameWithDocumentLoader(ErrorString* errorString, String frameId)
119 {
120     Frame* frame = m_pageAgent->assertFrame(errorString, frameId);
121     if (!frame)
122         return 0;
123
124     return InspectorPageAgent::assertDocumentLoader(errorString, frame);
125 }
126
127 void InspectorApplicationCacheAgent::getManifestForFrame(ErrorString* errorString, const String& frameId, String* manifestURL)
128 {
129     DocumentLoader* documentLoader = assertFrameWithDocumentLoader(errorString, frameId);
130     if (!documentLoader)
131         return;
132
133     ApplicationCacheHost::CacheInfo info = documentLoader->applicationCacheHost()->applicationCacheInfo();
134     *manifestURL = info.m_manifest.string();
135 }
136
137 void InspectorApplicationCacheAgent::getApplicationCacheForFrame(ErrorString* errorString, const String& frameId, RefPtr<TypeBuilder::ApplicationCache::ApplicationCache>& applicationCache)
138 {
139     DocumentLoader* documentLoader = assertFrameWithDocumentLoader(errorString, frameId);
140     if (!documentLoader)
141         return;
142
143     ApplicationCacheHost* host = documentLoader->applicationCacheHost();
144     ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo();
145
146     ApplicationCacheHost::ResourceInfoList resources;
147     host->fillResourceList(&resources);
148
149     applicationCache = buildObjectForApplicationCache(resources, info);
150 }
151
152 PassRefPtr<TypeBuilder::ApplicationCache::ApplicationCache> InspectorApplicationCacheAgent::buildObjectForApplicationCache(const ApplicationCacheHost::ResourceInfoList& applicationCacheResources, const ApplicationCacheHost::CacheInfo& applicationCacheInfo)
153 {
154     return TypeBuilder::ApplicationCache::ApplicationCache::create()
155         .setManifestURL(applicationCacheInfo.m_manifest.string())
156         .setSize(applicationCacheInfo.m_size)
157         .setCreationTime(applicationCacheInfo.m_creationTime)
158         .setUpdateTime(applicationCacheInfo.m_updateTime)
159         .setResources(buildArrayForApplicationCacheResources(applicationCacheResources))
160         .release();
161 }
162
163 PassRefPtr<TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource>> InspectorApplicationCacheAgent::buildArrayForApplicationCacheResources(const ApplicationCacheHost::ResourceInfoList& applicationCacheResources)
164 {
165     RefPtr<TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource>> resources = TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource>::create();
166
167     ApplicationCacheHost::ResourceInfoList::const_iterator end = applicationCacheResources.end();
168     ApplicationCacheHost::ResourceInfoList::const_iterator it = applicationCacheResources.begin();
169     for (int i = 0; it != end; ++it, i++)
170         resources->addItem(buildObjectForApplicationCacheResource(*it));
171
172     return resources;
173 }
174
175 PassRefPtr<TypeBuilder::ApplicationCache::ApplicationCacheResource> InspectorApplicationCacheAgent::buildObjectForApplicationCacheResource(const ApplicationCacheHost::ResourceInfo& resourceInfo)
176 {
177     String types;
178     if (resourceInfo.m_isMaster)
179         types.append("Master ");
180
181     if (resourceInfo.m_isManifest)
182         types.append("Manifest ");
183
184     if (resourceInfo.m_isFallback)
185         types.append("Fallback ");
186
187     if (resourceInfo.m_isForeign)
188         types.append("Foreign ");
189
190     if (resourceInfo.m_isExplicit)
191         types.append("Explicit ");
192
193     RefPtr<TypeBuilder::ApplicationCache::ApplicationCacheResource> value = TypeBuilder::ApplicationCache::ApplicationCacheResource::create()
194         .setUrl(resourceInfo.m_resource.string())
195         .setSize(static_cast<int>(resourceInfo.m_size))
196         .setType(types);
197     return value;
198 }
199
200 } // namespace WebCore
201
202 #endif // ENABLE(INSPECTOR)