The Tor Browser / file comparison

comparison: uriloader/prefetch/OfflineCacheUpdateChild.cpp

uriloader/prefetch/OfflineCacheUpdateChild.cpp

branch
TOR_BUG_3246
changeset 4
fc2d59ddac77
equal deleted inserted replaced
-1:000000000000 0:dce78b23a3a5
1 /* -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "OfflineCacheUpdateChild.h"
7 #include "nsOfflineCacheUpdate.h"
8 #include "mozilla/dom/ContentChild.h"
9 #include "mozilla/dom/TabChild.h"
10 #include "mozilla/ipc/URIUtils.h"
11 #include "mozilla/net/NeckoCommon.h"
12
13 #include "nsIApplicationCacheContainer.h"
14 #include "nsIApplicationCacheChannel.h"
15 #include "nsIApplicationCacheService.h"
16 #include "nsIDocShell.h"
17 #include "nsIDocShellTreeItem.h"
18 #include "nsIDocShellTreeOwner.h"
19 #include "nsIDOMWindow.h"
20 #include "nsIDOMOfflineResourceList.h"
21 #include "nsIDocument.h"
22 #include "nsIObserverService.h"
23 #include "nsIURL.h"
24 #include "nsITabChild.h"
25 #include "nsNetCID.h"
26 #include "nsNetUtil.h"
27 #include "nsServiceManagerUtils.h"
28 #include "nsStreamUtils.h"
29 #include "nsThreadUtils.h"
30 #include "nsProxyRelease.h"
31 #include "prlog.h"
32 #include "nsIAsyncVerifyRedirectCallback.h"
33
34 using namespace mozilla::ipc;
35 using namespace mozilla::net;
36 using mozilla::dom::TabChild;
37
38 #if defined(PR_LOGGING)
39 //
40 // To enable logging (see prlog.h for full details):
41 //
42 // set NSPR_LOG_MODULES=nsOfflineCacheUpdate:5
43 // set NSPR_LOG_FILE=offlineupdate.log
44 //
45 // this enables PR_LOG_ALWAYS level information and places all output in
46 // the file offlineupdate.log
47 //
48 extern PRLogModuleInfo *gOfflineCacheUpdateLog;
49 #endif
50
51 #undef LOG
52 #define LOG(args) PR_LOG(gOfflineCacheUpdateLog, 4, args)
53
54 #undef LOG_ENABLED
55 #define LOG_ENABLED() PR_LOG_TEST(gOfflineCacheUpdateLog, 4)
56
57 namespace mozilla {
58 namespace docshell {
59
60 //-----------------------------------------------------------------------------
61 // OfflineCacheUpdateChild::nsISupports
62 //-----------------------------------------------------------------------------
63
64 NS_INTERFACE_MAP_BEGIN(OfflineCacheUpdateChild)
65 NS_INTERFACE_MAP_ENTRY(nsISupports)
66 NS_INTERFACE_MAP_ENTRY(nsIOfflineCacheUpdate)
67 NS_INTERFACE_MAP_END
68
69 NS_IMPL_ADDREF(OfflineCacheUpdateChild)
70 NS_IMPL_RELEASE(OfflineCacheUpdateChild)
71
72 //-----------------------------------------------------------------------------
73 // OfflineCacheUpdateChild <public>
74 //-----------------------------------------------------------------------------
75
76 OfflineCacheUpdateChild::OfflineCacheUpdateChild(nsIDOMWindow* aWindow)
77 : mState(STATE_UNINITIALIZED)
78 , mIsUpgrade(false)
79 , mAppID(NECKO_NO_APP_ID)
80 , mInBrowser(false)
81 , mWindow(aWindow)
82 , mByteProgress(0)
83 {
84 }
85
86 OfflineCacheUpdateChild::~OfflineCacheUpdateChild()
87 {
88 LOG(("OfflineCacheUpdateChild::~OfflineCacheUpdateChild [%p]", this));
89 }
90
91 void
92 OfflineCacheUpdateChild::GatherObservers(nsCOMArray<nsIOfflineCacheUpdateObserver> &aObservers)
93 {
94 for (int32_t i = 0; i < mWeakObservers.Count(); i++) {
95 nsCOMPtr<nsIOfflineCacheUpdateObserver> observer =
96 do_QueryReferent(mWeakObservers[i]);
97 if (observer)
98 aObservers.AppendObject(observer);
99 else
100 mWeakObservers.RemoveObjectAt(i--);
101 }
102
103 for (int32_t i = 0; i < mObservers.Count(); i++) {
104 aObservers.AppendObject(mObservers[i]);
105 }
106 }
107
108 void
109 OfflineCacheUpdateChild::SetDocument(nsIDOMDocument *aDocument)
110 {
111 // The design is one document for one cache update on the content process.
112 NS_ASSERTION(!mDocument, "Setting more then a single document on a child offline cache update");
113
114 LOG(("Document %p added to update child %p", aDocument, this));
115
116 // Add document only if it was not loaded from an offline cache.
117 // If it were loaded from an offline cache then it has already
118 // been associated with it and must not be again cached as
119 // implicit (which are the reasons we collect documents here).
120 nsCOMPtr<nsIDocument> document = do_QueryInterface(aDocument);
121 if (!document)
122 return;
123
124 nsIChannel* channel = document->GetChannel();
125 nsCOMPtr<nsIApplicationCacheChannel> appCacheChannel =
126 do_QueryInterface(channel);
127 if (!appCacheChannel)
128 return;
129
130 bool loadedFromAppCache;
131 appCacheChannel->GetLoadedFromApplicationCache(&loadedFromAppCache);
132 if (loadedFromAppCache)
133 return;
134
135 mDocument = aDocument;
136 }
137
138 nsresult
139 OfflineCacheUpdateChild::AssociateDocument(nsIDOMDocument *aDocument,
140 nsIApplicationCache *aApplicationCache)
141 {
142 // Check that the document that requested this update was
143 // previously associated with an application cache. If not, it
144 // should be associated with the new one.
145 nsCOMPtr<nsIApplicationCacheContainer> container =
146 do_QueryInterface(aDocument);
147 if (!container)
148 return NS_OK;
149
150 nsCOMPtr<nsIApplicationCache> existingCache;
151 nsresult rv = container->GetApplicationCache(getter_AddRefs(existingCache));
152 NS_ENSURE_SUCCESS(rv, rv);
153
154 if (!existingCache) {
155 #if defined(PR_LOGGING)
156 if (LOG_ENABLED()) {
157 nsAutoCString clientID;
158 if (aApplicationCache) {
159 aApplicationCache->GetClientID(clientID);
160 }
161 LOG(("Update %p: associating app cache %s to document %p",
162 this, clientID.get(), aDocument));
163 }
164 #endif
165
166 rv = container->SetApplicationCache(aApplicationCache);
167 NS_ENSURE_SUCCESS(rv, rv);
168 }
169
170 return NS_OK;
171 }
172
173 //-----------------------------------------------------------------------------
174 // OfflineCacheUpdateChild::nsIOfflineCacheUpdate
175 //-----------------------------------------------------------------------------
176
177 NS_IMETHODIMP
178 OfflineCacheUpdateChild::Init(nsIURI *aManifestURI,
179 nsIURI *aDocumentURI,
180 nsIDOMDocument *aDocument,
181 nsIFile *aCustomProfileDir,
182 uint32_t aAppID,
183 bool aInBrowser)
184 {
185 nsresult rv;
186
187 // Make sure the service has been initialized
188 nsOfflineCacheUpdateService* service =
189 nsOfflineCacheUpdateService::EnsureService();
190 if (!service)
191 return NS_ERROR_FAILURE;
192
193 if (aCustomProfileDir) {
194 NS_ERROR("Custom Offline Cache Update not supported on child process");
195 return NS_ERROR_NOT_IMPLEMENTED;
196 }
197
198 LOG(("OfflineCacheUpdateChild::Init [%p]", this));
199
200 // Only http and https applications are supported.
201 bool match;
202 rv = aManifestURI->SchemeIs("http", &match);
203 NS_ENSURE_SUCCESS(rv, rv);
204
205 if (!match) {
206 rv = aManifestURI->SchemeIs("https", &match);
207 NS_ENSURE_SUCCESS(rv, rv);
208 if (!match)
209 return NS_ERROR_ABORT;
210 }
211
212 mManifestURI = aManifestURI;
213
214 rv = mManifestURI->GetAsciiHost(mUpdateDomain);
215 NS_ENSURE_SUCCESS(rv, rv);
216
217 mDocumentURI = aDocumentURI;
218
219 mState = STATE_INITIALIZED;
220
221 if (aDocument)
222 SetDocument(aDocument);
223
224 mAppID = aAppID;
225 mInBrowser = aInBrowser;
226
227 return NS_OK;
228 }
229
230 NS_IMETHODIMP
231 OfflineCacheUpdateChild::InitPartial(nsIURI *aManifestURI,
232 const nsACString& clientID,
233 nsIURI *aDocumentURI)
234 {
235 NS_NOTREACHED("Not expected to do partial offline cache updates"
236 " on the child process");
237 // For now leaving this method, we may discover we need it.
238 return NS_ERROR_NOT_IMPLEMENTED;
239 }
240
241 NS_IMETHODIMP
242 OfflineCacheUpdateChild::InitForUpdateCheck(nsIURI *aManifestURI,
243 uint32_t aAppID,
244 bool aInBrowser,
245 nsIObserver *aObserver)
246 {
247 NS_NOTREACHED("Not expected to do only update checks"
248 " from the child process");
249 return NS_ERROR_NOT_IMPLEMENTED;
250 }
251
252 NS_IMETHODIMP
253 OfflineCacheUpdateChild::GetUpdateDomain(nsACString &aUpdateDomain)
254 {
255 NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
256
257 aUpdateDomain = mUpdateDomain;
258 return NS_OK;
259 }
260
261 NS_IMETHODIMP
262 OfflineCacheUpdateChild::GetStatus(uint16_t *aStatus)
263 {
264 switch (mState) {
265 case STATE_CHECKING :
266 *aStatus = nsIDOMOfflineResourceList::CHECKING;
267 return NS_OK;
268 case STATE_DOWNLOADING :
269 *aStatus = nsIDOMOfflineResourceList::DOWNLOADING;
270 return NS_OK;
271 default :
272 *aStatus = nsIDOMOfflineResourceList::IDLE;
273 return NS_OK;
274 }
275
276 return NS_ERROR_FAILURE;
277 }
278
279 NS_IMETHODIMP
280 OfflineCacheUpdateChild::GetPartial(bool *aPartial)
281 {
282 *aPartial = false;
283 return NS_OK;
284 }
285
286 NS_IMETHODIMP
287 OfflineCacheUpdateChild::GetManifestURI(nsIURI **aManifestURI)
288 {
289 NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
290
291 NS_IF_ADDREF(*aManifestURI = mManifestURI);
292 return NS_OK;
293 }
294
295 NS_IMETHODIMP
296 OfflineCacheUpdateChild::GetSucceeded(bool *aSucceeded)
297 {
298 NS_ENSURE_TRUE(mState == STATE_FINISHED, NS_ERROR_NOT_AVAILABLE);
299
300 *aSucceeded = mSucceeded;
301
302 return NS_OK;
303 }
304
305 NS_IMETHODIMP
306 OfflineCacheUpdateChild::GetIsUpgrade(bool *aIsUpgrade)
307 {
308 NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
309
310 *aIsUpgrade = mIsUpgrade;
311
312 return NS_OK;
313 }
314
315 NS_IMETHODIMP
316 OfflineCacheUpdateChild::AddDynamicURI(nsIURI *aURI)
317 {
318 return NS_ERROR_NOT_IMPLEMENTED;
319 }
320
321 NS_IMETHODIMP
322 OfflineCacheUpdateChild::Cancel()
323 {
324 return NS_ERROR_NOT_IMPLEMENTED;
325 }
326
327 NS_IMETHODIMP
328 OfflineCacheUpdateChild::AddObserver(nsIOfflineCacheUpdateObserver *aObserver,
329 bool aHoldWeak)
330 {
331 LOG(("OfflineCacheUpdateChild::AddObserver [%p]", this));
332
333 NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
334
335 if (aHoldWeak) {
336 nsCOMPtr<nsIWeakReference> weakRef = do_GetWeakReference(aObserver);
337 mWeakObservers.AppendObject(weakRef);
338 } else {
339 mObservers.AppendObject(aObserver);
340 }
341
342 return NS_OK;
343 }
344
345 NS_IMETHODIMP
346 OfflineCacheUpdateChild::RemoveObserver(nsIOfflineCacheUpdateObserver *aObserver)
347 {
348 LOG(("OfflineCacheUpdateChild::RemoveObserver [%p]", this));
349
350 NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
351
352 for (int32_t i = 0; i < mWeakObservers.Count(); i++) {
353 nsCOMPtr<nsIOfflineCacheUpdateObserver> observer =
354 do_QueryReferent(mWeakObservers[i]);
355 if (observer == aObserver) {
356 mWeakObservers.RemoveObjectAt(i);
357 return NS_OK;
358 }
359 }
360
361 for (int32_t i = 0; i < mObservers.Count(); i++) {
362 if (mObservers[i] == aObserver) {
363 mObservers.RemoveObjectAt(i);
364 return NS_OK;
365 }
366 }
367
368 return NS_OK;
369 }
370
371 NS_IMETHODIMP
372 OfflineCacheUpdateChild::GetByteProgress(uint64_t * _result)
373 {
374 NS_ENSURE_ARG(_result);
375
376 *_result = mByteProgress;
377 return NS_OK;
378 }
379
380 NS_IMETHODIMP
381 OfflineCacheUpdateChild::Schedule()
382 {
383 LOG(("OfflineCacheUpdateChild::Schedule [%p]", this));
384
385 NS_ASSERTION(mWindow, "Window must be provided to the offline cache update child");
386
387 nsCOMPtr<nsPIDOMWindow> piWindow =
388 do_QueryInterface(mWindow);
389 mWindow = nullptr;
390
391 nsIDocShell *docshell = piWindow->GetDocShell();
392
393 nsCOMPtr<nsIDocShellTreeItem> item = do_QueryInterface(docshell);
394 if (!item) {
395 NS_WARNING("doc shell tree item is null");
396 return NS_ERROR_FAILURE;
397 }
398
399 nsCOMPtr<nsIDocShellTreeOwner> owner;
400 item->GetTreeOwner(getter_AddRefs(owner));
401
402 nsCOMPtr<nsITabChild> tabchild = do_GetInterface(owner);
403 // because owner implements nsITabChild, we can assume that it is
404 // the one and only TabChild.
405 TabChild* child = tabchild ? static_cast<TabChild*>(tabchild.get()) : nullptr;
406
407 if (MissingRequiredTabChild(child, "offlinecacheupdate")) {
408 return NS_ERROR_FAILURE;
409 }
410
411 URIParams manifestURI, documentURI;
412 SerializeURI(mManifestURI, manifestURI);
413 SerializeURI(mDocumentURI, documentURI);
414
415 nsCOMPtr<nsIObserverService> observerService =
416 mozilla::services::GetObserverService();
417 if (observerService) {
418 LOG(("Calling offline-cache-update-added"));
419 observerService->NotifyObservers(static_cast<nsIOfflineCacheUpdate*>(this),
420 "offline-cache-update-added",
421 nullptr);
422 LOG(("Done offline-cache-update-added"));
423 }
424
425 // mDocument is non-null if both:
426 // 1. this update was initiated by a document that referred a manifest
427 // 2. the document has not already been loaded from the application cache
428 // This tells the update to cache this document even in case the manifest
429 // has not been changed since the last fetch.
430 // See also nsOfflineCacheUpdate::ScheduleImplicit.
431 bool stickDocument = mDocument != nullptr;
432
433 // Need to addref ourself here, because the IPC stack doesn't hold
434 // a reference to us. Will be released in RecvFinish() that identifies
435 // the work has been done.
436 child->SendPOfflineCacheUpdateConstructor(this, manifestURI, documentURI,
437 stickDocument);
438
439 // TabChild::DeallocPOfflineCacheUpdate will release this.
440 NS_ADDREF_THIS();
441
442 return NS_OK;
443 }
444
445 bool
446 OfflineCacheUpdateChild::RecvAssociateDocuments(const nsCString &cacheGroupId,
447 const nsCString &cacheClientId)
448 {
449 LOG(("OfflineCacheUpdateChild::RecvAssociateDocuments [%p, cache=%s]", this, cacheClientId.get()));
450
451 nsresult rv;
452
453 nsCOMPtr<nsIApplicationCache> cache =
454 do_CreateInstance(NS_APPLICATIONCACHE_CONTRACTID, &rv);
455 if (NS_FAILED(rv))
456 return true;
457
458 cache->InitAsHandle(cacheGroupId, cacheClientId);
459
460 if (mDocument) {
461 AssociateDocument(mDocument, cache);
462 }
463
464 nsCOMArray<nsIOfflineCacheUpdateObserver> observers;
465 GatherObservers(observers);
466
467 for (int32_t i = 0; i < observers.Count(); i++)
468 observers[i]->ApplicationCacheAvailable(cache);
469
470 return true;
471 }
472
473 bool
474 OfflineCacheUpdateChild::RecvNotifyStateEvent(const uint32_t &event,
475 const uint64_t &byteProgress)
476 {
477 LOG(("OfflineCacheUpdateChild::RecvNotifyStateEvent [%p]", this));
478
479 mByteProgress = byteProgress;
480
481 // Convert the public observer state to our internal state
482 switch (event) {
483 case nsIOfflineCacheUpdateObserver::STATE_CHECKING:
484 mState = STATE_CHECKING;
485 break;
486
487 case nsIOfflineCacheUpdateObserver::STATE_DOWNLOADING:
488 mState = STATE_DOWNLOADING;
489 break;
490
491 default:
492 break;
493 }
494
495 nsCOMArray<nsIOfflineCacheUpdateObserver> observers;
496 GatherObservers(observers);
497
498 for (int32_t i = 0; i < observers.Count(); i++)
499 observers[i]->UpdateStateChanged(this, event);
500
501 return true;
502 }
503
504 bool
505 OfflineCacheUpdateChild::RecvFinish(const bool &succeeded,
506 const bool &isUpgrade)
507 {
508 LOG(("OfflineCacheUpdateChild::RecvFinish [%p]", this));
509
510 nsRefPtr<OfflineCacheUpdateChild> kungFuDeathGrip(this);
511
512 mState = STATE_FINISHED;
513 mSucceeded = succeeded;
514 mIsUpgrade = isUpgrade;
515
516 nsCOMPtr<nsIObserverService> observerService =
517 mozilla::services::GetObserverService();
518 if (observerService) {
519 LOG(("Calling offline-cache-update-completed"));
520 observerService->NotifyObservers(static_cast<nsIOfflineCacheUpdate*>(this),
521 "offline-cache-update-completed",
522 nullptr);
523 LOG(("Done offline-cache-update-completed"));
524 }
525
526 // This is by contract the last notification from the parent, release
527 // us now. This is corresponding to AddRef in Schedule().
528 // TabChild::DeallocPOfflineCacheUpdate will call Release.
529 OfflineCacheUpdateChild::Send__delete__(this);
530
531 return true;
532 }
533
534 }
535 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial