Line data Source code
1 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 : /* This Source Code Form is subject to the terms of the Mozilla Public
4 : * License, v. 2.0. If a copy of the MPL was not distributed with this
5 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 :
7 : // Local Includes
8 : #include "nsWebBrowser.h"
9 :
10 : // Helper Classes
11 : #include "nsGfxCIID.h"
12 : #include "nsWidgetsCID.h"
13 :
14 : #include "gfxUtils.h"
15 : #include "mozilla/gfx/2D.h"
16 :
17 : // Interfaces Needed
18 : #include "gfxContext.h"
19 : #include "nsReadableUtils.h"
20 : #include "nsIComponentManager.h"
21 : #include "nsIDOMDocument.h"
22 : #include "nsIDOMWindow.h"
23 : #include "nsIDOMElement.h"
24 : #include "nsIInterfaceRequestor.h"
25 : #include "nsIInterfaceRequestorUtils.h"
26 : #include "nsIWebBrowserChrome.h"
27 : #include "nsPIDOMWindow.h"
28 : #include "nsIWebProgress.h"
29 : #include "nsIWebProgressListener.h"
30 : #include "nsIWebBrowserFocus.h"
31 : #include "nsIWebBrowserStream.h"
32 : #include "nsIPresShell.h"
33 : #include "nsIURIContentListener.h"
34 : #include "nsISHistoryListener.h"
35 : #include "nsIURI.h"
36 : #include "nsIWebBrowserPersist.h"
37 : #include "nsCWebBrowserPersist.h"
38 : #include "nsIServiceManager.h"
39 : #include "nsFocusManager.h"
40 : #include "Layers.h"
41 : #include "nsILoadContext.h"
42 : #include "nsDocShell.h"
43 :
44 : // for painting the background window
45 : #include "mozilla/LookAndFeel.h"
46 :
47 : // Printing Includes
48 : #ifdef NS_PRINTING
49 : #include "nsIWebBrowserPrint.h"
50 : #include "nsIContentViewer.h"
51 : #endif
52 :
53 : // PSM2 includes
54 : #include "nsISecureBrowserUI.h"
55 : #include "nsXULAppAPI.h"
56 :
57 : using namespace mozilla;
58 : using namespace mozilla::gfx;
59 : using namespace mozilla::layers;
60 :
61 : static NS_DEFINE_CID(kChildCID, NS_CHILD_CID);
62 :
63 1 : nsWebBrowser::nsWebBrowser()
64 1 : : mInitInfo(new nsWebBrowserInitInfo())
65 : , mContentType(typeContentWrapper)
66 : , mActivating(false)
67 : , mShouldEnableHistory(true)
68 : , mIsActive(true)
69 : , mParentNativeWindow(nullptr)
70 : , mProgressListener(nullptr)
71 : , mBackgroundColor(0)
72 : , mPersistCurrentState(nsIWebBrowserPersist::PERSIST_STATE_READY)
73 : , mPersistResult(NS_OK)
74 : , mPersistFlags(nsIWebBrowserPersist::PERSIST_FLAGS_NONE)
75 2 : , mParentWidget(nullptr)
76 : {
77 1 : mWWatch = do_GetService(NS_WINDOWWATCHER_CONTRACTID);
78 1 : NS_ASSERTION(mWWatch, "failed to get WindowWatcher");
79 1 : }
80 :
81 0 : nsWebBrowser::~nsWebBrowser()
82 : {
83 0 : InternalDestroy();
84 0 : }
85 :
86 : NS_IMETHODIMP
87 0 : nsWebBrowser::InternalDestroy()
88 : {
89 0 : if (mInternalWidget) {
90 0 : mInternalWidget->SetWidgetListener(nullptr);
91 0 : mInternalWidget->Destroy();
92 0 : mInternalWidget = nullptr; // Force release here.
93 : }
94 :
95 0 : SetDocShell(nullptr);
96 :
97 0 : if (mDocShellTreeOwner) {
98 0 : mDocShellTreeOwner->WebBrowser(nullptr);
99 0 : mDocShellTreeOwner = nullptr;
100 : }
101 :
102 0 : mInitInfo = nullptr;
103 :
104 0 : mListenerArray = nullptr;
105 :
106 0 : return NS_OK;
107 : }
108 :
109 155 : NS_IMPL_ADDREF(nsWebBrowser)
110 154 : NS_IMPL_RELEASE(nsWebBrowser)
111 :
112 290 : NS_INTERFACE_MAP_BEGIN(nsWebBrowser)
113 290 : NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebBrowser)
114 290 : NS_INTERFACE_MAP_ENTRY(nsIWebBrowser)
115 288 : NS_INTERFACE_MAP_ENTRY(nsIWebNavigation)
116 281 : NS_INTERFACE_MAP_ENTRY(nsIBaseWindow)
117 276 : NS_INTERFACE_MAP_ENTRY(nsIScrollable)
118 276 : NS_INTERFACE_MAP_ENTRY(nsITextScroll)
119 276 : NS_INTERFACE_MAP_ENTRY(nsIDocShellTreeItem)
120 275 : NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
121 139 : NS_INTERFACE_MAP_ENTRY(nsIWebBrowserSetup)
122 138 : NS_INTERFACE_MAP_ENTRY(nsIWebBrowserPersist)
123 138 : NS_INTERFACE_MAP_ENTRY(nsICancelable)
124 138 : NS_INTERFACE_MAP_ENTRY(nsIWebBrowserFocus)
125 137 : NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener)
126 137 : NS_INTERFACE_MAP_ENTRY(nsIWebBrowserStream)
127 137 : NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
128 136 : NS_INTERFACE_MAP_END
129 :
130 : ///*****************************************************************************
131 : // nsWebBrowser::nsIInterfaceRequestor
132 : //*****************************************************************************
133 :
134 : NS_IMETHODIMP
135 136 : nsWebBrowser::GetInterface(const nsIID& aIID, void** aSink)
136 : {
137 136 : NS_ENSURE_ARG_POINTER(aSink);
138 :
139 136 : if (NS_SUCCEEDED(QueryInterface(aIID, aSink))) {
140 0 : return NS_OK;
141 : }
142 :
143 136 : if (mDocShell) {
144 : #ifdef NS_PRINTING
145 136 : if (aIID.Equals(NS_GET_IID(nsIWebBrowserPrint))) {
146 0 : nsCOMPtr<nsIContentViewer> viewer;
147 0 : mDocShell->GetContentViewer(getter_AddRefs(viewer));
148 0 : if (!viewer) {
149 0 : return NS_NOINTERFACE;
150 : }
151 :
152 0 : nsCOMPtr<nsIWebBrowserPrint> webBrowserPrint(do_QueryInterface(viewer));
153 0 : nsIWebBrowserPrint* print = (nsIWebBrowserPrint*)webBrowserPrint.get();
154 0 : NS_ASSERTION(print, "This MUST support this interface!");
155 0 : NS_ADDREF(print);
156 0 : *aSink = print;
157 0 : return NS_OK;
158 : }
159 : #endif
160 136 : return mDocShellAsReq->GetInterface(aIID, aSink);
161 : }
162 :
163 0 : return NS_NOINTERFACE;
164 : }
165 :
166 : //*****************************************************************************
167 : // nsWebBrowser::nsIWebBrowser
168 : //*****************************************************************************
169 :
170 : // listeners that currently support registration through AddWebBrowserListener:
171 : // - nsIWebProgressListener
172 : NS_IMETHODIMP
173 0 : nsWebBrowser::AddWebBrowserListener(nsIWeakReference* aListener,
174 : const nsIID& aIID)
175 : {
176 0 : NS_ENSURE_ARG_POINTER(aListener);
177 :
178 0 : nsresult rv = NS_OK;
179 0 : if (!mWebProgress) {
180 : // The window hasn't been created yet, so queue up the listener. They'll be
181 : // registered when the window gets created.
182 0 : if (!mListenerArray) {
183 0 : mListenerArray = new nsTArray<nsWebBrowserListenerState>();
184 : }
185 :
186 0 : nsWebBrowserListenerState* state = mListenerArray->AppendElement();
187 0 : state->mWeakPtr = aListener;
188 0 : state->mID = aIID;
189 : } else {
190 0 : nsCOMPtr<nsISupports> supports(do_QueryReferent(aListener));
191 0 : if (!supports) {
192 0 : return NS_ERROR_INVALID_ARG;
193 : }
194 0 : rv = BindListener(supports, aIID);
195 : }
196 :
197 0 : return rv;
198 : }
199 :
200 : NS_IMETHODIMP
201 1 : nsWebBrowser::BindListener(nsISupports* aListener, const nsIID& aIID)
202 : {
203 1 : NS_ENSURE_ARG_POINTER(aListener);
204 1 : NS_ASSERTION(mWebProgress,
205 : "this should only be called after we've retrieved a progress iface");
206 1 : nsresult rv = NS_OK;
207 :
208 : // register this listener for the specified interface id
209 1 : if (aIID.Equals(NS_GET_IID(nsIWebProgressListener))) {
210 2 : nsCOMPtr<nsIWebProgressListener> listener = do_QueryInterface(aListener, &rv);
211 1 : if (NS_FAILED(rv)) {
212 0 : return rv;
213 : }
214 1 : NS_ENSURE_STATE(mWebProgress);
215 1 : rv = mWebProgress->AddProgressListener(listener, nsIWebProgress::NOTIFY_ALL);
216 0 : } else if (aIID.Equals(NS_GET_IID(nsISHistoryListener))) {
217 0 : nsCOMPtr<nsISHistory> shistory(do_GetInterface(mDocShell, &rv));
218 0 : if (NS_FAILED(rv)) {
219 0 : return rv;
220 : }
221 0 : nsCOMPtr<nsISHistoryListener> listener(do_QueryInterface(aListener, &rv));
222 0 : if (NS_FAILED(rv)) {
223 0 : return rv;
224 : }
225 0 : rv = shistory->AddSHistoryListener(listener);
226 : }
227 1 : return rv;
228 : }
229 :
230 : NS_IMETHODIMP
231 0 : nsWebBrowser::RemoveWebBrowserListener(nsIWeakReference* aListener,
232 : const nsIID& aIID)
233 : {
234 0 : NS_ENSURE_ARG_POINTER(aListener);
235 :
236 0 : nsresult rv = NS_OK;
237 0 : if (!mWebProgress) {
238 : // if there's no-one to register the listener w/, and we don't have a queue
239 : // going, the the called is calling Remove before an Add which doesn't make
240 : // sense.
241 0 : if (!mListenerArray) {
242 0 : return NS_ERROR_FAILURE;
243 : }
244 :
245 : // iterate the array and remove the queued listener
246 0 : int32_t count = mListenerArray->Length();
247 0 : while (count > 0) {
248 0 : if (mListenerArray->ElementAt(count-1).Equals(aListener, aIID)) {
249 0 : mListenerArray->RemoveElementAt(count-1);
250 0 : break;
251 : }
252 0 : count--;
253 : }
254 :
255 : // if we've emptied the array, get rid of it.
256 0 : if (0 >= mListenerArray->Length()) {
257 0 : mListenerArray = nullptr;
258 : }
259 :
260 : } else {
261 0 : nsCOMPtr<nsISupports> supports(do_QueryReferent(aListener));
262 0 : if (!supports) {
263 0 : return NS_ERROR_INVALID_ARG;
264 : }
265 0 : rv = UnBindListener(supports, aIID);
266 : }
267 :
268 0 : return rv;
269 : }
270 :
271 : NS_IMETHODIMP
272 0 : nsWebBrowser::UnBindListener(nsISupports* aListener, const nsIID& aIID)
273 : {
274 0 : NS_ENSURE_ARG_POINTER(aListener);
275 0 : NS_ASSERTION(mWebProgress,
276 : "this should only be called after we've retrieved a progress iface");
277 0 : nsresult rv = NS_OK;
278 :
279 : // remove the listener for the specified interface id
280 0 : if (aIID.Equals(NS_GET_IID(nsIWebProgressListener))) {
281 0 : nsCOMPtr<nsIWebProgressListener> listener = do_QueryInterface(aListener, &rv);
282 0 : if (NS_FAILED(rv)) {
283 0 : return rv;
284 : }
285 0 : NS_ENSURE_STATE(mWebProgress);
286 0 : rv = mWebProgress->RemoveProgressListener(listener);
287 0 : } else if (aIID.Equals(NS_GET_IID(nsISHistoryListener))) {
288 0 : nsCOMPtr<nsISHistory> shistory(do_GetInterface(mDocShell, &rv));
289 0 : if (NS_FAILED(rv)) {
290 0 : return rv;
291 : }
292 0 : nsCOMPtr<nsISHistoryListener> listener(do_QueryInterface(aListener, &rv));
293 0 : if (NS_FAILED(rv)) {
294 0 : return rv;
295 : }
296 0 : rv = shistory->RemoveSHistoryListener(listener);
297 : }
298 0 : return rv;
299 : }
300 :
301 : NS_IMETHODIMP
302 0 : nsWebBrowser::EnableGlobalHistory(bool aEnable)
303 : {
304 0 : NS_ENSURE_STATE(mDocShell);
305 :
306 0 : return mDocShell->SetUseGlobalHistory(aEnable);
307 : }
308 :
309 : NS_IMETHODIMP
310 0 : nsWebBrowser::GetContainerWindow(nsIWebBrowserChrome** aTopWindow)
311 : {
312 0 : NS_ENSURE_ARG_POINTER(aTopWindow);
313 :
314 0 : nsCOMPtr<nsIWebBrowserChrome> top;
315 0 : if (mDocShellTreeOwner) {
316 0 : top = mDocShellTreeOwner->GetWebBrowserChrome();
317 : }
318 :
319 0 : top.forget(aTopWindow);
320 :
321 0 : return NS_OK;
322 : }
323 :
324 : NS_IMETHODIMP
325 1 : nsWebBrowser::SetContainerWindow(nsIWebBrowserChrome* aTopWindow)
326 : {
327 1 : NS_ENSURE_SUCCESS(EnsureDocShellTreeOwner(), NS_ERROR_FAILURE);
328 1 : return mDocShellTreeOwner->SetWebBrowserChrome(aTopWindow);
329 : }
330 :
331 : NS_IMETHODIMP
332 0 : nsWebBrowser::GetParentURIContentListener(
333 : nsIURIContentListener** aParentContentListener)
334 : {
335 0 : NS_ENSURE_ARG_POINTER(aParentContentListener);
336 0 : *aParentContentListener = nullptr;
337 :
338 : // get the interface from the docshell
339 0 : nsCOMPtr<nsIURIContentListener> listener(do_GetInterface(mDocShell));
340 :
341 0 : if (listener) {
342 0 : return listener->GetParentContentListener(aParentContentListener);
343 : }
344 0 : return NS_OK;
345 : }
346 :
347 : NS_IMETHODIMP
348 0 : nsWebBrowser::SetParentURIContentListener(
349 : nsIURIContentListener* aParentContentListener)
350 : {
351 : // get the interface from the docshell
352 0 : nsCOMPtr<nsIURIContentListener> listener(do_GetInterface(mDocShell));
353 :
354 0 : if (listener) {
355 0 : return listener->SetParentContentListener(aParentContentListener);
356 : }
357 0 : return NS_ERROR_FAILURE;
358 : }
359 :
360 : NS_IMETHODIMP
361 9 : nsWebBrowser::GetContentDOMWindow(mozIDOMWindowProxy** aResult)
362 : {
363 9 : if (!mDocShell) {
364 0 : return NS_ERROR_UNEXPECTED;
365 : }
366 :
367 18 : nsCOMPtr<nsPIDOMWindowOuter> retval = mDocShell->GetWindow();
368 9 : retval.forget(aResult);
369 9 : return *aResult ? NS_OK : NS_ERROR_FAILURE;
370 : }
371 :
372 : NS_IMETHODIMP
373 0 : nsWebBrowser::GetIsActive(bool* aResult)
374 : {
375 0 : *aResult = mIsActive;
376 0 : return NS_OK;
377 : }
378 :
379 : NS_IMETHODIMP
380 0 : nsWebBrowser::SetIsActive(bool aIsActive)
381 : {
382 : // Set our copy of the value
383 0 : mIsActive = aIsActive;
384 :
385 : // If we have a docshell, pass on the request
386 0 : if (mDocShell) {
387 0 : return mDocShell->SetIsActive(aIsActive);
388 : }
389 0 : return NS_OK;
390 : }
391 :
392 : void
393 1 : nsWebBrowser::SetOriginAttributes(const OriginAttributes& aAttrs)
394 : {
395 1 : mOriginAttributes = aAttrs;
396 1 : }
397 :
398 : //*****************************************************************************
399 : // nsWebBrowser::nsIDocShellTreeItem
400 : //*****************************************************************************
401 :
402 : NS_IMETHODIMP
403 0 : nsWebBrowser::GetName(nsAString& aName)
404 : {
405 0 : if (mDocShell) {
406 0 : mDocShell->GetName(aName);
407 : } else {
408 0 : aName = mInitInfo->name;
409 : }
410 :
411 0 : return NS_OK;
412 : }
413 :
414 : NS_IMETHODIMP
415 0 : nsWebBrowser::SetName(const nsAString& aName)
416 : {
417 0 : if (mDocShell) {
418 0 : return mDocShell->SetName(aName);
419 : } else {
420 0 : mInitInfo->name = aName;
421 : }
422 :
423 0 : return NS_OK;
424 : }
425 :
426 : NS_IMETHODIMP
427 0 : nsWebBrowser::NameEquals(const nsAString& aName, bool* aResult)
428 : {
429 0 : NS_ENSURE_ARG_POINTER(aResult);
430 0 : if (mDocShell) {
431 0 : return mDocShell->NameEquals(aName, aResult);
432 : } else {
433 0 : *aResult = mInitInfo->name.Equals(aName);
434 : }
435 :
436 0 : return NS_OK;
437 : }
438 :
439 : /* virtual */ int32_t
440 0 : nsWebBrowser::ItemType()
441 : {
442 0 : return mContentType;
443 : }
444 :
445 : NS_IMETHODIMP
446 0 : nsWebBrowser::GetItemType(int32_t* aItemType)
447 : {
448 0 : NS_ENSURE_ARG_POINTER(aItemType);
449 :
450 0 : *aItemType = ItemType();
451 0 : return NS_OK;
452 : }
453 :
454 : NS_IMETHODIMP
455 1 : nsWebBrowser::SetItemType(int32_t aItemType)
456 : {
457 1 : NS_ENSURE_TRUE(
458 : aItemType == typeContentWrapper || aItemType == typeChromeWrapper,
459 : NS_ERROR_FAILURE);
460 1 : mContentType = aItemType;
461 1 : if (mDocShell) {
462 0 : mDocShell->SetItemType(mContentType == typeChromeWrapper ?
463 : static_cast<int32_t>(typeChrome) :
464 0 : static_cast<int32_t>(typeContent));
465 : }
466 :
467 1 : return NS_OK;
468 : }
469 :
470 : NS_IMETHODIMP
471 0 : nsWebBrowser::GetParent(nsIDocShellTreeItem** aParent)
472 : {
473 0 : *aParent = nullptr;
474 0 : return NS_OK;
475 : }
476 :
477 : NS_IMETHODIMP
478 0 : nsWebBrowser::GetSameTypeParent(nsIDocShellTreeItem** aParent)
479 : {
480 0 : *aParent = nullptr;
481 :
482 0 : return NS_OK;
483 : }
484 :
485 : NS_IMETHODIMP
486 0 : nsWebBrowser::GetRootTreeItem(nsIDocShellTreeItem** aRootTreeItem)
487 : {
488 0 : NS_ENSURE_ARG_POINTER(aRootTreeItem);
489 0 : *aRootTreeItem = static_cast<nsIDocShellTreeItem*>(this);
490 :
491 0 : nsCOMPtr<nsIDocShellTreeItem> parent;
492 0 : NS_ENSURE_SUCCESS(GetParent(getter_AddRefs(parent)), NS_ERROR_FAILURE);
493 0 : while (parent) {
494 0 : *aRootTreeItem = parent;
495 0 : NS_ENSURE_SUCCESS((*aRootTreeItem)->GetParent(getter_AddRefs(parent)),
496 : NS_ERROR_FAILURE);
497 : }
498 0 : NS_ADDREF(*aRootTreeItem);
499 0 : return NS_OK;
500 : }
501 :
502 : NS_IMETHODIMP
503 0 : nsWebBrowser::GetSameTypeRootTreeItem(nsIDocShellTreeItem** aRootTreeItem)
504 : {
505 0 : NS_ENSURE_ARG_POINTER(aRootTreeItem);
506 0 : *aRootTreeItem = static_cast<nsIDocShellTreeItem*>(this);
507 :
508 0 : nsCOMPtr<nsIDocShellTreeItem> parent;
509 0 : NS_ENSURE_SUCCESS(GetSameTypeParent(getter_AddRefs(parent)),
510 : NS_ERROR_FAILURE);
511 0 : while (parent) {
512 0 : *aRootTreeItem = parent;
513 0 : NS_ENSURE_SUCCESS((*aRootTreeItem)->GetSameTypeParent(getter_AddRefs(parent)),
514 : NS_ERROR_FAILURE);
515 : }
516 0 : NS_ADDREF(*aRootTreeItem);
517 0 : return NS_OK;
518 : }
519 :
520 : NS_IMETHODIMP
521 0 : nsWebBrowser::FindItemWithName(const nsAString& aName,
522 : nsIDocShellTreeItem* aRequestor,
523 : nsIDocShellTreeItem* aOriginalRequestor,
524 : bool aSkipTabGroup,
525 : nsIDocShellTreeItem** aResult)
526 : {
527 0 : NS_ENSURE_STATE(mDocShell);
528 0 : NS_ASSERTION(mDocShellTreeOwner,
529 : "This should always be set when in this situation");
530 :
531 0 : return mDocShell->FindItemWithName(
532 0 : aName, aRequestor, aOriginalRequestor, aSkipTabGroup, aResult);
533 : }
534 :
535 : nsIDocument*
536 0 : nsWebBrowser::GetDocument()
537 : {
538 0 : return mDocShell ? mDocShell->GetDocument() : nullptr;
539 : }
540 :
541 : nsPIDOMWindowOuter*
542 1 : nsWebBrowser::GetWindow()
543 : {
544 1 : return mDocShell ? mDocShell->GetWindow() : nullptr;
545 : }
546 :
547 : NS_IMETHODIMP
548 0 : nsWebBrowser::GetTreeOwner(nsIDocShellTreeOwner** aTreeOwner)
549 : {
550 0 : NS_ENSURE_ARG_POINTER(aTreeOwner);
551 0 : *aTreeOwner = nullptr;
552 0 : if (mDocShellTreeOwner) {
553 0 : if (mDocShellTreeOwner->mTreeOwner) {
554 0 : *aTreeOwner = mDocShellTreeOwner->mTreeOwner;
555 : } else {
556 0 : *aTreeOwner = mDocShellTreeOwner;
557 : }
558 : }
559 0 : NS_IF_ADDREF(*aTreeOwner);
560 0 : return NS_OK;
561 : }
562 :
563 : NS_IMETHODIMP
564 0 : nsWebBrowser::SetTreeOwner(nsIDocShellTreeOwner* aTreeOwner)
565 : {
566 0 : NS_ENSURE_SUCCESS(EnsureDocShellTreeOwner(), NS_ERROR_FAILURE);
567 0 : return mDocShellTreeOwner->SetTreeOwner(aTreeOwner);
568 : }
569 :
570 : //*****************************************************************************
571 : // nsWebBrowser::nsIDocShellTreeItem
572 : //*****************************************************************************
573 :
574 : NS_IMETHODIMP
575 0 : nsWebBrowser::GetChildCount(int32_t* aChildCount)
576 : {
577 0 : NS_ENSURE_ARG_POINTER(aChildCount);
578 0 : *aChildCount = 0;
579 0 : return NS_OK;
580 : }
581 :
582 : NS_IMETHODIMP
583 0 : nsWebBrowser::AddChild(nsIDocShellTreeItem* aChild)
584 : {
585 0 : return NS_ERROR_UNEXPECTED;
586 : }
587 :
588 : NS_IMETHODIMP
589 0 : nsWebBrowser::RemoveChild(nsIDocShellTreeItem* aChild)
590 : {
591 0 : return NS_ERROR_UNEXPECTED;
592 : }
593 :
594 : NS_IMETHODIMP
595 0 : nsWebBrowser::GetChildAt(int32_t aIndex, nsIDocShellTreeItem** aChild)
596 : {
597 0 : return NS_ERROR_UNEXPECTED;
598 : }
599 :
600 : NS_IMETHODIMP
601 0 : nsWebBrowser::FindChildWithName(const nsAString& aName,
602 : bool aRecurse,
603 : bool aSameType,
604 : nsIDocShellTreeItem* aRequestor,
605 : nsIDocShellTreeItem* aOriginalRequestor,
606 : nsIDocShellTreeItem** aResult)
607 : {
608 0 : NS_ENSURE_ARG_POINTER(aResult);
609 :
610 0 : *aResult = nullptr;
611 0 : return NS_OK;
612 : }
613 :
614 : //*****************************************************************************
615 : // nsWebBrowser::nsIWebNavigation
616 : //*****************************************************************************
617 :
618 : NS_IMETHODIMP
619 0 : nsWebBrowser::GetCanGoBack(bool* aCanGoBack)
620 : {
621 0 : NS_ENSURE_STATE(mDocShell);
622 :
623 0 : return mDocShellAsNav->GetCanGoBack(aCanGoBack);
624 : }
625 :
626 : NS_IMETHODIMP
627 0 : nsWebBrowser::GetCanGoForward(bool* aCanGoForward)
628 : {
629 0 : NS_ENSURE_STATE(mDocShell);
630 :
631 0 : return mDocShellAsNav->GetCanGoForward(aCanGoForward);
632 : }
633 :
634 : NS_IMETHODIMP
635 0 : nsWebBrowser::GoBack()
636 : {
637 0 : NS_ENSURE_STATE(mDocShell);
638 :
639 0 : return mDocShellAsNav->GoBack();
640 : }
641 :
642 : NS_IMETHODIMP
643 0 : nsWebBrowser::GoForward()
644 : {
645 0 : NS_ENSURE_STATE(mDocShell);
646 :
647 0 : return mDocShellAsNav->GoForward();
648 : }
649 :
650 : NS_IMETHODIMP
651 0 : nsWebBrowser::LoadURIWithOptions(const char16_t* aURI, uint32_t aLoadFlags,
652 : nsIURI* aReferringURI,
653 : uint32_t aReferrerPolicy,
654 : nsIInputStream* aPostDataStream,
655 : nsIInputStream* aExtraHeaderStream,
656 : nsIURI* aBaseURI,
657 : nsIPrincipal* aTriggeringPrincipal)
658 : {
659 0 : NS_ENSURE_STATE(mDocShell);
660 :
661 0 : return mDocShellAsNav->LoadURIWithOptions(
662 : aURI, aLoadFlags, aReferringURI, aReferrerPolicy, aPostDataStream,
663 0 : aExtraHeaderStream, aBaseURI, aTriggeringPrincipal);
664 : }
665 :
666 : NS_IMETHODIMP
667 0 : nsWebBrowser::SetOriginAttributesBeforeLoading(JS::Handle<JS::Value> aOriginAttributes)
668 : {
669 0 : return mDocShellAsNav->SetOriginAttributesBeforeLoading(aOriginAttributes);
670 : }
671 :
672 : NS_IMETHODIMP
673 1 : nsWebBrowser::LoadURI(const char16_t* aURI, uint32_t aLoadFlags,
674 : nsIURI* aReferringURI,
675 : nsIInputStream* aPostDataStream,
676 : nsIInputStream* aExtraHeaderStream,
677 : nsIPrincipal* aTriggeringPrincipal)
678 : {
679 1 : NS_ENSURE_STATE(mDocShell);
680 :
681 1 : return mDocShellAsNav->LoadURI(aURI, aLoadFlags, aReferringURI,
682 : aPostDataStream, aExtraHeaderStream,
683 1 : aTriggeringPrincipal);
684 : }
685 :
686 : NS_IMETHODIMP
687 0 : nsWebBrowser::Reload(uint32_t aReloadFlags)
688 : {
689 0 : NS_ENSURE_STATE(mDocShell);
690 :
691 0 : return mDocShellAsNav->Reload(aReloadFlags);
692 : }
693 :
694 : NS_IMETHODIMP
695 0 : nsWebBrowser::GotoIndex(int32_t aIndex)
696 : {
697 0 : NS_ENSURE_STATE(mDocShell);
698 :
699 0 : return mDocShellAsNav->GotoIndex(aIndex);
700 : }
701 :
702 : NS_IMETHODIMP
703 0 : nsWebBrowser::Stop(uint32_t aStopFlags)
704 : {
705 0 : NS_ENSURE_STATE(mDocShell);
706 :
707 0 : return mDocShellAsNav->Stop(aStopFlags);
708 : }
709 :
710 : NS_IMETHODIMP
711 0 : nsWebBrowser::GetCurrentURI(nsIURI** aURI)
712 : {
713 0 : NS_ENSURE_STATE(mDocShell);
714 :
715 0 : return mDocShellAsNav->GetCurrentURI(aURI);
716 : }
717 :
718 : NS_IMETHODIMP
719 0 : nsWebBrowser::GetReferringURI(nsIURI** aURI)
720 : {
721 0 : NS_ENSURE_STATE(mDocShell);
722 :
723 0 : return mDocShellAsNav->GetReferringURI(aURI);
724 : }
725 :
726 : NS_IMETHODIMP
727 0 : nsWebBrowser::SetSessionHistory(nsISHistory* aSessionHistory)
728 : {
729 0 : if (mDocShell) {
730 0 : return mDocShellAsNav->SetSessionHistory(aSessionHistory);
731 : } else {
732 0 : mInitInfo->sessionHistory = aSessionHistory;
733 : }
734 :
735 0 : return NS_OK;
736 : }
737 :
738 : NS_IMETHODIMP
739 0 : nsWebBrowser::GetSessionHistory(nsISHistory** aSessionHistory)
740 : {
741 0 : NS_ENSURE_ARG_POINTER(aSessionHistory);
742 0 : if (mDocShell) {
743 0 : return mDocShellAsNav->GetSessionHistory(aSessionHistory);
744 : } else {
745 0 : *aSessionHistory = mInitInfo->sessionHistory;
746 : }
747 :
748 0 : NS_IF_ADDREF(*aSessionHistory);
749 :
750 0 : return NS_OK;
751 : }
752 :
753 : NS_IMETHODIMP
754 9 : nsWebBrowser::GetDocument(nsIDOMDocument** aDocument)
755 : {
756 9 : NS_ENSURE_STATE(mDocShell);
757 :
758 9 : return mDocShellAsNav->GetDocument(aDocument);
759 : }
760 :
761 : //*****************************************************************************
762 : // nsWebBrowser::nsIWebBrowserSetup
763 : //*****************************************************************************
764 :
765 : NS_IMETHODIMP
766 1 : nsWebBrowser::SetProperty(uint32_t aId, uint32_t aValue)
767 : {
768 1 : nsresult rv = NS_OK;
769 :
770 1 : switch (aId) {
771 : case nsIWebBrowserSetup::SETUP_ALLOW_PLUGINS: {
772 0 : NS_ENSURE_STATE(mDocShell);
773 0 : NS_ENSURE_TRUE((aValue == static_cast<uint32_t>(true) ||
774 : aValue == static_cast<uint32_t>(false)),
775 : NS_ERROR_INVALID_ARG);
776 0 : mDocShell->SetAllowPlugins(!!aValue);
777 0 : break;
778 : }
779 : case nsIWebBrowserSetup::SETUP_ALLOW_JAVASCRIPT: {
780 0 : NS_ENSURE_STATE(mDocShell);
781 0 : NS_ENSURE_TRUE((aValue == static_cast<uint32_t>(true) ||
782 : aValue == static_cast<uint32_t>(false)),
783 : NS_ERROR_INVALID_ARG);
784 0 : mDocShell->SetAllowJavascript(!!aValue);
785 0 : break;
786 : }
787 : case nsIWebBrowserSetup::SETUP_ALLOW_META_REDIRECTS: {
788 0 : NS_ENSURE_STATE(mDocShell);
789 0 : NS_ENSURE_TRUE((aValue == static_cast<uint32_t>(true) ||
790 : aValue == static_cast<uint32_t>(false)),
791 : NS_ERROR_INVALID_ARG);
792 0 : mDocShell->SetAllowMetaRedirects(!!aValue);
793 0 : break;
794 : }
795 : case nsIWebBrowserSetup::SETUP_ALLOW_SUBFRAMES: {
796 0 : NS_ENSURE_STATE(mDocShell);
797 0 : NS_ENSURE_TRUE((aValue == static_cast<uint32_t>(true) ||
798 : aValue == static_cast<uint32_t>(false)),
799 : NS_ERROR_INVALID_ARG);
800 0 : mDocShell->SetAllowSubframes(!!aValue);
801 0 : break;
802 : }
803 : case nsIWebBrowserSetup::SETUP_ALLOW_IMAGES: {
804 0 : NS_ENSURE_STATE(mDocShell);
805 0 : NS_ENSURE_TRUE((aValue == static_cast<uint32_t>(true) ||
806 : aValue == static_cast<uint32_t>(false)),
807 : NS_ERROR_INVALID_ARG);
808 0 : mDocShell->SetAllowImages(!!aValue);
809 0 : break;
810 : }
811 : case nsIWebBrowserSetup::SETUP_ALLOW_DNS_PREFETCH: {
812 1 : NS_ENSURE_STATE(mDocShell);
813 1 : NS_ENSURE_TRUE((aValue == static_cast<uint32_t>(true) ||
814 : aValue == static_cast<uint32_t>(false)),
815 : NS_ERROR_INVALID_ARG);
816 1 : mDocShell->SetAllowDNSPrefetch(!!aValue);
817 1 : break;
818 : }
819 : case nsIWebBrowserSetup::SETUP_USE_GLOBAL_HISTORY: {
820 0 : NS_ENSURE_STATE(mDocShell);
821 0 : NS_ENSURE_TRUE((aValue == static_cast<uint32_t>(true) ||
822 : aValue == static_cast<uint32_t>(false)),
823 : NS_ERROR_INVALID_ARG);
824 0 : rv = EnableGlobalHistory(!!aValue);
825 0 : mShouldEnableHistory = aValue;
826 0 : break;
827 : }
828 : case nsIWebBrowserSetup::SETUP_FOCUS_DOC_BEFORE_CONTENT: {
829 : // obsolete
830 0 : break;
831 : }
832 : case nsIWebBrowserSetup::SETUP_IS_CHROME_WRAPPER: {
833 0 : NS_ENSURE_TRUE((aValue == static_cast<uint32_t>(true) ||
834 : aValue == static_cast<uint32_t>(false)),
835 : NS_ERROR_INVALID_ARG);
836 0 : SetItemType(aValue ? static_cast<int32_t>(typeChromeWrapper) :
837 0 : static_cast<int32_t>(typeContentWrapper));
838 0 : break;
839 : }
840 : default:
841 0 : rv = NS_ERROR_INVALID_ARG;
842 : }
843 1 : return rv;
844 : }
845 :
846 : //*****************************************************************************
847 : // nsWebBrowser::nsIWebProgressListener
848 : //*****************************************************************************
849 :
850 : NS_IMETHODIMP
851 0 : nsWebBrowser::OnStateChange(nsIWebProgress* aWebProgress,
852 : nsIRequest* aRequest,
853 : uint32_t aStateFlags,
854 : nsresult aStatus)
855 : {
856 0 : if (mPersist) {
857 0 : mPersist->GetCurrentState(&mPersistCurrentState);
858 : }
859 0 : if (aStateFlags & STATE_IS_NETWORK && aStateFlags & STATE_STOP) {
860 0 : mPersist = nullptr;
861 : }
862 0 : if (mProgressListener) {
863 0 : return mProgressListener->OnStateChange(aWebProgress, aRequest, aStateFlags,
864 0 : aStatus);
865 : }
866 0 : return NS_OK;
867 : }
868 :
869 : NS_IMETHODIMP
870 0 : nsWebBrowser::OnProgressChange(nsIWebProgress* aWebProgress,
871 : nsIRequest* aRequest,
872 : int32_t aCurSelfProgress,
873 : int32_t aMaxSelfProgress,
874 : int32_t aCurTotalProgress,
875 : int32_t aMaxTotalProgress)
876 : {
877 0 : if (mPersist) {
878 0 : mPersist->GetCurrentState(&mPersistCurrentState);
879 : }
880 0 : if (mProgressListener) {
881 0 : return mProgressListener->OnProgressChange(
882 : aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress,
883 0 : aCurTotalProgress, aMaxTotalProgress);
884 : }
885 0 : return NS_OK;
886 : }
887 :
888 : NS_IMETHODIMP
889 0 : nsWebBrowser::OnLocationChange(nsIWebProgress* aWebProgress,
890 : nsIRequest* aRequest,
891 : nsIURI* aLocation,
892 : uint32_t aFlags)
893 : {
894 0 : if (mProgressListener) {
895 0 : return mProgressListener->OnLocationChange(aWebProgress, aRequest, aLocation,
896 0 : aFlags);
897 : }
898 0 : return NS_OK;
899 : }
900 :
901 : NS_IMETHODIMP
902 0 : nsWebBrowser::OnStatusChange(nsIWebProgress* aWebProgress,
903 : nsIRequest* aRequest,
904 : nsresult aStatus,
905 : const char16_t* aMessage)
906 : {
907 0 : if (mProgressListener) {
908 0 : return mProgressListener->OnStatusChange(aWebProgress, aRequest, aStatus,
909 0 : aMessage);
910 : }
911 0 : return NS_OK;
912 : }
913 :
914 : NS_IMETHODIMP
915 0 : nsWebBrowser::OnSecurityChange(nsIWebProgress* aWebProgress,
916 : nsIRequest* aRequest,
917 : uint32_t aState)
918 : {
919 0 : if (mProgressListener) {
920 0 : return mProgressListener->OnSecurityChange(aWebProgress, aRequest, aState);
921 : }
922 0 : return NS_OK;
923 : }
924 :
925 : //*****************************************************************************
926 : // nsWebBrowser::nsIWebBrowserPersist
927 : //*****************************************************************************
928 :
929 : NS_IMETHODIMP
930 0 : nsWebBrowser::GetPersistFlags(uint32_t* aPersistFlags)
931 : {
932 0 : NS_ENSURE_ARG_POINTER(aPersistFlags);
933 0 : nsresult rv = NS_OK;
934 0 : if (mPersist) {
935 0 : rv = mPersist->GetPersistFlags(&mPersistFlags);
936 : }
937 0 : *aPersistFlags = mPersistFlags;
938 0 : return rv;
939 : }
940 :
941 : NS_IMETHODIMP
942 0 : nsWebBrowser::SetPersistFlags(uint32_t aPersistFlags)
943 : {
944 0 : nsresult rv = NS_OK;
945 0 : mPersistFlags = aPersistFlags;
946 0 : if (mPersist) {
947 0 : rv = mPersist->SetPersistFlags(mPersistFlags);
948 0 : mPersist->GetPersistFlags(&mPersistFlags);
949 : }
950 0 : return rv;
951 : }
952 :
953 : NS_IMETHODIMP
954 0 : nsWebBrowser::GetCurrentState(uint32_t* aCurrentState)
955 : {
956 0 : NS_ENSURE_ARG_POINTER(aCurrentState);
957 0 : if (mPersist) {
958 0 : mPersist->GetCurrentState(&mPersistCurrentState);
959 : }
960 0 : *aCurrentState = mPersistCurrentState;
961 0 : return NS_OK;
962 : }
963 :
964 : NS_IMETHODIMP
965 0 : nsWebBrowser::GetResult(nsresult* aResult)
966 : {
967 0 : NS_ENSURE_ARG_POINTER(aResult);
968 0 : if (mPersist) {
969 0 : mPersist->GetResult(&mPersistResult);
970 : }
971 0 : *aResult = mPersistResult;
972 0 : return NS_OK;
973 : }
974 :
975 : NS_IMETHODIMP
976 0 : nsWebBrowser::GetProgressListener(nsIWebProgressListener** aProgressListener)
977 : {
978 0 : NS_ENSURE_ARG_POINTER(aProgressListener);
979 0 : *aProgressListener = mProgressListener;
980 0 : NS_IF_ADDREF(*aProgressListener);
981 0 : return NS_OK;
982 : }
983 :
984 : NS_IMETHODIMP
985 0 : nsWebBrowser::SetProgressListener(nsIWebProgressListener* aProgressListener)
986 : {
987 0 : mProgressListener = aProgressListener;
988 0 : return NS_OK;
989 : }
990 :
991 : NS_IMETHODIMP
992 0 : nsWebBrowser::SaveURI(nsIURI* aURI,
993 : nsISupports* aCacheKey,
994 : nsIURI* aReferrer,
995 : uint32_t aReferrerPolicy,
996 : nsIInputStream* aPostData,
997 : const char* aExtraHeaders,
998 : nsISupports* aFile,
999 : nsILoadContext* aPrivacyContext)
1000 : {
1001 0 : return SavePrivacyAwareURI(
1002 : aURI, aCacheKey, aReferrer, aReferrerPolicy, aPostData, aExtraHeaders,
1003 0 : aFile, aPrivacyContext && aPrivacyContext->UsePrivateBrowsing());
1004 : }
1005 :
1006 : NS_IMETHODIMP
1007 0 : nsWebBrowser::SavePrivacyAwareURI(nsIURI* aURI,
1008 : nsISupports* aCacheKey,
1009 : nsIURI* aReferrer,
1010 : uint32_t aReferrerPolicy,
1011 : nsIInputStream* aPostData,
1012 : const char* aExtraHeaders,
1013 : nsISupports* aFile,
1014 : bool aIsPrivate)
1015 : {
1016 0 : if (mPersist) {
1017 : uint32_t currentState;
1018 0 : mPersist->GetCurrentState(¤tState);
1019 0 : if (currentState == PERSIST_STATE_FINISHED) {
1020 0 : mPersist = nullptr;
1021 : } else {
1022 : // You can't save again until the last save has completed
1023 0 : return NS_ERROR_FAILURE;
1024 : }
1025 : }
1026 :
1027 0 : nsCOMPtr<nsIURI> uri;
1028 0 : if (aURI) {
1029 0 : uri = aURI;
1030 : } else {
1031 0 : nsresult rv = GetCurrentURI(getter_AddRefs(uri));
1032 0 : if (NS_FAILED(rv)) {
1033 0 : return NS_ERROR_FAILURE;
1034 : }
1035 : }
1036 :
1037 : // Create a throwaway persistence object to do the work
1038 : nsresult rv;
1039 0 : mPersist = do_CreateInstance(NS_WEBBROWSERPERSIST_CONTRACTID, &rv);
1040 0 : NS_ENSURE_SUCCESS(rv, rv);
1041 0 : mPersist->SetProgressListener(this);
1042 0 : mPersist->SetPersistFlags(mPersistFlags);
1043 0 : mPersist->GetCurrentState(&mPersistCurrentState);
1044 :
1045 0 : rv = mPersist->SavePrivacyAwareURI(uri, aCacheKey, aReferrer, aReferrerPolicy,
1046 0 : aPostData, aExtraHeaders, aFile, aIsPrivate);
1047 0 : if (NS_FAILED(rv)) {
1048 0 : mPersist = nullptr;
1049 : }
1050 0 : return rv;
1051 : }
1052 :
1053 : NS_IMETHODIMP
1054 0 : nsWebBrowser::SaveChannel(nsIChannel* aChannel, nsISupports* aFile)
1055 : {
1056 0 : if (mPersist) {
1057 : uint32_t currentState;
1058 0 : mPersist->GetCurrentState(¤tState);
1059 0 : if (currentState == PERSIST_STATE_FINISHED) {
1060 0 : mPersist = nullptr;
1061 : } else {
1062 : // You can't save again until the last save has completed
1063 0 : return NS_ERROR_FAILURE;
1064 : }
1065 : }
1066 :
1067 : // Create a throwaway persistence object to do the work
1068 : nsresult rv;
1069 0 : mPersist = do_CreateInstance(NS_WEBBROWSERPERSIST_CONTRACTID, &rv);
1070 0 : NS_ENSURE_SUCCESS(rv, rv);
1071 0 : mPersist->SetProgressListener(this);
1072 0 : mPersist->SetPersistFlags(mPersistFlags);
1073 0 : mPersist->GetCurrentState(&mPersistCurrentState);
1074 0 : rv = mPersist->SaveChannel(aChannel, aFile);
1075 0 : if (NS_FAILED(rv)) {
1076 0 : mPersist = nullptr;
1077 : }
1078 0 : return rv;
1079 : }
1080 :
1081 : NS_IMETHODIMP
1082 0 : nsWebBrowser::SaveDocument(nsISupports* aDocumentish,
1083 : nsISupports* aFile,
1084 : nsISupports* aDataPath,
1085 : const char* aOutputContentType,
1086 : uint32_t aEncodingFlags,
1087 : uint32_t aWrapColumn)
1088 : {
1089 0 : if (mPersist) {
1090 : uint32_t currentState;
1091 0 : mPersist->GetCurrentState(¤tState);
1092 0 : if (currentState == PERSIST_STATE_FINISHED) {
1093 0 : mPersist = nullptr;
1094 : } else {
1095 : // You can't save again until the last save has completed
1096 0 : return NS_ERROR_FAILURE;
1097 : }
1098 : }
1099 :
1100 : // Use the specified DOM document, or if none is specified, the one
1101 : // attached to the web browser.
1102 :
1103 0 : nsCOMPtr<nsISupports> doc;
1104 0 : if (aDocumentish) {
1105 0 : doc = aDocumentish;
1106 : } else {
1107 0 : nsCOMPtr<nsIDOMDocument> domDoc;
1108 0 : GetDocument(getter_AddRefs(domDoc));
1109 0 : doc = domDoc.forget();
1110 : }
1111 0 : if (!doc) {
1112 0 : return NS_ERROR_FAILURE;
1113 : }
1114 :
1115 : // Create a throwaway persistence object to do the work
1116 : nsresult rv;
1117 0 : mPersist = do_CreateInstance(NS_WEBBROWSERPERSIST_CONTRACTID, &rv);
1118 0 : NS_ENSURE_SUCCESS(rv, rv);
1119 0 : mPersist->SetProgressListener(this);
1120 0 : mPersist->SetPersistFlags(mPersistFlags);
1121 0 : mPersist->GetCurrentState(&mPersistCurrentState);
1122 0 : rv = mPersist->SaveDocument(doc, aFile, aDataPath, aOutputContentType,
1123 0 : aEncodingFlags, aWrapColumn);
1124 0 : if (NS_FAILED(rv)) {
1125 0 : mPersist = nullptr;
1126 : }
1127 0 : return rv;
1128 : }
1129 :
1130 : NS_IMETHODIMP
1131 0 : nsWebBrowser::CancelSave()
1132 : {
1133 0 : if (mPersist) {
1134 0 : return mPersist->CancelSave();
1135 : }
1136 0 : return NS_OK;
1137 : }
1138 :
1139 : NS_IMETHODIMP
1140 0 : nsWebBrowser::Cancel(nsresult aReason)
1141 : {
1142 0 : if (mPersist) {
1143 0 : return mPersist->Cancel(aReason);
1144 : }
1145 0 : return NS_OK;
1146 : }
1147 :
1148 : //*****************************************************************************
1149 : // nsWebBrowser::nsIBaseWindow
1150 : //*****************************************************************************
1151 :
1152 : NS_IMETHODIMP
1153 1 : nsWebBrowser::InitWindow(nativeWindow aParentNativeWindow,
1154 : nsIWidget* aParentWidget,
1155 : int32_t aX, int32_t aY,
1156 : int32_t aCX, int32_t aCY)
1157 : {
1158 1 : NS_ENSURE_ARG(aParentNativeWindow || aParentWidget);
1159 1 : NS_ENSURE_STATE(!mDocShell || mInitInfo);
1160 :
1161 1 : if (aParentWidget) {
1162 1 : NS_ENSURE_SUCCESS(SetParentWidget(aParentWidget), NS_ERROR_FAILURE);
1163 : } else
1164 0 : NS_ENSURE_SUCCESS(SetParentNativeWindow(aParentNativeWindow),
1165 : NS_ERROR_FAILURE);
1166 :
1167 1 : NS_ENSURE_SUCCESS(SetPositionAndSize(aX, aY, aCX, aCY, 0),
1168 : NS_ERROR_FAILURE);
1169 :
1170 1 : return NS_OK;
1171 : }
1172 :
1173 : NS_IMETHODIMP
1174 1 : nsWebBrowser::Create()
1175 : {
1176 1 : NS_ENSURE_STATE(!mDocShell && (mParentNativeWindow || mParentWidget));
1177 :
1178 1 : nsresult rv = EnsureDocShellTreeOwner();
1179 1 : NS_ENSURE_SUCCESS(rv, rv);
1180 :
1181 2 : nsCOMPtr<nsIWidget> docShellParentWidget(mParentWidget);
1182 1 : if (!mParentWidget) {
1183 : // Create the widget
1184 0 : mInternalWidget = do_CreateInstance(kChildCID, &rv);
1185 0 : NS_ENSURE_SUCCESS(rv, rv);
1186 :
1187 0 : docShellParentWidget = mInternalWidget;
1188 0 : nsWidgetInitData widgetInit;
1189 :
1190 0 : widgetInit.clipChildren = true;
1191 :
1192 0 : widgetInit.mWindowType = eWindowType_child;
1193 0 : LayoutDeviceIntRect bounds(mInitInfo->x, mInitInfo->y,
1194 0 : mInitInfo->cx, mInitInfo->cy);
1195 :
1196 0 : mInternalWidget->SetWidgetListener(this);
1197 0 : rv = mInternalWidget->Create(nullptr, mParentNativeWindow, bounds,
1198 0 : &widgetInit);
1199 0 : NS_ENSURE_SUCCESS(rv, rv);
1200 : }
1201 :
1202 : nsCOMPtr<nsIDocShell> docShell(
1203 2 : do_CreateInstance("@mozilla.org/docshell;1", &rv));
1204 1 : NS_ENSURE_SUCCESS(rv, rv);
1205 1 : nsDocShell::Cast(docShell)->SetOriginAttributes(mOriginAttributes);
1206 1 : rv = SetDocShell(docShell);
1207 1 : NS_ENSURE_SUCCESS(rv, rv);
1208 :
1209 : // get the system default window background colour
1210 1 : LookAndFeel::GetColor(LookAndFeel::eColorID_WindowBackground,
1211 1 : &mBackgroundColor);
1212 :
1213 : // the docshell has been set so we now have our listener registrars.
1214 1 : if (mListenerArray) {
1215 : // we had queued up some listeners, let's register them now.
1216 0 : uint32_t count = mListenerArray->Length();
1217 0 : uint32_t i = 0;
1218 0 : NS_ASSERTION(count > 0, "array construction problem");
1219 0 : while (i < count) {
1220 0 : nsWebBrowserListenerState& state = mListenerArray->ElementAt(i);
1221 0 : nsCOMPtr<nsISupports> listener = do_QueryReferent(state.mWeakPtr);
1222 0 : NS_ASSERTION(listener, "bad listener");
1223 0 : (void)BindListener(listener, state.mID);
1224 0 : i++;
1225 : }
1226 0 : mListenerArray = nullptr;
1227 : }
1228 :
1229 : // HACK ALERT - this registration registers the nsDocShellTreeOwner as a
1230 : // nsIWebBrowserListener so it can setup its MouseListener in one of the
1231 : // progress callbacks. If we can register the MouseListener another way, this
1232 : // registration can go away, and nsDocShellTreeOwner can stop implementing
1233 : // nsIWebProgressListener.
1234 2 : nsCOMPtr<nsISupports> supports = nullptr;
1235 1 : (void)mDocShellTreeOwner->QueryInterface(
1236 : NS_GET_IID(nsIWebProgressListener),
1237 2 : static_cast<void**>(getter_AddRefs(supports)));
1238 1 : (void)BindListener(supports, NS_GET_IID(nsIWebProgressListener));
1239 :
1240 1 : NS_ENSURE_SUCCESS(mDocShellAsWin->InitWindow(nullptr, docShellParentWidget,
1241 : mInitInfo->x, mInitInfo->y,
1242 : mInitInfo->cx, mInitInfo->cy),
1243 : NS_ERROR_FAILURE);
1244 :
1245 1 : mDocShell->SetName(mInitInfo->name);
1246 1 : if (mContentType == typeChromeWrapper) {
1247 0 : mDocShell->SetItemType(nsIDocShellTreeItem::typeChrome);
1248 : } else {
1249 1 : mDocShell->SetItemType(nsIDocShellTreeItem::typeContent);
1250 : }
1251 1 : mDocShell->SetTreeOwner(mDocShellTreeOwner);
1252 :
1253 : // If the webbrowser is a content docshell item then we won't hear any
1254 : // events from subframes. To solve that we install our own chrome event
1255 : // handler that always gets called (even for subframes) for any bubbling
1256 : // event.
1257 :
1258 1 : if (!mInitInfo->sessionHistory) {
1259 1 : mInitInfo->sessionHistory = do_CreateInstance(NS_SHISTORY_CONTRACTID, &rv);
1260 1 : NS_ENSURE_SUCCESS(rv, rv);
1261 : }
1262 1 : mDocShellAsNav->SetSessionHistory(mInitInfo->sessionHistory);
1263 :
1264 1 : if (XRE_IsParentProcess()) {
1265 : // Hook up global history. Do not fail if we can't - just warn.
1266 0 : rv = EnableGlobalHistory(mShouldEnableHistory);
1267 0 : NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "EnableGlobalHistory() failed");
1268 : }
1269 :
1270 1 : NS_ENSURE_SUCCESS(mDocShellAsWin->Create(), NS_ERROR_FAILURE);
1271 :
1272 : // Hook into the OnSecurityChange() notification for lock/unlock icon
1273 : // updates
1274 2 : nsCOMPtr<mozIDOMWindowProxy> domWindow;
1275 1 : rv = GetContentDOMWindow(getter_AddRefs(domWindow));
1276 1 : if (NS_SUCCEEDED(rv)) {
1277 : // this works because the implementation of nsISecureBrowserUI
1278 : // (nsSecureBrowserUIImpl) gets a docShell from the domWindow,
1279 : // and calls docShell->SetSecurityUI(this);
1280 : nsCOMPtr<nsISecureBrowserUI> securityUI =
1281 2 : do_CreateInstance(NS_SECURE_BROWSER_UI_CONTRACTID, &rv);
1282 1 : if (NS_SUCCEEDED(rv)) {
1283 1 : securityUI->Init(domWindow);
1284 : }
1285 : }
1286 :
1287 1 : mDocShellTreeOwner->AddToWatcher(); // evil twin of Remove in SetDocShell(0)
1288 1 : mDocShellTreeOwner->AddChromeListeners();
1289 :
1290 1 : mInitInfo = nullptr;
1291 :
1292 1 : return NS_OK;
1293 : }
1294 :
1295 : NS_IMETHODIMP
1296 0 : nsWebBrowser::Destroy()
1297 : {
1298 0 : InternalDestroy();
1299 :
1300 0 : if (!mInitInfo) {
1301 0 : mInitInfo = new nsWebBrowserInitInfo();
1302 : }
1303 :
1304 0 : return NS_OK;
1305 : }
1306 :
1307 : NS_IMETHODIMP
1308 0 : nsWebBrowser::GetUnscaledDevicePixelsPerCSSPixel(double* aScale)
1309 : {
1310 0 : *aScale = mParentWidget ? mParentWidget->GetDefaultScale().scale : 1.0;
1311 0 : return NS_OK;
1312 : }
1313 :
1314 : NS_IMETHODIMP
1315 0 : nsWebBrowser::GetDevicePixelsPerDesktopPixel(double* aScale)
1316 : {
1317 0 : *aScale = mParentWidget ? mParentWidget->GetDesktopToDeviceScale().scale
1318 0 : : 1.0;
1319 0 : return NS_OK;
1320 : }
1321 :
1322 : NS_IMETHODIMP
1323 0 : nsWebBrowser::SetPositionDesktopPix(int32_t aX, int32_t aY)
1324 : {
1325 : // XXX jfkthame
1326 : // It's not clear to me whether this will be fully correct across
1327 : // potential multi-screen, mixed-DPI configurations for all platforms;
1328 : // we might need to add code paths that make it possible to pass the
1329 : // desktop-pix parameters all the way through to the native widget,
1330 : // to avoid the risk of device-pixel coords mapping to the wrong
1331 : // display on OS X with mixed retina/non-retina screens.
1332 0 : double scale = 1.0;
1333 0 : GetDevicePixelsPerDesktopPixel(&scale);
1334 0 : return SetPosition(NSToIntRound(aX * scale), NSToIntRound(aY * scale));
1335 : }
1336 :
1337 : NS_IMETHODIMP
1338 0 : nsWebBrowser::SetPosition(int32_t aX, int32_t aY)
1339 : {
1340 0 : int32_t cx = 0;
1341 0 : int32_t cy = 0;
1342 :
1343 0 : GetSize(&cx, &cy);
1344 :
1345 0 : return SetPositionAndSize(aX, aY, cx, cy, 0);
1346 : }
1347 :
1348 : NS_IMETHODIMP
1349 0 : nsWebBrowser::GetPosition(int32_t* aX, int32_t* aY)
1350 : {
1351 0 : return GetPositionAndSize(aX, aY, nullptr, nullptr);
1352 : }
1353 :
1354 : NS_IMETHODIMP
1355 0 : nsWebBrowser::SetSize(int32_t aCX, int32_t aCY, bool aRepaint)
1356 : {
1357 0 : int32_t x = 0;
1358 0 : int32_t y = 0;
1359 :
1360 0 : GetPosition(&x, &y);
1361 :
1362 0 : return SetPositionAndSize(x, y, aCX, aCY,
1363 0 : aRepaint ? nsIBaseWindow::eRepaint : 0);
1364 : }
1365 :
1366 : NS_IMETHODIMP
1367 0 : nsWebBrowser::GetSize(int32_t* aCX, int32_t* aCY)
1368 : {
1369 0 : return GetPositionAndSize(nullptr, nullptr, aCX, aCY);
1370 : }
1371 :
1372 : NS_IMETHODIMP
1373 4 : nsWebBrowser::SetPositionAndSize(int32_t aX, int32_t aY,
1374 : int32_t aCX, int32_t aCY, uint32_t aFlags)
1375 : {
1376 4 : if (!mDocShell) {
1377 1 : mInitInfo->x = aX;
1378 1 : mInitInfo->y = aY;
1379 1 : mInitInfo->cx = aCX;
1380 1 : mInitInfo->cy = aCY;
1381 : } else {
1382 3 : int32_t doc_x = aX;
1383 3 : int32_t doc_y = aY;
1384 :
1385 : // If there is an internal widget we need to make the docShell coordinates
1386 : // relative to the internal widget rather than the calling app's parent.
1387 : // We also need to resize our widget then.
1388 3 : if (mInternalWidget) {
1389 0 : doc_x = doc_y = 0;
1390 0 : mInternalWidget->Resize(aX, aY, aCX, aCY,
1391 0 : !!(aFlags & nsIBaseWindow::eRepaint));
1392 : }
1393 : // Now reposition/ resize the doc
1394 3 : NS_ENSURE_SUCCESS(
1395 : mDocShellAsWin->SetPositionAndSize(doc_x, doc_y, aCX, aCY, aFlags),
1396 : NS_ERROR_FAILURE);
1397 : }
1398 :
1399 4 : return NS_OK;
1400 : }
1401 :
1402 : NS_IMETHODIMP
1403 0 : nsWebBrowser::GetPositionAndSize(int32_t* aX, int32_t* aY,
1404 : int32_t* aCX, int32_t* aCY)
1405 : {
1406 0 : if (!mDocShell) {
1407 0 : if (aX) {
1408 0 : *aX = mInitInfo->x;
1409 : }
1410 0 : if (aY) {
1411 0 : *aY = mInitInfo->y;
1412 : }
1413 0 : if (aCX) {
1414 0 : *aCX = mInitInfo->cx;
1415 : }
1416 0 : if (aCY) {
1417 0 : *aCY = mInitInfo->cy;
1418 : }
1419 0 : } else if (mInternalWidget) {
1420 0 : LayoutDeviceIntRect bounds = mInternalWidget->GetBounds();
1421 :
1422 0 : if (aX) {
1423 0 : *aX = bounds.x;
1424 : }
1425 0 : if (aY) {
1426 0 : *aY = bounds.y;
1427 : }
1428 0 : if (aCX) {
1429 0 : *aCX = bounds.width;
1430 : }
1431 0 : if (aCY) {
1432 0 : *aCY = bounds.height;
1433 : }
1434 0 : return NS_OK;
1435 : } else {
1436 : // Can directly return this as it is the
1437 : // same interface, thus same returns.
1438 0 : return mDocShellAsWin->GetPositionAndSize(aX, aY, aCX, aCY);
1439 : }
1440 0 : return NS_OK;
1441 : }
1442 :
1443 : NS_IMETHODIMP
1444 0 : nsWebBrowser::Repaint(bool aForce)
1445 : {
1446 0 : NS_ENSURE_STATE(mDocShell);
1447 : // Can directly return this as it is the
1448 : // same interface, thus same returns.
1449 0 : return mDocShellAsWin->Repaint(aForce);
1450 : }
1451 :
1452 : NS_IMETHODIMP
1453 0 : nsWebBrowser::GetParentWidget(nsIWidget** aParentWidget)
1454 : {
1455 0 : NS_ENSURE_ARG_POINTER(aParentWidget);
1456 :
1457 0 : *aParentWidget = mParentWidget;
1458 :
1459 0 : NS_IF_ADDREF(*aParentWidget);
1460 :
1461 0 : return NS_OK;
1462 : }
1463 :
1464 : NS_IMETHODIMP
1465 1 : nsWebBrowser::SetParentWidget(nsIWidget* aParentWidget)
1466 : {
1467 1 : NS_ENSURE_STATE(!mDocShell);
1468 :
1469 1 : mParentWidget = aParentWidget;
1470 1 : if (mParentWidget) {
1471 1 : mParentNativeWindow = mParentWidget->GetNativeData(NS_NATIVE_WIDGET);
1472 : } else {
1473 0 : mParentNativeWindow = nullptr;
1474 : }
1475 :
1476 1 : return NS_OK;
1477 : }
1478 :
1479 : NS_IMETHODIMP
1480 0 : nsWebBrowser::GetParentNativeWindow(nativeWindow* aParentNativeWindow)
1481 : {
1482 0 : NS_ENSURE_ARG_POINTER(aParentNativeWindow);
1483 :
1484 0 : *aParentNativeWindow = mParentNativeWindow;
1485 :
1486 0 : return NS_OK;
1487 : }
1488 :
1489 : NS_IMETHODIMP
1490 0 : nsWebBrowser::SetParentNativeWindow(nativeWindow aParentNativeWindow)
1491 : {
1492 0 : NS_ENSURE_STATE(!mDocShell);
1493 :
1494 0 : mParentNativeWindow = aParentNativeWindow;
1495 :
1496 0 : return NS_OK;
1497 : }
1498 :
1499 : NS_IMETHODIMP
1500 0 : nsWebBrowser::GetNativeHandle(nsAString& aNativeHandle)
1501 : {
1502 : // the nativeHandle should be accessed from nsIXULWindow
1503 0 : return NS_ERROR_NOT_IMPLEMENTED;
1504 : }
1505 :
1506 : NS_IMETHODIMP
1507 0 : nsWebBrowser::GetVisibility(bool* aVisibility)
1508 : {
1509 0 : NS_ENSURE_ARG_POINTER(aVisibility);
1510 :
1511 0 : if (!mDocShell) {
1512 0 : *aVisibility = mInitInfo->visible;
1513 : } else {
1514 0 : NS_ENSURE_SUCCESS(mDocShellAsWin->GetVisibility(aVisibility),
1515 : NS_ERROR_FAILURE);
1516 : }
1517 :
1518 0 : return NS_OK;
1519 : }
1520 :
1521 : NS_IMETHODIMP
1522 1 : nsWebBrowser::SetVisibility(bool aVisibility)
1523 : {
1524 1 : if (!mDocShell) {
1525 0 : mInitInfo->visible = aVisibility;
1526 : } else {
1527 1 : NS_ENSURE_SUCCESS(mDocShellAsWin->SetVisibility(aVisibility),
1528 : NS_ERROR_FAILURE);
1529 1 : if (mInternalWidget) {
1530 0 : mInternalWidget->Show(aVisibility);
1531 : }
1532 : }
1533 :
1534 1 : return NS_OK;
1535 : }
1536 :
1537 : NS_IMETHODIMP
1538 0 : nsWebBrowser::GetEnabled(bool* aEnabled)
1539 : {
1540 0 : if (mInternalWidget) {
1541 0 : *aEnabled = mInternalWidget->IsEnabled();
1542 0 : return NS_OK;
1543 : }
1544 :
1545 0 : return NS_ERROR_FAILURE;
1546 : }
1547 :
1548 : NS_IMETHODIMP
1549 0 : nsWebBrowser::SetEnabled(bool aEnabled)
1550 : {
1551 0 : if (mInternalWidget) {
1552 0 : mInternalWidget->Enable(aEnabled);
1553 0 : return NS_OK;
1554 : }
1555 0 : return NS_ERROR_FAILURE;
1556 : }
1557 :
1558 : NS_IMETHODIMP
1559 0 : nsWebBrowser::GetMainWidget(nsIWidget** aMainWidget)
1560 : {
1561 0 : NS_ENSURE_ARG_POINTER(aMainWidget);
1562 :
1563 0 : if (mInternalWidget) {
1564 0 : *aMainWidget = mInternalWidget;
1565 : } else {
1566 0 : *aMainWidget = mParentWidget;
1567 : }
1568 :
1569 0 : NS_IF_ADDREF(*aMainWidget);
1570 :
1571 0 : return NS_OK;
1572 : }
1573 :
1574 : NS_IMETHODIMP
1575 0 : nsWebBrowser::SetFocus()
1576 : {
1577 0 : nsCOMPtr<nsPIDOMWindowOuter> window = GetWindow();
1578 0 : NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
1579 :
1580 0 : nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
1581 0 : return fm ? fm->SetFocusedWindow(window) : NS_OK;
1582 : }
1583 :
1584 : NS_IMETHODIMP
1585 0 : nsWebBrowser::GetTitle(char16_t** aTitle)
1586 : {
1587 0 : NS_ENSURE_ARG_POINTER(aTitle);
1588 0 : NS_ENSURE_STATE(mDocShell);
1589 :
1590 0 : NS_ENSURE_SUCCESS(mDocShellAsWin->GetTitle(aTitle), NS_ERROR_FAILURE);
1591 :
1592 0 : return NS_OK;
1593 : }
1594 :
1595 : NS_IMETHODIMP
1596 0 : nsWebBrowser::SetTitle(const char16_t* aTitle)
1597 : {
1598 0 : NS_ENSURE_STATE(mDocShell);
1599 :
1600 0 : NS_ENSURE_SUCCESS(mDocShellAsWin->SetTitle(aTitle), NS_ERROR_FAILURE);
1601 :
1602 0 : return NS_OK;
1603 : }
1604 :
1605 : //*****************************************************************************
1606 : // nsWebBrowser::nsIScrollable
1607 : //*****************************************************************************
1608 :
1609 : NS_IMETHODIMP
1610 0 : nsWebBrowser::GetDefaultScrollbarPreferences(int32_t aScrollOrientation,
1611 : int32_t* aScrollbarPref)
1612 : {
1613 0 : NS_ENSURE_STATE(mDocShell);
1614 :
1615 0 : return mDocShellAsScrollable->GetDefaultScrollbarPreferences(
1616 0 : aScrollOrientation, aScrollbarPref);
1617 : }
1618 :
1619 : NS_IMETHODIMP
1620 0 : nsWebBrowser::SetDefaultScrollbarPreferences(int32_t aScrollOrientation,
1621 : int32_t aScrollbarPref)
1622 : {
1623 0 : NS_ENSURE_STATE(mDocShell);
1624 :
1625 0 : return mDocShellAsScrollable->SetDefaultScrollbarPreferences(
1626 0 : aScrollOrientation, aScrollbarPref);
1627 : }
1628 :
1629 : NS_IMETHODIMP
1630 0 : nsWebBrowser::GetScrollbarVisibility(bool* aVerticalVisible,
1631 : bool* aHorizontalVisible)
1632 : {
1633 0 : NS_ENSURE_STATE(mDocShell);
1634 :
1635 0 : return mDocShellAsScrollable->GetScrollbarVisibility(aVerticalVisible,
1636 0 : aHorizontalVisible);
1637 : }
1638 :
1639 : //*****************************************************************************
1640 : // nsWebBrowser::nsITextScroll
1641 : //*****************************************************************************
1642 :
1643 : NS_IMETHODIMP
1644 0 : nsWebBrowser::ScrollByLines(int32_t aNumLines)
1645 : {
1646 0 : NS_ENSURE_STATE(mDocShell);
1647 :
1648 0 : return mDocShellAsTextScroll->ScrollByLines(aNumLines);
1649 : }
1650 :
1651 : NS_IMETHODIMP
1652 0 : nsWebBrowser::ScrollByPages(int32_t aNumPages)
1653 : {
1654 0 : NS_ENSURE_STATE(mDocShell);
1655 :
1656 0 : return mDocShellAsTextScroll->ScrollByPages(aNumPages);
1657 : }
1658 :
1659 : //*****************************************************************************
1660 : // nsWebBrowser: Listener Helpers
1661 : //*****************************************************************************
1662 :
1663 : NS_IMETHODIMP
1664 1 : nsWebBrowser::SetDocShell(nsIDocShell* aDocShell)
1665 : {
1666 : // We need to keep the docshell alive while we perform the changes, but we
1667 : // don't need to call any methods on it.
1668 2 : nsCOMPtr<nsIDocShell> kungFuDeathGrip(mDocShell);
1669 : mozilla::Unused << kungFuDeathGrip;
1670 :
1671 1 : if (aDocShell) {
1672 1 : NS_ENSURE_TRUE(!mDocShell, NS_ERROR_FAILURE);
1673 :
1674 2 : nsCOMPtr<nsIInterfaceRequestor> req(do_QueryInterface(aDocShell));
1675 2 : nsCOMPtr<nsIBaseWindow> baseWin(do_QueryInterface(aDocShell));
1676 2 : nsCOMPtr<nsIWebNavigation> nav(do_QueryInterface(aDocShell));
1677 2 : nsCOMPtr<nsIScrollable> scrollable(do_QueryInterface(aDocShell));
1678 2 : nsCOMPtr<nsITextScroll> textScroll(do_QueryInterface(aDocShell));
1679 2 : nsCOMPtr<nsIWebProgress> progress(do_GetInterface(aDocShell));
1680 1 : NS_ENSURE_TRUE(req && baseWin && nav && scrollable && textScroll && progress,
1681 : NS_ERROR_FAILURE);
1682 :
1683 1 : mDocShell = aDocShell;
1684 1 : mDocShellAsReq = req;
1685 1 : mDocShellAsWin = baseWin;
1686 1 : mDocShellAsNav = nav;
1687 1 : mDocShellAsScrollable = scrollable;
1688 1 : mDocShellAsTextScroll = textScroll;
1689 1 : mWebProgress = progress;
1690 :
1691 : // By default, do not allow DNS prefetch, so we don't break our frozen
1692 : // API. Embeddors who decide to enable it should do so manually.
1693 1 : mDocShell->SetAllowDNSPrefetch(false);
1694 :
1695 : // It's possible to call setIsActive() on us before we have a docshell.
1696 : // If we're getting a docshell now, pass along our desired value. The
1697 : // default here (true) matches the default of the docshell, so this is
1698 : // a no-op unless setIsActive(false) has been called on us.
1699 1 : mDocShell->SetIsActive(mIsActive);
1700 : } else {
1701 0 : if (mDocShellTreeOwner) {
1702 0 : mDocShellTreeOwner->RemoveFromWatcher(); // evil twin of Add in Create()
1703 : }
1704 0 : if (mDocShellAsWin) {
1705 0 : mDocShellAsWin->Destroy();
1706 : }
1707 :
1708 0 : mDocShell = nullptr;
1709 0 : mDocShellAsReq = nullptr;
1710 0 : mDocShellAsWin = nullptr;
1711 0 : mDocShellAsNav = nullptr;
1712 0 : mDocShellAsScrollable = nullptr;
1713 0 : mDocShellAsTextScroll = nullptr;
1714 0 : mWebProgress = nullptr;
1715 : }
1716 :
1717 1 : return NS_OK;
1718 : }
1719 :
1720 : NS_IMETHODIMP
1721 2 : nsWebBrowser::EnsureDocShellTreeOwner()
1722 : {
1723 2 : if (mDocShellTreeOwner) {
1724 1 : return NS_OK;
1725 : }
1726 :
1727 1 : mDocShellTreeOwner = new nsDocShellTreeOwner();
1728 1 : mDocShellTreeOwner->WebBrowser(this);
1729 :
1730 1 : return NS_OK;
1731 : }
1732 :
1733 : static void
1734 0 : DrawPaintedLayer(PaintedLayer* aLayer,
1735 : gfxContext* aContext,
1736 : const nsIntRegion& aRegionToDraw,
1737 : const nsIntRegion& aDirtyRegion,
1738 : DrawRegionClip aClip,
1739 : const nsIntRegion& aRegionToInvalidate,
1740 : void* aCallbackData)
1741 : {
1742 0 : DrawTarget& aDrawTarget = *aContext->GetDrawTarget();
1743 :
1744 0 : ColorPattern color(ToDeviceColor(*static_cast<nscolor*>(aCallbackData)));
1745 0 : nsIntRect dirtyRect = aRegionToDraw.GetBounds();
1746 0 : aDrawTarget.FillRect(
1747 0 : Rect(dirtyRect.x, dirtyRect.y, dirtyRect.width, dirtyRect.height), color);
1748 0 : }
1749 :
1750 : void
1751 0 : nsWebBrowser::WindowRaised(nsIWidget* aWidget)
1752 : {
1753 : #if defined(DEBUG_smaug)
1754 : nsCOMPtr<nsIDocument> document = mDocShell->GetDocument();
1755 : nsAutoString documentURI;
1756 : document->GetDocumentURI(documentURI);
1757 : printf("nsWebBrowser::NS_ACTIVATE %p %s\n", (void*)this,
1758 : NS_ConvertUTF16toUTF8(documentURI).get());
1759 : #endif
1760 0 : Activate();
1761 0 : }
1762 :
1763 : void
1764 0 : nsWebBrowser::WindowLowered(nsIWidget* aWidget)
1765 : {
1766 : #if defined(DEBUG_smaug)
1767 : nsCOMPtr<nsIDocument> document = mDocShell->GetDocument();
1768 : nsAutoString documentURI;
1769 : document->GetDocumentURI(documentURI);
1770 : printf("nsWebBrowser::NS_DEACTIVATE %p %s\n", (void*)this,
1771 : NS_ConvertUTF16toUTF8(documentURI).get());
1772 : #endif
1773 0 : Deactivate();
1774 0 : }
1775 :
1776 : bool
1777 0 : nsWebBrowser::PaintWindow(nsIWidget* aWidget, LayoutDeviceIntRegion aRegion)
1778 : {
1779 0 : LayerManager* layerManager = aWidget->GetLayerManager();
1780 0 : NS_ASSERTION(layerManager, "Must be in paint event");
1781 :
1782 0 : layerManager->BeginTransaction();
1783 0 : RefPtr<PaintedLayer> root = layerManager->CreatePaintedLayer();
1784 0 : if (root) {
1785 0 : nsIntRect dirtyRect = aRegion.GetBounds().ToUnknownRect();
1786 0 : root->SetVisibleRegion(LayerIntRegion::FromUnknownRegion(dirtyRect));
1787 0 : layerManager->SetRoot(root);
1788 : }
1789 :
1790 0 : layerManager->EndTransaction(DrawPaintedLayer, &mBackgroundColor);
1791 0 : return true;
1792 : }
1793 : /*
1794 : NS_IMETHODIMP
1795 : nsWebBrowser::GetPrimaryContentWindow(mozIDOMWindowProxy** aDOMWindow)
1796 : {
1797 : *aDOMWindow = nullptr;
1798 :
1799 : nsCOMPtr<nsIDocShellTreeItem> item;
1800 : NS_ENSURE_TRUE(mDocShellTreeOwner, NS_ERROR_FAILURE);
1801 : mDocShellTreeOwner->GetPrimaryContentShell(getter_AddRefs(item));
1802 : NS_ENSURE_TRUE(item, NS_ERROR_FAILURE);
1803 :
1804 : nsCOMPtr<nsIDocShell> docShell;
1805 : docShell = do_QueryInterface(item);
1806 : NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
1807 :
1808 : nsCOMPtr<nsPIDOMWindowOuter> domWindow = docShell->GetWindow();
1809 : NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE);
1810 :
1811 : *aDOMWindow = domWindow;
1812 : NS_ADDREF(*aDOMWindow);
1813 : return NS_OK;
1814 : }
1815 : */
1816 : //*****************************************************************************
1817 : // nsWebBrowser::nsIWebBrowserFocus
1818 : //*****************************************************************************
1819 :
1820 : NS_IMETHODIMP
1821 1 : nsWebBrowser::Activate(void)
1822 : {
1823 2 : nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
1824 2 : nsCOMPtr<nsPIDOMWindowOuter> window = GetWindow();
1825 1 : if (fm && window) {
1826 1 : return fm->WindowRaised(window);
1827 : }
1828 0 : return NS_OK;
1829 : }
1830 :
1831 : NS_IMETHODIMP
1832 0 : nsWebBrowser::Deactivate(void)
1833 : {
1834 0 : nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
1835 0 : nsCOMPtr<nsPIDOMWindowOuter> window = GetWindow();
1836 0 : if (fm && window) {
1837 0 : return fm->WindowLowered(window);
1838 : }
1839 0 : return NS_OK;
1840 : }
1841 :
1842 : NS_IMETHODIMP
1843 0 : nsWebBrowser::SetFocusAtFirstElement(void)
1844 : {
1845 0 : return NS_OK;
1846 : }
1847 :
1848 : NS_IMETHODIMP
1849 0 : nsWebBrowser::SetFocusAtLastElement(void)
1850 : {
1851 0 : return NS_OK;
1852 : }
1853 :
1854 : NS_IMETHODIMP
1855 0 : nsWebBrowser::GetFocusedWindow(mozIDOMWindowProxy** aFocusedWindow)
1856 : {
1857 0 : NS_ENSURE_ARG_POINTER(aFocusedWindow);
1858 0 : *aFocusedWindow = nullptr;
1859 :
1860 0 : NS_ENSURE_TRUE(mDocShell, NS_ERROR_FAILURE);
1861 :
1862 0 : nsCOMPtr<nsPIDOMWindowOuter> window = mDocShell->GetWindow();
1863 0 : NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
1864 :
1865 0 : nsCOMPtr<nsIDOMElement> focusedElement;
1866 0 : nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
1867 0 : return fm ? fm->GetFocusedElementForWindow(window, true, aFocusedWindow,
1868 0 : getter_AddRefs(focusedElement)) :
1869 0 : NS_OK;
1870 : }
1871 :
1872 : NS_IMETHODIMP
1873 0 : nsWebBrowser::SetFocusedWindow(mozIDOMWindowProxy* aFocusedWindow)
1874 : {
1875 0 : nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
1876 0 : return fm ? fm->SetFocusedWindow(aFocusedWindow) : NS_OK;
1877 : }
1878 :
1879 : NS_IMETHODIMP
1880 0 : nsWebBrowser::GetFocusedElement(nsIDOMElement** aFocusedElement)
1881 : {
1882 0 : NS_ENSURE_ARG_POINTER(aFocusedElement);
1883 0 : NS_ENSURE_TRUE(mDocShell, NS_ERROR_FAILURE);
1884 :
1885 0 : nsCOMPtr<nsPIDOMWindowOuter> window = mDocShell->GetWindow();
1886 0 : NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
1887 :
1888 0 : nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
1889 : return
1890 0 : fm ? fm->GetFocusedElementForWindow(window, true, nullptr, aFocusedElement) :
1891 0 : NS_OK;
1892 : }
1893 :
1894 : NS_IMETHODIMP
1895 0 : nsWebBrowser::SetFocusedElement(nsIDOMElement* aFocusedElement)
1896 : {
1897 0 : nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
1898 0 : return fm ? fm->SetFocus(aFocusedElement, 0) : NS_OK;
1899 : }
1900 :
1901 : //*****************************************************************************
1902 : // nsWebBrowser::nsIWebBrowserStream
1903 : //*****************************************************************************
1904 :
1905 : NS_IMETHODIMP
1906 0 : nsWebBrowser::OpenStream(nsIURI* aBaseURI, const nsACString& aContentType)
1907 : {
1908 : nsresult rv;
1909 :
1910 0 : if (!mStream) {
1911 0 : mStream = new nsEmbedStream();
1912 0 : mStream->InitOwner(this);
1913 0 : rv = mStream->Init();
1914 0 : if (NS_FAILED(rv)) {
1915 0 : return rv;
1916 : }
1917 : }
1918 :
1919 0 : return mStream->OpenStream(aBaseURI, aContentType);
1920 : }
1921 :
1922 :
1923 : NS_IMETHODIMP
1924 0 : nsWebBrowser::AppendToStream(const uint8_t* aData, uint32_t aLen)
1925 : {
1926 0 : if (!mStream) {
1927 0 : return NS_ERROR_FAILURE;
1928 : }
1929 :
1930 0 : return mStream->AppendToStream(aData, aLen);
1931 : }
1932 :
1933 : NS_IMETHODIMP
1934 0 : nsWebBrowser::CloseStream()
1935 : {
1936 : nsresult rv;
1937 :
1938 0 : if (!mStream) {
1939 0 : return NS_ERROR_FAILURE;
1940 : }
1941 0 : rv = mStream->CloseStream();
1942 :
1943 0 : mStream = nullptr;
1944 :
1945 0 : return rv;
1946 : }
|
