Line data Source code
1 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 : * vim: set sw=2 sts=2 ts=2 et tw=80:
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 :
8 : #include "nsIconURI.h"
9 :
10 : #include "mozilla/ArrayUtils.h"
11 : #include "mozilla/ipc/URIUtils.h"
12 : #include "mozilla/Sprintf.h"
13 :
14 : #include "nsIIOService.h"
15 : #include "nsIURL.h"
16 : #include "nsNetUtil.h"
17 : #include "plstr.h"
18 : #include <stdlib.h>
19 :
20 : using namespace mozilla;
21 : using namespace mozilla::ipc;
22 :
23 : #define DEFAULT_IMAGE_SIZE 16
24 :
25 : #if defined(MAX_PATH)
26 : #define SANE_FILE_NAME_LEN MAX_PATH
27 : #elif defined(PATH_MAX)
28 : #define SANE_FILE_NAME_LEN PATH_MAX
29 : #else
30 : #define SANE_FILE_NAME_LEN 1024
31 : #endif
32 :
33 : // helper function for parsing out attributes like size, and contentType
34 : // from the icon url.
35 : static void extractAttributeValue(const char* aSearchString,
36 : const char* aAttributeName,
37 : nsCString& aResult);
38 :
39 : static const char* kSizeStrings[] =
40 : {
41 : "button",
42 : "toolbar",
43 : "toolbarsmall",
44 : "menu",
45 : "dnd",
46 : "dialog"
47 : };
48 :
49 : static const char* kStateStrings[] =
50 : {
51 : "normal",
52 : "disabled"
53 : };
54 :
55 : ////////////////////////////////////////////////////////////////////////////////
56 :
57 3 : nsMozIconURI::nsMozIconURI()
58 : : mSize(DEFAULT_IMAGE_SIZE),
59 : mIconSize(-1),
60 3 : mIconState(-1)
61 3 : { }
62 :
63 0 : nsMozIconURI::~nsMozIconURI()
64 0 : { }
65 :
66 45 : NS_IMPL_ISUPPORTS(nsMozIconURI, nsIMozIconURI, nsIURI, nsIIPCSerializableURI)
67 :
68 : #define MOZICON_SCHEME "moz-icon:"
69 : #define MOZICON_SCHEME_LEN (sizeof(MOZICON_SCHEME) - 1)
70 :
71 : ////////////////////////////////////////////////////////////////////////////////
72 : // nsIURI methods:
73 :
74 : NS_IMETHODIMP
75 3 : nsMozIconURI::GetSpec(nsACString& aSpec)
76 : {
77 3 : aSpec = MOZICON_SCHEME;
78 :
79 3 : if (mIconURL) {
80 0 : nsAutoCString fileIconSpec;
81 0 : nsresult rv = mIconURL->GetSpec(fileIconSpec);
82 0 : NS_ENSURE_SUCCESS(rv, rv);
83 0 : aSpec += fileIconSpec;
84 3 : } else if (!mStockIcon.IsEmpty()) {
85 3 : aSpec += "//stock/";
86 3 : aSpec += mStockIcon;
87 : } else {
88 0 : aSpec += "//";
89 0 : aSpec += mFileName;
90 : }
91 :
92 3 : aSpec += "?size=";
93 3 : if (mIconSize >= 0) {
94 3 : aSpec += kSizeStrings[mIconSize];
95 : } else {
96 : char buf[20];
97 0 : SprintfLiteral(buf, "%d", mSize);
98 0 : aSpec.Append(buf);
99 : }
100 :
101 3 : if (mIconState >= 0) {
102 0 : aSpec += "&state=";
103 0 : aSpec += kStateStrings[mIconState];
104 : }
105 :
106 3 : if (!mContentType.IsEmpty()) {
107 0 : aSpec += "&contentType=";
108 0 : aSpec += mContentType.get();
109 : }
110 :
111 3 : return NS_OK;
112 : }
113 :
114 : NS_IMETHODIMP
115 0 : nsMozIconURI::GetSpecIgnoringRef(nsACString& result)
116 : {
117 0 : return GetSpec(result);
118 : }
119 :
120 : NS_IMETHODIMP
121 0 : nsMozIconURI::GetDisplaySpec(nsACString& aUnicodeSpec)
122 : {
123 0 : return GetSpec(aUnicodeSpec);
124 : }
125 :
126 : NS_IMETHODIMP
127 0 : nsMozIconURI::GetDisplayHostPort(nsACString& aUnicodeHostPort)
128 : {
129 0 : return GetHostPort(aUnicodeHostPort);
130 : }
131 :
132 : NS_IMETHODIMP
133 0 : nsMozIconURI::GetDisplayHost(nsACString& aUnicodeHost)
134 : {
135 0 : return GetHost(aUnicodeHost);
136 : }
137 :
138 : NS_IMETHODIMP
139 0 : nsMozIconURI::GetHasRef(bool* result)
140 : {
141 0 : *result = false;
142 0 : return NS_OK;
143 : }
144 :
145 : // takes a string like ?size=32&contentType=text/html and returns a new string
146 : // containing just the attribute value. i.e you could pass in this string with
147 : // an attribute name of 'size=', this will return 32
148 : // Assumption: attribute pairs in the string are separated by '&'.
149 : void
150 9 : extractAttributeValue(const char* aSearchString,
151 : const char* aAttributeName,
152 : nsCString& aResult)
153 : {
154 : //NS_ENSURE_ARG_POINTER(extractAttributeValue);
155 :
156 9 : aResult.Truncate();
157 :
158 9 : if (aSearchString && aAttributeName) {
159 : // search the string for attributeName
160 9 : uint32_t attributeNameSize = strlen(aAttributeName);
161 9 : const char* startOfAttribute = PL_strcasestr(aSearchString, aAttributeName);
162 12 : if (startOfAttribute &&
163 3 : ( *(startOfAttribute-1) == '?' || *(startOfAttribute-1) == '&') ) {
164 3 : startOfAttribute += attributeNameSize; // skip over the attributeName
165 : // is there something after the attribute name
166 3 : if (*startOfAttribute) {
167 3 : const char* endofAttribute = strchr(startOfAttribute, '&');
168 3 : if (endofAttribute) {
169 0 : aResult.Assign(Substring(startOfAttribute, endofAttribute));
170 : } else {
171 3 : aResult.Assign(startOfAttribute);
172 : }
173 : } // if we have a attribute value
174 : } // if we have a attribute name
175 : } // if we got non-null search string and attribute name values
176 9 : }
177 :
178 : NS_IMETHODIMP
179 3 : nsMozIconURI::SetSpec(const nsACString& aSpec)
180 : {
181 : // Reset everything to default values.
182 3 : mIconURL = nullptr;
183 3 : mSize = DEFAULT_IMAGE_SIZE;
184 3 : mContentType.Truncate();
185 3 : mFileName.Truncate();
186 3 : mStockIcon.Truncate();
187 3 : mIconSize = -1;
188 3 : mIconState = -1;
189 :
190 6 : nsAutoCString iconSpec(aSpec);
191 6 : if (!Substring(iconSpec, 0,
192 3 : MOZICON_SCHEME_LEN).EqualsLiteral(MOZICON_SCHEME)) {
193 0 : return NS_ERROR_MALFORMED_URI;
194 : }
195 :
196 3 : int32_t questionMarkPos = iconSpec.Find("?");
197 6 : if (questionMarkPos != -1 &&
198 3 : static_cast<int32_t>(iconSpec.Length()) > (questionMarkPos + 1)) {
199 3 : extractAttributeValue(iconSpec.get(), "contentType=", mContentType);
200 :
201 6 : nsAutoCString sizeString;
202 3 : extractAttributeValue(iconSpec.get(), "size=", sizeString);
203 3 : if (!sizeString.IsEmpty()) {
204 3 : const char* sizeStr = sizeString.get();
205 12 : for (uint32_t i = 0; i < ArrayLength(kSizeStrings); i++) {
206 12 : if (PL_strcasecmp(sizeStr, kSizeStrings[i]) == 0) {
207 3 : mIconSize = i;
208 3 : break;
209 : }
210 : }
211 :
212 3 : int32_t sizeValue = atoi(sizeString.get());
213 3 : if (sizeValue > 0) {
214 0 : mSize = sizeValue;
215 : }
216 : }
217 :
218 6 : nsAutoCString stateString;
219 3 : extractAttributeValue(iconSpec.get(), "state=", stateString);
220 3 : if (!stateString.IsEmpty()) {
221 0 : const char* stateStr = stateString.get();
222 0 : for (uint32_t i = 0; i < ArrayLength(kStateStrings); i++) {
223 0 : if (PL_strcasecmp(stateStr, kStateStrings[i]) == 0) {
224 0 : mIconState = i;
225 0 : break;
226 : }
227 : }
228 : }
229 : }
230 :
231 3 : int32_t pathLength = iconSpec.Length() - MOZICON_SCHEME_LEN;
232 3 : if (questionMarkPos != -1) {
233 3 : pathLength = questionMarkPos - MOZICON_SCHEME_LEN;
234 : }
235 3 : if (pathLength < 3) {
236 0 : return NS_ERROR_MALFORMED_URI;
237 : }
238 :
239 6 : nsAutoCString iconPath(Substring(iconSpec, MOZICON_SCHEME_LEN, pathLength));
240 :
241 : // Icon URI path can have three forms:
242 : // (1) //stock/<icon-identifier>
243 : // (2) //<some dummy file with an extension>
244 : // (3) a valid URL
245 :
246 3 : if (!strncmp("//stock/", iconPath.get(), 8)) {
247 3 : mStockIcon.Assign(Substring(iconPath, 8));
248 : // An icon identifier must always be specified.
249 3 : if (mStockIcon.IsEmpty()) {
250 0 : return NS_ERROR_MALFORMED_URI;
251 : }
252 3 : return NS_OK;
253 : }
254 :
255 0 : if (StringBeginsWith(iconPath, NS_LITERAL_CSTRING("//"))) {
256 : // Sanity check this supposed dummy file name.
257 0 : if (iconPath.Length() > SANE_FILE_NAME_LEN) {
258 0 : return NS_ERROR_MALFORMED_URI;
259 : }
260 0 : iconPath.Cut(0, 2);
261 0 : mFileName.Assign(iconPath);
262 : }
263 :
264 : nsresult rv;
265 0 : nsCOMPtr<nsIIOService> ioService(do_GetService(NS_IOSERVICE_CONTRACTID, &rv));
266 0 : NS_ENSURE_SUCCESS(rv, rv);
267 :
268 0 : nsCOMPtr<nsIURI> uri;
269 0 : ioService->NewURI(iconPath, nullptr, nullptr, getter_AddRefs(uri));
270 0 : mIconURL = do_QueryInterface(uri);
271 0 : if (mIconURL) {
272 0 : mFileName.Truncate();
273 0 : } else if (mFileName.IsEmpty()) {
274 0 : return NS_ERROR_MALFORMED_URI;
275 : }
276 :
277 0 : return NS_OK;
278 : }
279 :
280 : NS_IMETHODIMP
281 0 : nsMozIconURI::GetPrePath(nsACString& prePath)
282 : {
283 0 : prePath = MOZICON_SCHEME;
284 0 : return NS_OK;
285 : }
286 :
287 : NS_IMETHODIMP
288 1 : nsMozIconURI::GetScheme(nsACString& aScheme)
289 : {
290 1 : aScheme = "moz-icon";
291 1 : return NS_OK;
292 : }
293 :
294 : NS_IMETHODIMP
295 0 : nsMozIconURI::SetScheme(const nsACString& aScheme)
296 : {
297 : // doesn't make sense to set the scheme of a moz-icon URL
298 0 : return NS_ERROR_FAILURE;
299 : }
300 :
301 : NS_IMETHODIMP
302 0 : nsMozIconURI::GetUsername(nsACString& aUsername)
303 : {
304 0 : return NS_ERROR_FAILURE;
305 : }
306 :
307 : NS_IMETHODIMP
308 0 : nsMozIconURI::SetUsername(const nsACString& aUsername)
309 : {
310 0 : return NS_ERROR_FAILURE;
311 : }
312 :
313 : NS_IMETHODIMP
314 0 : nsMozIconURI::GetPassword(nsACString& aPassword)
315 : {
316 0 : return NS_ERROR_FAILURE;
317 : }
318 :
319 : NS_IMETHODIMP
320 0 : nsMozIconURI::SetPassword(const nsACString& aPassword)
321 : {
322 0 : return NS_ERROR_FAILURE;
323 : }
324 :
325 : NS_IMETHODIMP
326 0 : nsMozIconURI::GetUserPass(nsACString& aUserPass)
327 : {
328 0 : return NS_ERROR_FAILURE;
329 : }
330 :
331 : NS_IMETHODIMP
332 0 : nsMozIconURI::SetUserPass(const nsACString& aUserPass)
333 : {
334 0 : return NS_ERROR_FAILURE;
335 : }
336 :
337 : NS_IMETHODIMP
338 0 : nsMozIconURI::GetHostPort(nsACString& aHostPort)
339 : {
340 0 : return NS_ERROR_FAILURE;
341 : }
342 :
343 : NS_IMETHODIMP
344 0 : nsMozIconURI::SetHostPort(const nsACString& aHostPort)
345 : {
346 0 : return NS_ERROR_FAILURE;
347 : }
348 :
349 : NS_IMETHODIMP
350 0 : nsMozIconURI::SetHostAndPort(const nsACString& aHostPort)
351 : {
352 0 : return NS_ERROR_FAILURE;
353 : }
354 :
355 : NS_IMETHODIMP
356 0 : nsMozIconURI::GetHost(nsACString& aHost)
357 : {
358 0 : return NS_ERROR_FAILURE;
359 : }
360 :
361 : NS_IMETHODIMP
362 0 : nsMozIconURI::SetHost(const nsACString& aHost)
363 : {
364 0 : return NS_ERROR_FAILURE;
365 : }
366 :
367 : NS_IMETHODIMP
368 0 : nsMozIconURI::GetPort(int32_t* aPort)
369 : {
370 0 : return NS_ERROR_FAILURE;
371 : }
372 :
373 : NS_IMETHODIMP
374 0 : nsMozIconURI::SetPort(int32_t aPort)
375 : {
376 0 : return NS_ERROR_FAILURE;
377 : }
378 :
379 : NS_IMETHODIMP
380 0 : nsMozIconURI::GetPath(nsACString& aPath)
381 : {
382 0 : aPath.Truncate();
383 0 : return NS_OK;
384 : }
385 :
386 : NS_IMETHODIMP
387 0 : nsMozIconURI::SetPath(const nsACString& aPath)
388 : {
389 0 : return NS_ERROR_FAILURE;
390 : }
391 :
392 : NS_IMETHODIMP
393 0 : nsMozIconURI::GetFilePath(nsACString& aFilePath)
394 : {
395 0 : aFilePath.Truncate();
396 0 : return NS_OK;
397 : }
398 :
399 : NS_IMETHODIMP
400 0 : nsMozIconURI::SetFilePath(const nsACString& aFilePath)
401 : {
402 0 : return NS_ERROR_FAILURE;
403 : }
404 :
405 : NS_IMETHODIMP
406 0 : nsMozIconURI::GetQuery(nsACString& aQuery)
407 : {
408 0 : aQuery.Truncate();
409 0 : return NS_OK;
410 : }
411 :
412 : NS_IMETHODIMP
413 0 : nsMozIconURI::SetQuery(const nsACString& aQuery)
414 : {
415 0 : return NS_ERROR_FAILURE;
416 : }
417 :
418 : NS_IMETHODIMP
419 0 : nsMozIconURI::GetRef(nsACString& aRef)
420 : {
421 0 : aRef.Truncate();
422 0 : return NS_OK;
423 : }
424 :
425 : NS_IMETHODIMP
426 0 : nsMozIconURI::SetRef(const nsACString& aRef)
427 : {
428 0 : return NS_ERROR_FAILURE;
429 : }
430 :
431 : NS_IMETHODIMP
432 0 : nsMozIconURI::Equals(nsIURI* other, bool* result)
433 : {
434 0 : *result = false;
435 0 : NS_ENSURE_ARG_POINTER(other);
436 0 : NS_PRECONDITION(result, "null pointer");
437 :
438 0 : nsAutoCString spec1;
439 0 : nsAutoCString spec2;
440 :
441 0 : nsresult rv = GetSpec(spec1);
442 0 : NS_ENSURE_SUCCESS(rv, rv);
443 0 : rv = other->GetSpec(spec2);
444 0 : NS_ENSURE_SUCCESS(rv, rv);
445 :
446 0 : if (!PL_strcasecmp(spec1.get(), spec2.get())) {
447 0 : *result = true;
448 : } else {
449 0 : *result = false;
450 : }
451 0 : return NS_OK;
452 : }
453 :
454 : NS_IMETHODIMP
455 0 : nsMozIconURI::EqualsExceptRef(nsIURI* other, bool* result)
456 : {
457 : // GetRef/SetRef not supported by nsMozIconURI, so
458 : // EqualsExceptRef() is the same as Equals().
459 0 : return Equals(other, result);
460 : }
461 :
462 : NS_IMETHODIMP
463 0 : nsMozIconURI::SchemeIs(const char* aScheme, bool* aEquals)
464 : {
465 0 : NS_ENSURE_ARG_POINTER(aEquals);
466 0 : if (!aScheme) {
467 0 : return NS_ERROR_INVALID_ARG;
468 : }
469 :
470 0 : *aEquals = PL_strcasecmp("moz-icon", aScheme) ? false : true;
471 0 : return NS_OK;
472 : }
473 :
474 : NS_IMETHODIMP
475 0 : nsMozIconURI::Clone(nsIURI** result)
476 : {
477 0 : nsCOMPtr<nsIURL> newIconURL;
478 0 : if (mIconURL) {
479 0 : nsCOMPtr<nsIURI> newURI;
480 0 : nsresult rv = mIconURL->Clone(getter_AddRefs(newURI));
481 0 : if (NS_FAILED(rv)) {
482 0 : return rv;
483 : }
484 0 : newIconURL = do_QueryInterface(newURI, &rv);
485 0 : if (NS_FAILED(rv)) {
486 0 : return rv;
487 : }
488 : }
489 :
490 0 : nsMozIconURI* uri = new nsMozIconURI();
491 0 : newIconURL.swap(uri->mIconURL);
492 0 : uri->mSize = mSize;
493 0 : uri->mContentType = mContentType;
494 0 : uri->mFileName = mFileName;
495 0 : uri->mStockIcon = mStockIcon;
496 0 : uri->mIconSize = mIconSize;
497 0 : uri->mIconState = mIconState;
498 0 : NS_ADDREF(*result = uri);
499 :
500 0 : return NS_OK;
501 : }
502 :
503 : NS_IMETHODIMP
504 0 : nsMozIconURI::CloneIgnoringRef(nsIURI** result)
505 : {
506 : // GetRef/SetRef not supported by nsMozIconURI, so
507 : // CloneIgnoringRef() is the same as Clone().
508 0 : return Clone(result);
509 : }
510 :
511 : NS_IMETHODIMP
512 0 : nsMozIconURI::CloneWithNewRef(const nsACString& newRef, nsIURI** result)
513 : {
514 : // GetRef/SetRef not supported by nsMozIconURI, so
515 : // CloneWithNewRef() is the same as Clone().
516 0 : return Clone(result);
517 : }
518 :
519 :
520 : NS_IMETHODIMP
521 0 : nsMozIconURI::Resolve(const nsACString& relativePath, nsACString& result)
522 : {
523 0 : return NS_ERROR_NOT_IMPLEMENTED;
524 : }
525 :
526 : NS_IMETHODIMP
527 0 : nsMozIconURI::GetAsciiSpec(nsACString& aSpecA)
528 : {
529 0 : return GetSpec(aSpecA);
530 : }
531 :
532 : NS_IMETHODIMP
533 0 : nsMozIconURI::GetAsciiHostPort(nsACString& aHostPortA)
534 : {
535 0 : return GetHostPort(aHostPortA);
536 : }
537 :
538 : NS_IMETHODIMP
539 0 : nsMozIconURI::GetAsciiHost(nsACString& aHostA)
540 : {
541 0 : return GetHost(aHostA);
542 : }
543 :
544 : NS_IMETHODIMP
545 3 : nsMozIconURI::GetOriginCharset(nsACString& result)
546 : {
547 3 : result.Truncate();
548 3 : return NS_OK;
549 : }
550 :
551 : ////////////////////////////////////////////////////////////////////////////////
552 : // nsIIconUri methods:
553 :
554 : NS_IMETHODIMP
555 3 : nsMozIconURI::GetIconURL(nsIURL** aFileUrl)
556 : {
557 3 : *aFileUrl = mIconURL;
558 3 : NS_IF_ADDREF(*aFileUrl);
559 3 : return NS_OK;
560 : }
561 :
562 : NS_IMETHODIMP
563 0 : nsMozIconURI::SetIconURL(nsIURL* aFileUrl)
564 : {
565 : // this isn't called anywhere, needs to go through SetSpec parsing
566 0 : return NS_ERROR_NOT_IMPLEMENTED;
567 : }
568 :
569 : NS_IMETHODIMP
570 0 : nsMozIconURI::GetImageSize(uint32_t* aImageSize)
571 : // measured by # of pixels in a row. defaults to 16.
572 : {
573 0 : *aImageSize = mSize;
574 0 : return NS_OK;
575 : }
576 :
577 : NS_IMETHODIMP
578 0 : nsMozIconURI::SetImageSize(uint32_t aImageSize)
579 : // measured by # of pixels in a row. defaults to 16.
580 : {
581 0 : mSize = aImageSize;
582 0 : return NS_OK;
583 : }
584 :
585 : NS_IMETHODIMP
586 0 : nsMozIconURI::GetContentType(nsACString& aContentType)
587 : {
588 0 : aContentType = mContentType;
589 0 : return NS_OK;
590 : }
591 :
592 : NS_IMETHODIMP
593 0 : nsMozIconURI::SetContentType(const nsACString& aContentType)
594 : {
595 0 : mContentType = aContentType;
596 0 : return NS_OK;
597 : }
598 :
599 : NS_IMETHODIMP
600 0 : nsMozIconURI::GetFileExtension(nsACString& aFileExtension)
601 : {
602 : // First, try to get the extension from mIconURL if we have one
603 0 : if (mIconURL) {
604 0 : nsAutoCString fileExt;
605 0 : if (NS_SUCCEEDED(mIconURL->GetFileExtension(fileExt))) {
606 0 : if (!fileExt.IsEmpty()) {
607 : // unfortunately, this code doesn't give us the required '.' in
608 : // front of the extension so we have to do it ourselves.
609 0 : aFileExtension.Assign('.');
610 0 : aFileExtension.Append(fileExt);
611 : }
612 : }
613 0 : return NS_OK;
614 : }
615 :
616 0 : if (!mFileName.IsEmpty()) {
617 : // truncate the extension out of the file path...
618 0 : const char* chFileName = mFileName.get(); // get the underlying buffer
619 0 : const char* fileExt = strrchr(chFileName, '.');
620 0 : if (!fileExt) {
621 0 : return NS_OK;
622 : }
623 0 : aFileExtension = fileExt;
624 : }
625 :
626 0 : return NS_OK;
627 : }
628 :
629 : NS_IMETHODIMP
630 0 : nsMozIconURI::GetStockIcon(nsACString& aStockIcon)
631 : {
632 0 : aStockIcon = mStockIcon;
633 0 : return NS_OK;
634 : }
635 :
636 : NS_IMETHODIMP
637 0 : nsMozIconURI::GetIconSize(nsACString& aSize)
638 : {
639 0 : if (mIconSize >= 0) {
640 0 : aSize = kSizeStrings[mIconSize];
641 : } else {
642 0 : aSize.Truncate();
643 : }
644 0 : return NS_OK;
645 : }
646 :
647 : NS_IMETHODIMP
648 0 : nsMozIconURI::GetIconState(nsACString& aState)
649 : {
650 0 : if (mIconState >= 0) {
651 0 : aState = kStateStrings[mIconState];
652 : } else {
653 0 : aState.Truncate();
654 : }
655 0 : return NS_OK;
656 : }
657 : ////////////////////////////////////////////////////////////////////////////////
658 : // nsIIPCSerializableURI methods:
659 :
660 : void
661 0 : nsMozIconURI::Serialize(URIParams& aParams)
662 : {
663 0 : IconURIParams params;
664 :
665 0 : if (mIconURL) {
666 0 : URIParams iconURLParams;
667 0 : SerializeURI(mIconURL, iconURLParams);
668 0 : if (iconURLParams.type() == URIParams::T__None) {
669 : // Serialization failed, bail.
670 0 : return;
671 : }
672 :
673 0 : params.uri() = iconURLParams;
674 : } else {
675 0 : params.uri() = void_t();
676 : }
677 :
678 0 : params.size() = mSize;
679 0 : params.fileName() = mFileName;
680 0 : params.stockIcon() = mStockIcon;
681 0 : params.iconSize() = mIconSize;
682 0 : params.iconState() = mIconState;
683 :
684 0 : aParams = params;
685 : }
686 :
687 : bool
688 0 : nsMozIconURI::Deserialize(const URIParams& aParams)
689 : {
690 0 : if (aParams.type() != URIParams::TIconURIParams) {
691 0 : MOZ_ASSERT_UNREACHABLE("Received unknown URI from other process!");
692 : return false;
693 : }
694 :
695 0 : const IconURIParams& params = aParams.get_IconURIParams();
696 0 : if (params.uri().type() != OptionalURIParams::Tvoid_t) {
697 0 : nsCOMPtr<nsIURI> uri = DeserializeURI(params.uri().get_URIParams());
698 0 : mIconURL = do_QueryInterface(uri);
699 0 : if (!mIconURL) {
700 0 : MOZ_ASSERT_UNREACHABLE("bad nsIURI passed");
701 : return false;
702 : }
703 : }
704 :
705 0 : mSize = params.size();
706 0 : mContentType = params.contentType();
707 0 : mFileName = params.fileName();
708 0 : mStockIcon = params.stockIcon();
709 0 : mIconSize = params.iconSize();
710 0 : mIconState = params.iconState();
711 :
712 0 : return true;
713 : }
714 :
715 : ////////////////////////////////////////////////////////////
716 : // Nested version of nsIconURI
717 :
718 0 : nsNestedMozIconURI::nsNestedMozIconURI()
719 0 : { }
720 :
721 0 : nsNestedMozIconURI::~nsNestedMozIconURI()
722 0 : { }
723 :
724 0 : NS_IMPL_ISUPPORTS_INHERITED(nsNestedMozIconURI, nsMozIconURI, nsINestedURI)
725 :
726 : NS_IMETHODIMP
727 0 : nsNestedMozIconURI::GetInnerURI(nsIURI** aURI)
728 : {
729 0 : nsCOMPtr<nsIURI> iconURL = do_QueryInterface(mIconURL);
730 0 : if (iconURL) {
731 0 : iconURL.forget(aURI);
732 : } else {
733 0 : *aURI = nullptr;
734 : }
735 0 : return NS_OK;
736 : }
737 :
738 : NS_IMETHODIMP
739 0 : nsNestedMozIconURI::GetInnermostURI(nsIURI** aURI)
740 : {
741 0 : return NS_ImplGetInnermostURI(this, aURI);
742 : }
743 :
|
