LCOV - code coverage report
Current view: directory - embedding/browser/webBrowser - nsWebBrowser.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 868 0 0.0 %
Date: 2012-06-02 Functions: 116 0 0.0 %

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

Generated by: LCOV version 1.7