LCOV - app.info - dom/base/nsDOMWindowUtils.cpp

LCOV - code coverage report
| Current view: | directory - dom/base - nsDOMWindowUtils.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 1091 | 2 | 0.2 %
| Date: | 2012-04-21 | Functions: | 99 | 2 | 2.0 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           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 mozilla.org code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *
          24                 :  * Alternatively, the contents of this file may be used under the terms of
          25                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          26                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          27                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          28                 :  * of those above. If you wish to allow use of your version of this file only
          29                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          30                 :  * use your version of this file under the terms of the MPL, indicate your
          31                 :  * decision by deleting the provisions above and replace them with the notice
          32                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          33                 :  * the provisions above, a recipient may use your version of this file under
          34                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          35                 :  *
          36                 :  * ***** END LICENSE BLOCK ***** */
          37                 :
          38                 : #include "nsIDocShell.h"
          39                 : #include "nsPresContext.h"
          40                 : #include "nsDOMClassInfoID.h"
          41                 : #include "nsDOMError.h"
          42                 : #include "nsIDOMNSEvent.h"
          43                 : #include "nsIPrivateDOMEvent.h"
          44                 : #include "nsDOMWindowUtils.h"
          45                 : #include "nsQueryContentEventResult.h"
          46                 : #include "nsGlobalWindow.h"
          47                 : #include "nsIDocument.h"
          48                 : #include "nsFocusManager.h"
          49                 : #include "nsEventStateManager.h"
          50                 : #include "nsFrameManager.h"
          51                 : #include "nsRefreshDriver.h"
          52                 : #include "nsDOMTouchEvent.h"
          53                 : #include "nsIDOMTouchEvent.h"
          54                 :
          55                 : #include "nsIScrollableFrame.h"
          56                 :
          57                 : #include "nsContentUtils.h"
          58                 : #include "nsLayoutUtils.h"
          59                 :
          60                 : #include "nsIFrame.h"
          61                 : #include "nsIWidget.h"
          62                 : #include "nsGUIEvent.h"
          63                 : #include "nsIParser.h"
          64                 : #include "nsJSEnvironment.h"
          65                 : #include "nsJSUtils.h"
          66                 :
          67                 : #include "nsIViewManager.h"
          68                 :
          69                 : #include "nsIDOMHTMLCanvasElement.h"
          70                 : #include "gfxContext.h"
          71                 : #include "gfxImageSurface.h"
          72                 : #include "nsLayoutUtils.h"
          73                 : #include "nsComputedDOMStyle.h"
          74                 : #include "nsIPresShell.h"
          75                 : #include "nsStyleAnimation.h"
          76                 : #include "nsCSSProps.h"
          77                 : #include "nsDOMFile.h"
          78                 : #include "BasicLayers.h"
          79                 :
          80                 : #if defined(MOZ_X11) && defined(MOZ_WIDGET_GTK2)
          81                 : #include <gdk/gdk.h>
          82                 : #include <gdk/gdkx.h>
          83                 : #endif
          84                 :
          85                 : #include "Layers.h"
          86                 : #include "nsIIOService.h"
          87                 :
          88                 : #include "mozilla/dom/Element.h"
          89                 : #include "mozilla/dom/indexedDB/FileInfo.h"
          90                 : #include "mozilla/dom/indexedDB/IndexedDatabaseManager.h"
          91                 : #include "sampler.h"
          92                 :
          93                 : using namespace mozilla::dom;
          94                 : using namespace mozilla::layers;
          95                 : using namespace mozilla::widget;
          96                 :
          97               0 : static bool IsUniversalXPConnectCapable()
          98                 : {
          99               0 :   bool hasCap = false;
         100               0 :   nsresult rv = nsContentUtils::GetSecurityManager()->
         101               0 :                   IsCapabilityEnabled("UniversalXPConnect", &hasCap);
         102               0 :   NS_ENSURE_SUCCESS(rv, false);
         103               0 :   return hasCap;
         104                 : }
         105                 :
         106                 : DOMCI_DATA(WindowUtils, nsDOMWindowUtils)
         107                 :
         108            1396 : NS_IMPL_CYCLE_COLLECTION_CLASS(nsDOMWindowUtils)
         109               0 : NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsDOMWindowUtils)
         110               0 :   NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mWindow)
         111               0 : NS_IMPL_CYCLE_COLLECTION_UNLINK_END
         112               0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsDOMWindowUtils)
         113               0 :   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR_AMBIGUOUS(mWindow,
         114                 :                                                        nsIScriptGlobalObject)
         115               0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
         116                 :
         117               0 : NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsDOMWindowUtils)
         118               0 :   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMWindowUtils)
         119               0 :   NS_INTERFACE_MAP_ENTRY(nsIDOMWindowUtils)
         120               0 :   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
         121               0 :   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(WindowUtils)
         122               0 : NS_INTERFACE_MAP_END
         123                 :
         124               0 : NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDOMWindowUtils)
         125               0 : NS_IMPL_CYCLE_COLLECTING_RELEASE(nsDOMWindowUtils)
         126                 :
         127               0 : nsDOMWindowUtils::nsDOMWindowUtils(nsGlobalWindow *aWindow)
         128               0 :   : mWindow(aWindow)
         129                 : {
         130               0 :   NS_ASSERTION(mWindow->IsOuterWindow(), "How did that happen?");
         131               0 : }
         132                 :
         133               0 : nsDOMWindowUtils::~nsDOMWindowUtils()
         134                 : {
         135               0 : }
         136                 :
         137                 : nsIPresShell*
         138               0 : nsDOMWindowUtils::GetPresShell()
         139                 : {
         140               0 :   if (!mWindow)
         141               0 :     return nsnull;
         142                 :
         143               0 :   nsIDocShell *docShell = mWindow->GetDocShell();
         144               0 :   if (!docShell)
         145               0 :     return nsnull;
         146                 :
         147               0 :   nsCOMPtr<nsIPresShell> presShell;
         148               0 :   docShell->GetPresShell(getter_AddRefs(presShell));
         149               0 :   return presShell;
         150                 : }
         151                 :
         152                 : nsPresContext*
         153               0 : nsDOMWindowUtils::GetPresContext()
         154                 : {
         155               0 :   if (!mWindow)
         156               0 :     return nsnull;
         157               0 :   nsIDocShell *docShell = mWindow->GetDocShell();
         158               0 :   if (!docShell)
         159               0 :     return nsnull;
         160               0 :   nsRefPtr<nsPresContext> presContext;
         161               0 :   docShell->GetPresContext(getter_AddRefs(presContext));
         162               0 :   return presContext;
         163                 : }
         164                 :
         165                 : NS_IMETHODIMP
         166               0 : nsDOMWindowUtils::GetImageAnimationMode(PRUint16 *aMode)
         167                 : {
         168               0 :   NS_ENSURE_ARG_POINTER(aMode);
         169               0 :   *aMode = 0;
         170               0 :   nsPresContext* presContext = GetPresContext();
         171               0 :   if (presContext) {
         172               0 :     *aMode = presContext->ImageAnimationMode();
         173               0 :     return NS_OK;
         174                 :   }
         175               0 :   return NS_ERROR_NOT_AVAILABLE;
         176                 : }
         177                 :
         178                 : NS_IMETHODIMP
         179               0 : nsDOMWindowUtils::SetImageAnimationMode(PRUint16 aMode)
         180                 : {
         181               0 :   nsPresContext* presContext = GetPresContext();
         182               0 :   if (presContext) {
         183               0 :     presContext->SetImageAnimationMode(aMode);
         184               0 :     return NS_OK;
         185                 :   }
         186               0 :   return NS_ERROR_NOT_AVAILABLE;
         187                 : }
         188                 :
         189                 : NS_IMETHODIMP
         190               0 : nsDOMWindowUtils::GetDocCharsetIsForced(bool *aIsForced)
         191                 : {
         192               0 :   *aIsForced = false;
         193                 :
         194               0 :   if (!IsUniversalXPConnectCapable()) {
         195               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         196                 :   }
         197                 :
         198               0 :   if (mWindow) {
         199               0 :     nsCOMPtr<nsIDocument> doc(do_QueryInterface(mWindow->GetExtantDocument()));
         200                 :     *aIsForced = doc &&
         201               0 :       doc->GetDocumentCharacterSetSource() >= kCharsetFromParentForced;
         202                 :   }
         203               0 :   return NS_OK;
         204                 : }
         205                 :
         206                 : NS_IMETHODIMP
         207               0 : nsDOMWindowUtils::GetDocumentMetadata(const nsAString& aName,
         208                 :                                       nsAString& aValue)
         209                 : {
         210               0 :   if (!IsUniversalXPConnectCapable()) {
         211               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         212                 :   }
         213                 :
         214               0 :   if (mWindow) {
         215               0 :     nsCOMPtr<nsIDocument> doc(do_QueryInterface(mWindow->GetExtantDocument()));
         216               0 :     if (doc) {
         217               0 :       nsCOMPtr<nsIAtom> name = do_GetAtom(aName);
         218               0 :       doc->GetHeaderData(name, aValue);
         219               0 :       return NS_OK;
         220                 :     }
         221                 :   }
         222                 :
         223               0 :   aValue.Truncate();
         224               0 :   return NS_OK;
         225                 : }
         226                 :
         227                 : NS_IMETHODIMP
         228               0 : nsDOMWindowUtils::Redraw(PRUint32 aCount, PRUint32 *aDurationOut)
         229                 : {
         230               0 :   if (aCount == 0)
         231               0 :     aCount = 1;
         232                 :
         233               0 :   if (nsIPresShell* presShell = GetPresShell()) {
         234               0 :     nsIFrame *rootFrame = presShell->GetRootFrame();
         235                 :
         236               0 :     if (rootFrame) {
         237               0 :       nsRect r(nsPoint(0, 0), rootFrame->GetSize());
         238                 :
         239               0 :       PRIntervalTime iStart = PR_IntervalNow();
         240                 :
         241               0 :       for (PRUint32 i = 0; i < aCount; i++)
         242               0 :         rootFrame->InvalidateWithFlags(r, nsIFrame::INVALIDATE_IMMEDIATE);
         243                 :
         244                 : #if defined(MOZ_X11) && defined(MOZ_WIDGET_GTK2)
         245               0 :       XSync(GDK_DISPLAY(), False);
         246                 : #endif
         247                 :
         248               0 :       *aDurationOut = PR_IntervalToMilliseconds(PR_IntervalNow() - iStart);
         249                 :
         250               0 :       return NS_OK;
         251                 :     }
         252                 :   }
         253               0 :   return NS_ERROR_FAILURE;
         254                 : }
         255                 :
         256                 : NS_IMETHODIMP
         257               0 : nsDOMWindowUtils::SetCSSViewport(float aWidthPx, float aHeightPx)
         258                 : {
         259               0 :   if (!IsUniversalXPConnectCapable()) {
         260               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         261                 :   }
         262                 :
         263               0 :   if (!(aWidthPx >= 0.0 && aHeightPx >= 0.0)) {
         264               0 :     return NS_ERROR_ILLEGAL_VALUE;
         265                 :   }
         266                 :
         267               0 :   nsIPresShell* presShell = GetPresShell();
         268               0 :   if (!presShell) {
         269               0 :     return NS_ERROR_FAILURE;
         270                 :   }
         271                 :
         272               0 :   nscoord width = nsPresContext::CSSPixelsToAppUnits(aWidthPx);
         273               0 :   nscoord height = nsPresContext::CSSPixelsToAppUnits(aHeightPx);
         274                 :
         275               0 :   presShell->ResizeReflowOverride(width, height);
         276                 :
         277               0 :   return NS_OK;
         278                 : }
         279                 :
         280               0 : static void DestroyNsRect(void* aObject, nsIAtom* aPropertyName,
         281                 :                           void* aPropertyValue, void* aData)
         282                 : {
         283               0 :   nsRect* rect = static_cast<nsRect*>(aPropertyValue);
         284               0 :   delete rect;
         285               0 : }
         286                 :
         287                 : NS_IMETHODIMP
         288               0 : nsDOMWindowUtils::SetDisplayPortForElement(float aXPx, float aYPx,
         289                 :                                            float aWidthPx, float aHeightPx,
         290                 :                                            nsIDOMElement* aElement)
         291                 : {
         292               0 :   if (!IsUniversalXPConnectCapable()) {
         293               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         294                 :   }
         295                 :
         296               0 :   nsIPresShell* presShell = GetPresShell();
         297               0 :   if (!presShell) {
         298               0 :     return NS_ERROR_FAILURE;
         299                 :   }
         300                 :
         301                 :   nsRect displayport(nsPresContext::CSSPixelsToAppUnits(aXPx),
         302                 :                      nsPresContext::CSSPixelsToAppUnits(aYPx),
         303                 :                      nsPresContext::CSSPixelsToAppUnits(aWidthPx),
         304               0 :                      nsPresContext::CSSPixelsToAppUnits(aHeightPx));
         305                 :
         306               0 :   if (!aElement) {
         307               0 :     return NS_ERROR_INVALID_ARG;
         308                 :   }
         309                 :
         310               0 :   nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
         311                 :
         312               0 :   if (!content) {
         313               0 :     return NS_ERROR_INVALID_ARG;
         314                 :   }
         315                 :
         316               0 :   nsRect lastDisplayPort;
         317               0 :   if (nsLayoutUtils::GetDisplayPort(content, &lastDisplayPort) &&
         318               0 :       displayport.IsEqualInterior(lastDisplayPort)) {
         319               0 :     return NS_OK;
         320                 :   }
         321                 :
         322               0 :   content->SetProperty(nsGkAtoms::DisplayPort, new nsRect(displayport),
         323               0 :                        DestroyNsRect);
         324                 :
         325               0 :   nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
         326               0 :   if (rootScrollFrame) {
         327               0 :     if (content == rootScrollFrame->GetContent()) {
         328                 :       // We are setting a root displayport for a document.
         329                 :       // The pres shell needs a special flag set.
         330               0 :       presShell->SetIgnoreViewportScrolling(true);
         331                 :
         332                 :       // The root document currently has a widget, but we might end up
         333                 :       // painting content inside the displayport but outside the widget
         334                 :       // bounds. This ensures the document's view honors invalidations
         335                 :       // within the displayport.
         336               0 :       nsPresContext* presContext = GetPresContext();
         337               0 :       if (presContext && presContext->IsRoot()) {
         338               0 :         nsIFrame* rootFrame = presShell->GetRootFrame();
         339               0 :         nsIView* view = rootFrame->GetView();
         340               0 :         if (view) {
         341               0 :           view->SetInvalidationDimensions(&displayport);
         342                 :         }
         343                 :       }
         344                 :     }
         345                 :   }
         346                 :
         347               0 :   if (presShell) {
         348               0 :     nsIFrame* rootFrame = presShell->FrameManager()->GetRootFrame();
         349               0 :     if (rootFrame) {
         350                 :       nsIContent* rootContent =
         351               0 :         rootScrollFrame ? rootScrollFrame->GetContent() : nsnull;
         352               0 :       nsRect rootDisplayport;
         353                 :       bool usingDisplayport = rootContent &&
         354               0 :         nsLayoutUtils::GetDisplayPort(rootContent, &rootDisplayport);
         355                 :       rootFrame->InvalidateWithFlags(
         356               0 :         usingDisplayport ? rootDisplayport : rootFrame->GetVisualOverflowRect(),
         357               0 :         nsIFrame::INVALIDATE_NO_THEBES_LAYERS);
         358                 :
         359                 :       // Send empty paint transaction in order to release retained layers
         360               0 :       if (displayport.IsEmpty()) {
         361               0 :         nsCOMPtr<nsIWidget> widget = GetWidget();
         362               0 :         if (widget) {
         363                 :           bool isRetainingManager;
         364               0 :           LayerManager* manager = widget->GetLayerManager(&isRetainingManager);
         365               0 :           if (isRetainingManager) {
         366               0 :             manager->BeginTransaction();
         367               0 :             nsLayoutUtils::PaintFrame(nsnull, rootFrame, nsRegion(), NS_RGB(255, 255, 255),
         368                 :                                       nsLayoutUtils::PAINT_WIDGET_LAYERS |
         369               0 :                                       nsLayoutUtils::PAINT_EXISTING_TRANSACTION);
         370                 :           }
         371                 :         }
         372                 :       }
         373                 :     }
         374                 :   }
         375                 :
         376               0 :   return NS_OK;
         377                 : }
         378                 :
         379                 : NS_IMETHODIMP
         380               0 : nsDOMWindowUtils::SetResolution(float aXResolution, float aYResolution)
         381                 : {
         382               0 :   if (!IsUniversalXPConnectCapable()) {
         383               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         384                 :   }
         385                 :
         386               0 :   nsIPresShell* presShell = GetPresShell();
         387               0 :   return presShell ? presShell->SetResolution(aXResolution, aYResolution)
         388               0 :                    : NS_ERROR_FAILURE;
         389                 : }
         390                 :
         391                 : NS_IMETHODIMP
         392               0 : nsDOMWindowUtils::SendMouseEvent(const nsAString& aType,
         393                 :                                  float aX,
         394                 :                                  float aY,
         395                 :                                  PRInt32 aButton,
         396                 :                                  PRInt32 aClickCount,
         397                 :                                  PRInt32 aModifiers,
         398                 :                                  bool aIgnoreRootScrollFrame)
         399                 : {
         400                 :   return SendMouseEventCommon(aType, aX, aY, aButton, aClickCount, aModifiers,
         401               0 :                               aIgnoreRootScrollFrame, false);
         402                 : }
         403                 :
         404                 : NS_IMETHODIMP
         405               0 : nsDOMWindowUtils::SendMouseEventToWindow(const nsAString& aType,
         406                 :                                          float aX,
         407                 :                                          float aY,
         408                 :                                          PRInt32 aButton,
         409                 :                                          PRInt32 aClickCount,
         410                 :                                          PRInt32 aModifiers,
         411                 :                                          bool aIgnoreRootScrollFrame)
         412                 : {
         413                 :   return SendMouseEventCommon(aType, aX, aY, aButton, aClickCount, aModifiers,
         414               0 :                               aIgnoreRootScrollFrame, true);
         415                 : }
         416                 :
         417                 : NS_IMETHODIMP
         418               0 : nsDOMWindowUtils::SendMouseEventCommon(const nsAString& aType,
         419                 :                                        float aX,
         420                 :                                        float aY,
         421                 :                                        PRInt32 aButton,
         422                 :                                        PRInt32 aClickCount,
         423                 :                                        PRInt32 aModifiers,
         424                 :                                        bool aIgnoreRootScrollFrame,
         425                 :                                        bool aToWindow)
         426                 : {
         427               0 :   if (!IsUniversalXPConnectCapable()) {
         428               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         429                 :   }
         430                 :
         431                 :   // get the widget to send the event to
         432               0 :   nsPoint offset;
         433               0 :   nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
         434               0 :   if (!widget)
         435               0 :     return NS_ERROR_FAILURE;
         436                 :
         437                 :   PRInt32 msg;
         438               0 :   bool contextMenuKey = false;
         439               0 :   if (aType.EqualsLiteral("mousedown"))
         440               0 :     msg = NS_MOUSE_BUTTON_DOWN;
         441               0 :   else if (aType.EqualsLiteral("mouseup"))
         442               0 :     msg = NS_MOUSE_BUTTON_UP;
         443               0 :   else if (aType.EqualsLiteral("mousemove"))
         444               0 :     msg = NS_MOUSE_MOVE;
         445               0 :   else if (aType.EqualsLiteral("mouseover"))
         446               0 :     msg = NS_MOUSE_ENTER;
         447               0 :   else if (aType.EqualsLiteral("mouseout"))
         448               0 :     msg = NS_MOUSE_EXIT;
         449               0 :   else if (aType.EqualsLiteral("contextmenu")) {
         450               0 :     msg = NS_CONTEXTMENU;
         451               0 :     contextMenuKey = (aButton == 0);
         452                 :   } else
         453               0 :     return NS_ERROR_FAILURE;
         454                 :
         455                 :   nsMouseEvent event(true, msg, widget, nsMouseEvent::eReal,
         456                 :                      contextMenuKey ?
         457               0 :                        nsMouseEvent::eContextMenuKey : nsMouseEvent::eNormal);
         458               0 :   event.isShift = (aModifiers & nsIDOMNSEvent::SHIFT_MASK) ? true : false;
         459               0 :   event.isControl = (aModifiers & nsIDOMNSEvent::CONTROL_MASK) ? true : false;
         460               0 :   event.isAlt = (aModifiers & nsIDOMNSEvent::ALT_MASK) ? true : false;
         461               0 :   event.isMeta = (aModifiers & nsIDOMNSEvent::META_MASK) ? true : false;
         462               0 :   event.button = aButton;
         463               0 :   event.widget = widget;
         464                 :
         465               0 :   event.clickCount = aClickCount;
         466               0 :   event.time = PR_IntervalNow();
         467               0 :   event.flags |= NS_EVENT_FLAG_SYNTHETIC_TEST_EVENT;
         468                 :
         469               0 :   nsPresContext* presContext = GetPresContext();
         470               0 :   if (!presContext)
         471               0 :     return NS_ERROR_FAILURE;
         472                 :
         473               0 :   PRInt32 appPerDev = presContext->AppUnitsPerDevPixel();
         474                 :   event.refPoint.x =
         475               0 :     NSAppUnitsToIntPixels(nsPresContext::CSSPixelsToAppUnits(aX) + offset.x,
         476               0 :                           appPerDev);
         477                 :   event.refPoint.y =
         478               0 :     NSAppUnitsToIntPixels(nsPresContext::CSSPixelsToAppUnits(aY) + offset.y,
         479               0 :                           appPerDev);
         480               0 :   event.ignoreRootScrollFrame = aIgnoreRootScrollFrame;
         481                 :
         482                 :   nsEventStatus status;
         483               0 :   if (aToWindow) {
         484               0 :     nsCOMPtr<nsIPresShell> presShell = presContext->PresShell();
         485               0 :     if (!presShell)
         486               0 :       return NS_ERROR_FAILURE;
         487               0 :     nsIViewManager* viewManager = presShell->GetViewManager();
         488               0 :     if (!viewManager)
         489               0 :       return NS_ERROR_FAILURE;
         490               0 :     nsIView* view = viewManager->GetRootView();
         491               0 :     if (!view)
         492               0 :       return NS_ERROR_FAILURE;
         493                 :
         494               0 :     status = nsEventStatus_eIgnore;
         495               0 :     return presShell->HandleEvent(view->GetFrame(), &event, false, &status);
         496                 :   }
         497               0 :   return widget->DispatchEvent(&event, status);
         498                 : }
         499                 :
         500                 : NS_IMETHODIMP
         501               0 : nsDOMWindowUtils::SendMouseScrollEvent(const nsAString& aType,
         502                 :                                        float aX,
         503                 :                                        float aY,
         504                 :                                        PRInt32 aButton,
         505                 :                                        PRInt32 aScrollFlags,
         506                 :                                        PRInt32 aDelta,
         507                 :                                        PRInt32 aModifiers)
         508                 : {
         509               0 :   if (!IsUniversalXPConnectCapable()) {
         510               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         511                 :   }
         512                 :
         513                 :   // get the widget to send the event to
         514               0 :   nsPoint offset;
         515               0 :   nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
         516               0 :   if (!widget)
         517               0 :     return NS_ERROR_NULL_POINTER;
         518                 :
         519                 :   PRInt32 msg;
         520               0 :   if (aType.EqualsLiteral("DOMMouseScroll"))
         521               0 :     msg = NS_MOUSE_SCROLL;
         522               0 :   else if (aType.EqualsLiteral("MozMousePixelScroll"))
         523               0 :     msg = NS_MOUSE_PIXEL_SCROLL;
         524                 :   else
         525               0 :     return NS_ERROR_UNEXPECTED;
         526                 :
         527               0 :   nsMouseScrollEvent event(true, msg, widget);
         528               0 :   event.isShift = (aModifiers & nsIDOMNSEvent::SHIFT_MASK) ? true : false;
         529               0 :   event.isControl = (aModifiers & nsIDOMNSEvent::CONTROL_MASK) ? true : false;
         530               0 :   event.isAlt = (aModifiers & nsIDOMNSEvent::ALT_MASK) ? true : false;
         531               0 :   event.isMeta = (aModifiers & nsIDOMNSEvent::META_MASK) ? true : false;
         532               0 :   event.button = aButton;
         533               0 :   event.widget = widget;
         534               0 :   event.delta = aDelta;
         535               0 :   event.scrollFlags = aScrollFlags;
         536                 :
         537               0 :   event.time = PR_IntervalNow();
         538                 :
         539               0 :   nsPresContext* presContext = GetPresContext();
         540               0 :   if (!presContext)
         541               0 :     return NS_ERROR_FAILURE;
         542                 :
         543               0 :   PRInt32 appPerDev = presContext->AppUnitsPerDevPixel();
         544                 :   event.refPoint.x =
         545               0 :     NSAppUnitsToIntPixels(nsPresContext::CSSPixelsToAppUnits(aX) + offset.x,
         546               0 :                           appPerDev);
         547                 :   event.refPoint.y =
         548               0 :     NSAppUnitsToIntPixels(nsPresContext::CSSPixelsToAppUnits(aY) + offset.y,
         549               0 :                           appPerDev);
         550                 :
         551                 :   nsEventStatus status;
         552               0 :   return widget->DispatchEvent(&event, status);
         553                 : }
         554                 :
         555                 :
         556                 : NS_IMETHODIMP
         557               0 : nsDOMWindowUtils::SendTouchEvent(const nsAString& aType,
         558                 :                                  PRUint32 *aIdentifiers,
         559                 :                                  PRInt32 *aXs,
         560                 :                                  PRInt32 *aYs,
         561                 :                                  PRUint32 *aRxs,
         562                 :                                  PRUint32 *aRys,
         563                 :                                  float *aRotationAngles,
         564                 :                                  float *aForces,
         565                 :                                  PRUint32 aCount,
         566                 :                                  PRInt32 aModifiers,
         567                 :                                  bool aIgnoreRootScrollFrame,
         568                 :                                  bool *aPreventDefault)
         569                 : {
         570               0 :   if (!IsUniversalXPConnectCapable()) {
         571               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         572                 :   }
         573                 :
         574                 :   // get the widget to send the event to
         575               0 :   nsPoint offset;
         576               0 :   nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
         577               0 :   if (!widget) {
         578               0 :     return NS_ERROR_NULL_POINTER;
         579                 :   }
         580                 :   PRInt32 msg;
         581               0 :   if (aType.EqualsLiteral("touchstart")) {
         582               0 :     msg = NS_TOUCH_START;
         583               0 :   } else if (aType.EqualsLiteral("touchmove")) {
         584               0 :     msg = NS_TOUCH_MOVE;
         585               0 :   } else if (aType.EqualsLiteral("touchend")) {
         586               0 :     msg = NS_TOUCH_END;
         587               0 :   } else if (aType.EqualsLiteral("touchcancel")) {
         588               0 :     msg = NS_TOUCH_CANCEL;
         589                 :   } else {
         590               0 :     return NS_ERROR_UNEXPECTED;
         591                 :   }
         592               0 :   nsTouchEvent event(true, msg, widget);
         593               0 :   event.isShift = (aModifiers & nsIDOMNSEvent::SHIFT_MASK) ? true : false;
         594               0 :   event.isControl = (aModifiers & nsIDOMNSEvent::CONTROL_MASK) ? true : false;
         595               0 :   event.isAlt = (aModifiers & nsIDOMNSEvent::ALT_MASK) ? true : false;
         596               0 :   event.isMeta = (aModifiers & nsIDOMNSEvent::META_MASK) ? true : false;
         597               0 :   event.widget = widget;
         598               0 :   event.time = PR_Now();
         599                 :
         600               0 :   nsPresContext* presContext = GetPresContext();
         601               0 :   if (!presContext) {
         602               0 :     return NS_ERROR_FAILURE;
         603                 :   }
         604               0 :   event.touches.SetCapacity(aCount);
         605               0 :   PRInt32 appPerDev = presContext->AppUnitsPerDevPixel();
         606               0 :   for (PRUint32 i = 0; i < aCount; ++i) {
         607               0 :     nsIntPoint pt(0, 0);
         608                 :     pt.x =
         609               0 :       NSAppUnitsToIntPixels(nsPresContext::CSSPixelsToAppUnits(aXs[i]) + offset.x,
         610               0 :                             appPerDev);
         611                 :     pt.y =
         612               0 :       NSAppUnitsToIntPixels(nsPresContext::CSSPixelsToAppUnits(aYs[i]) + offset.y,
         613               0 :                             appPerDev);
         614               0 :     nsCOMPtr<nsIDOMTouch> t(new nsDOMTouch(aIdentifiers[i],
         615                 :                                            pt,
         616               0 :                                            nsIntPoint(aRxs[i], aRys[i]),
         617               0 :                                            aRotationAngles[i],
         618               0 :                                            aForces[i]));
         619               0 :     event.touches.AppendElement(t);
         620                 :   }
         621                 :
         622                 :   nsEventStatus status;
         623               0 :   nsresult rv = widget->DispatchEvent(&event, status);
         624               0 :   *aPreventDefault = (status == nsEventStatus_eConsumeNoDefault);
         625               0 :   return rv;
         626                 : }
         627                 :
         628                 : NS_IMETHODIMP
         629               0 : nsDOMWindowUtils::SendKeyEvent(const nsAString& aType,
         630                 :                                PRInt32 aKeyCode,
         631                 :                                PRInt32 aCharCode,
         632                 :                                PRInt32 aModifiers,
         633                 :                                bool aPreventDefault,
         634                 :                                bool* aDefaultActionTaken)
         635                 : {
         636               0 :   if (!IsUniversalXPConnectCapable()) {
         637               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         638                 :   }
         639                 :
         640                 :   // get the widget to send the event to
         641               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
         642               0 :   if (!widget)
         643               0 :     return NS_ERROR_FAILURE;
         644                 :
         645                 :   PRInt32 msg;
         646               0 :   if (aType.EqualsLiteral("keydown"))
         647               0 :     msg = NS_KEY_DOWN;
         648               0 :   else if (aType.EqualsLiteral("keyup"))
         649               0 :     msg = NS_KEY_UP;
         650               0 :   else if (aType.EqualsLiteral("keypress"))
         651               0 :     msg = NS_KEY_PRESS;
         652                 :   else
         653               0 :     return NS_ERROR_FAILURE;
         654                 :
         655               0 :   nsKeyEvent event(true, msg, widget);
         656               0 :   event.isShift = (aModifiers & nsIDOMNSEvent::SHIFT_MASK) ? true : false;
         657               0 :   event.isControl = (aModifiers & nsIDOMNSEvent::CONTROL_MASK) ? true : false;
         658               0 :   event.isAlt = (aModifiers & nsIDOMNSEvent::ALT_MASK) ? true : false;
         659               0 :   event.isMeta = (aModifiers & nsIDOMNSEvent::META_MASK) ? true : false;
         660                 :
         661               0 :   event.keyCode = aKeyCode;
         662               0 :   event.charCode = aCharCode;
         663               0 :   event.refPoint.x = event.refPoint.y = 0;
         664               0 :   event.time = PR_IntervalNow();
         665                 :
         666               0 :   if (aPreventDefault) {
         667               0 :     event.flags |= NS_EVENT_FLAG_NO_DEFAULT;
         668                 :   }
         669                 :
         670                 :   nsEventStatus status;
         671               0 :   nsresult rv = widget->DispatchEvent(&event, status);
         672               0 :   NS_ENSURE_SUCCESS(rv, rv);
         673                 :
         674               0 :   *aDefaultActionTaken = (status != nsEventStatus_eConsumeNoDefault);
         675                 :
         676               0 :   return NS_OK;
         677                 : }
         678                 :
         679                 : NS_IMETHODIMP
         680               0 : nsDOMWindowUtils::SendNativeKeyEvent(PRInt32 aNativeKeyboardLayout,
         681                 :                                      PRInt32 aNativeKeyCode,
         682                 :                                      PRInt32 aModifiers,
         683                 :                                      const nsAString& aCharacters,
         684                 :                                      const nsAString& aUnmodifiedCharacters)
         685                 : {
         686               0 :   if (!IsUniversalXPConnectCapable()) {
         687               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         688                 :   }
         689                 :
         690                 :   // get the widget to send the event to
         691               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
         692               0 :   if (!widget)
         693               0 :     return NS_ERROR_FAILURE;
         694                 :
         695               0 :   return widget->SynthesizeNativeKeyEvent(aNativeKeyboardLayout, aNativeKeyCode,
         696               0 :                                           aModifiers, aCharacters, aUnmodifiedCharacters);
         697                 : }
         698                 :
         699                 : NS_IMETHODIMP
         700               0 : nsDOMWindowUtils::SendNativeMouseEvent(PRInt32 aScreenX,
         701                 :                                        PRInt32 aScreenY,
         702                 :                                        PRInt32 aNativeMessage,
         703                 :                                        PRInt32 aModifierFlags,
         704                 :                                        nsIDOMElement* aElement)
         705                 : {
         706               0 :   if (!IsUniversalXPConnectCapable()) {
         707               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         708                 :   }
         709                 :
         710                 :   // get the widget to send the event to
         711               0 :   nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement);
         712               0 :   if (!widget)
         713               0 :     return NS_ERROR_FAILURE;
         714                 :
         715               0 :   return widget->SynthesizeNativeMouseEvent(nsIntPoint(aScreenX, aScreenY),
         716               0 :                                             aNativeMessage, aModifierFlags);
         717                 : }
         718                 :
         719                 : NS_IMETHODIMP
         720               0 : nsDOMWindowUtils::ActivateNativeMenuItemAt(const nsAString& indexString)
         721                 : {
         722               0 :   if (!IsUniversalXPConnectCapable()) {
         723               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         724                 :   }
         725                 :
         726                 :   // get the widget to send the event to
         727               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
         728               0 :   if (!widget)
         729               0 :     return NS_ERROR_FAILURE;
         730                 :
         731               0 :   return widget->ActivateNativeMenuItemAt(indexString);
         732                 : }
         733                 :
         734                 : NS_IMETHODIMP
         735               0 : nsDOMWindowUtils::ForceUpdateNativeMenuAt(const nsAString& indexString)
         736                 : {
         737               0 :   if (!IsUniversalXPConnectCapable()) {
         738               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         739                 :   }
         740                 :
         741                 :   // get the widget to send the event to
         742               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
         743               0 :   if (!widget)
         744               0 :     return NS_ERROR_FAILURE;
         745                 :
         746               0 :   return widget->ForceUpdateNativeMenuAt(indexString);
         747                 : }
         748                 :
         749                 : nsIWidget*
         750               0 : nsDOMWindowUtils::GetWidget(nsPoint* aOffset)
         751                 : {
         752               0 :   if (mWindow) {
         753               0 :     nsIDocShell *docShell = mWindow->GetDocShell();
         754               0 :     if (docShell) {
         755               0 :       nsCOMPtr<nsIPresShell> presShell;
         756               0 :       docShell->GetPresShell(getter_AddRefs(presShell));
         757               0 :       if (presShell) {
         758               0 :         nsIFrame* frame = presShell->GetRootFrame();
         759               0 :         if (frame)
         760               0 :           return frame->GetView()->GetNearestWidget(aOffset);
         761                 :       }
         762                 :     }
         763                 :   }
         764                 :
         765               0 :   return nsnull;
         766                 : }
         767                 :
         768                 : nsIWidget*
         769               0 : nsDOMWindowUtils::GetWidgetForElement(nsIDOMElement* aElement)
         770                 : {
         771               0 :   if (!aElement)
         772               0 :     return GetWidget();
         773                 :
         774               0 :   nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
         775               0 :   nsIDocument* doc = content->GetCurrentDoc();
         776               0 :   nsIPresShell* presShell = doc ? doc->GetShell() : nsnull;
         777                 :
         778               0 :   if (presShell) {
         779               0 :     nsIFrame* frame = content->GetPrimaryFrame();
         780               0 :     if (!frame) {
         781               0 :       frame = presShell->GetRootFrame();
         782                 :     }
         783               0 :     if (frame)
         784               0 :       return frame->GetNearestWidget();
         785                 :   }
         786                 :
         787               0 :   return nsnull;
         788                 : }
         789                 :
         790                 : NS_IMETHODIMP
         791               0 : nsDOMWindowUtils::Focus(nsIDOMElement* aElement)
         792                 : {
         793               0 :   if (!IsUniversalXPConnectCapable()) {
         794               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         795                 :   }
         796                 :
         797               0 :   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
         798               0 :   if (fm) {
         799               0 :     if (aElement)
         800               0 :       fm->SetFocus(aElement, 0);
         801                 :     else
         802               0 :       fm->ClearFocus(mWindow);
         803                 :   }
         804                 :
         805               0 :   return NS_OK;
         806                 : }
         807                 :
         808                 : NS_IMETHODIMP
         809               0 : nsDOMWindowUtils::GarbageCollect(nsICycleCollectorListener *aListener,
         810                 :                                  PRInt32 aExtraForgetSkippableCalls)
         811                 : {
         812               0 :   SAMPLE_LABEL("GC", "GarbageCollect");
         813                 :   // Always permit this in debug builds.
         814                 : #ifndef DEBUG
         815                 :   if (!IsUniversalXPConnectCapable()) {
         816                 :     return NS_ERROR_DOM_SECURITY_ERR;
         817                 :   }
         818                 : #endif
         819                 :
         820               0 :   nsJSContext::GarbageCollectNow(js::gcreason::DOM_UTILS);
         821               0 :   nsJSContext::CycleCollectNow(aListener, aExtraForgetSkippableCalls);
         822                 :
         823               0 :   return NS_OK;
         824                 : }
         825                 :
         826                 : NS_IMETHODIMP
         827               0 : nsDOMWindowUtils::CycleCollect(nsICycleCollectorListener *aListener,
         828                 :                                PRInt32 aExtraForgetSkippableCalls)
         829                 : {
         830                 :   // Always permit this in debug builds.
         831                 : #ifndef DEBUG
         832                 :   if (!IsUniversalXPConnectCapable()) {
         833                 :     return NS_ERROR_DOM_SECURITY_ERR;
         834                 :   }
         835                 : #endif
         836                 :
         837               0 :   nsJSContext::CycleCollectNow(aListener, aExtraForgetSkippableCalls);
         838               0 :   return NS_OK;
         839                 : }
         840                 :
         841                 : NS_IMETHODIMP
         842               0 : nsDOMWindowUtils::SendSimpleGestureEvent(const nsAString& aType,
         843                 :                                          float aX,
         844                 :                                          float aY,
         845                 :                                          PRUint32 aDirection,
         846                 :                                          PRFloat64 aDelta,
         847                 :                                          PRInt32 aModifiers)
         848                 : {
         849               0 :   if (!IsUniversalXPConnectCapable()) {
         850               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         851                 :   }
         852                 :
         853                 :   // get the widget to send the event to
         854               0 :   nsPoint offset;
         855               0 :   nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
         856               0 :   if (!widget)
         857               0 :     return NS_ERROR_FAILURE;
         858                 :
         859                 :   PRInt32 msg;
         860               0 :   if (aType.EqualsLiteral("MozSwipeGesture"))
         861               0 :     msg = NS_SIMPLE_GESTURE_SWIPE;
         862               0 :   else if (aType.EqualsLiteral("MozMagnifyGestureStart"))
         863               0 :     msg = NS_SIMPLE_GESTURE_MAGNIFY_START;
         864               0 :   else if (aType.EqualsLiteral("MozMagnifyGestureUpdate"))
         865               0 :     msg = NS_SIMPLE_GESTURE_MAGNIFY_UPDATE;
         866               0 :   else if (aType.EqualsLiteral("MozMagnifyGesture"))
         867               0 :     msg = NS_SIMPLE_GESTURE_MAGNIFY;
         868               0 :   else if (aType.EqualsLiteral("MozRotateGestureStart"))
         869               0 :     msg = NS_SIMPLE_GESTURE_ROTATE_START;
         870               0 :   else if (aType.EqualsLiteral("MozRotateGestureUpdate"))
         871               0 :     msg = NS_SIMPLE_GESTURE_ROTATE_UPDATE;
         872               0 :   else if (aType.EqualsLiteral("MozRotateGesture"))
         873               0 :     msg = NS_SIMPLE_GESTURE_ROTATE;
         874               0 :   else if (aType.EqualsLiteral("MozTapGesture"))
         875               0 :     msg = NS_SIMPLE_GESTURE_TAP;
         876               0 :   else if (aType.EqualsLiteral("MozPressTapGesture"))
         877               0 :     msg = NS_SIMPLE_GESTURE_PRESSTAP;
         878                 :   else
         879               0 :     return NS_ERROR_FAILURE;
         880                 :
         881               0 :   nsSimpleGestureEvent event(true, msg, widget, aDirection, aDelta);
         882               0 :   event.isShift = (aModifiers & nsIDOMNSEvent::SHIFT_MASK) ? true : false;
         883               0 :   event.isControl = (aModifiers & nsIDOMNSEvent::CONTROL_MASK) ? true : false;
         884               0 :   event.isAlt = (aModifiers & nsIDOMNSEvent::ALT_MASK) ? true : false;
         885               0 :   event.isMeta = (aModifiers & nsIDOMNSEvent::META_MASK) ? true : false;
         886               0 :   event.time = PR_IntervalNow();
         887                 :
         888               0 :   nsPresContext* presContext = GetPresContext();
         889               0 :   if (!presContext)
         890               0 :     return NS_ERROR_FAILURE;
         891                 :
         892               0 :   PRInt32 appPerDev = presContext->AppUnitsPerDevPixel();
         893                 :   event.refPoint.x =
         894               0 :     NSAppUnitsToIntPixels(nsPresContext::CSSPixelsToAppUnits(aX) + offset.x,
         895               0 :                           appPerDev);
         896                 :   event.refPoint.y =
         897               0 :     NSAppUnitsToIntPixels(nsPresContext::CSSPixelsToAppUnits(aY) + offset.y,
         898               0 :                           appPerDev);
         899                 :
         900                 :   nsEventStatus status;
         901               0 :   return widget->DispatchEvent(&event, status);
         902                 : }
         903                 :
         904                 : NS_IMETHODIMP
         905               0 : nsDOMWindowUtils::ElementFromPoint(float aX, float aY,
         906                 :                                    bool aIgnoreRootScrollFrame,
         907                 :                                    bool aFlushLayout,
         908                 :                                    nsIDOMElement** aReturn)
         909                 : {
         910               0 :   nsCOMPtr<nsIDocument> doc(do_QueryInterface(mWindow->GetExtantDocument()));
         911               0 :   NS_ENSURE_STATE(doc);
         912                 :
         913               0 :   return doc->ElementFromPointHelper(aX, aY, aIgnoreRootScrollFrame, aFlushLayout,
         914               0 :                                      aReturn);
         915                 : }
         916                 :
         917                 : NS_IMETHODIMP
         918               0 : nsDOMWindowUtils::NodesFromRect(float aX, float aY,
         919                 :                                 float aTopSize, float aRightSize,
         920                 :                                 float aBottomSize, float aLeftSize,
         921                 :                                 bool aIgnoreRootScrollFrame,
         922                 :                                 bool aFlushLayout,
         923                 :                                 nsIDOMNodeList** aReturn)
         924                 : {
         925               0 :   if (!IsUniversalXPConnectCapable()) {
         926               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         927                 :   }
         928                 :
         929               0 :   nsCOMPtr<nsIDocument> doc(do_QueryInterface(mWindow->GetExtantDocument()));
         930               0 :   NS_ENSURE_STATE(doc);
         931                 :
         932               0 :   return doc->NodesFromRectHelper(aX, aY, aTopSize, aRightSize, aBottomSize, aLeftSize,
         933               0 :                                   aIgnoreRootScrollFrame, aFlushLayout, aReturn);
         934                 : }
         935                 :
         936                 : static already_AddRefed<gfxImageSurface>
         937               0 : CanvasToImageSurface(nsIDOMHTMLCanvasElement* aCanvas)
         938                 : {
         939               0 :   nsCOMPtr<nsINode> node = do_QueryInterface(aCanvas);
         940               0 :   if (!node) {
         941               0 :     return nsnull;
         942                 :   }
         943                 :
         944               0 :   NS_ABORT_IF_FALSE(node->IsElement(),
         945                 :                     "An nsINode that implements nsIDOMHTMLCanvasElement should "
         946                 :                     "be an element.");
         947                 :   nsLayoutUtils::SurfaceFromElementResult result =
         948                 :     nsLayoutUtils::SurfaceFromElement(node->AsElement(),
         949               0 :                                       nsLayoutUtils::SFE_WANT_IMAGE_SURFACE);
         950               0 :   return static_cast<gfxImageSurface*>(result.mSurface.forget().get());
         951                 : }
         952                 :
         953                 : NS_IMETHODIMP
         954               0 : nsDOMWindowUtils::CompareCanvases(nsIDOMHTMLCanvasElement *aCanvas1,
         955                 :                                   nsIDOMHTMLCanvasElement *aCanvas2,
         956                 :                                   PRUint32* aMaxDifference,
         957                 :                                   PRUint32* retVal)
         958                 : {
         959               0 :   if (!IsUniversalXPConnectCapable()) {
         960               0 :     return NS_ERROR_DOM_SECURITY_ERR;
         961                 :   }
         962                 :
         963               0 :   if (aCanvas1 == nsnull ||
         964                 :       aCanvas2 == nsnull ||
         965                 :       retVal == nsnull)
         966               0 :     return NS_ERROR_FAILURE;
         967                 :
         968               0 :   nsRefPtr<gfxImageSurface> img1 = CanvasToImageSurface(aCanvas1);
         969               0 :   nsRefPtr<gfxImageSurface> img2 = CanvasToImageSurface(aCanvas2);
         970                 :
         971               0 :   if (img1 == nsnull || img2 == nsnull ||
         972               0 :       img1->GetSize() != img2->GetSize() ||
         973               0 :       img1->Stride() != img2->Stride())
         974               0 :     return NS_ERROR_FAILURE;
         975                 :
         976                 :   int v;
         977               0 :   gfxIntSize size = img1->GetSize();
         978               0 :   PRUint32 stride = img1->Stride();
         979                 :
         980                 :   // we can optimize for the common all-pass case
         981               0 :   if (stride == (PRUint32) size.width * 4) {
         982               0 :     v = memcmp(img1->Data(), img2->Data(), size.width * size.height * 4);
         983               0 :     if (v == 0) {
         984               0 :       if (aMaxDifference)
         985               0 :         *aMaxDifference = 0;
         986               0 :       *retVal = 0;
         987               0 :       return NS_OK;
         988                 :     }
         989                 :   }
         990                 :
         991               0 :   PRUint32 dc = 0;
         992               0 :   PRUint32 different = 0;
         993                 :
         994               0 :   for (int j = 0; j < size.height; j++) {
         995               0 :     unsigned char *p1 = img1->Data() + j*stride;
         996               0 :     unsigned char *p2 = img2->Data() + j*stride;
         997               0 :     v = memcmp(p1, p2, stride);
         998                 :
         999               0 :     if (v) {
        1000               0 :       for (int i = 0; i < size.width; i++) {
        1001               0 :         if (*(PRUint32*) p1 != *(PRUint32*) p2) {
        1002                 :
        1003               0 :           different++;
        1004                 :
        1005               0 :           dc = NS_MAX((PRUint32)abs(p1[0] - p2[0]), dc);
        1006               0 :           dc = NS_MAX((PRUint32)abs(p1[1] - p2[1]), dc);
        1007               0 :           dc = NS_MAX((PRUint32)abs(p1[2] - p2[2]), dc);
        1008               0 :           dc = NS_MAX((PRUint32)abs(p1[3] - p2[3]), dc);
        1009                 :         }
        1010                 :
        1011               0 :         p1 += 4;
        1012               0 :         p2 += 4;
        1013                 :       }
        1014                 :     }
        1015                 :   }
        1016                 :
        1017               0 :   if (aMaxDifference)
        1018               0 :     *aMaxDifference = dc;
        1019                 :
        1020               0 :   *retVal = different;
        1021               0 :   return NS_OK;
        1022                 : }
        1023                 :
        1024                 : NS_IMETHODIMP
        1025               0 : nsDOMWindowUtils::GetIsMozAfterPaintPending(bool *aResult)
        1026                 : {
        1027               0 :   *aResult = false;
        1028               0 :   nsPresContext* presContext = GetPresContext();
        1029               0 :   if (!presContext)
        1030               0 :     return NS_OK;
        1031               0 :   *aResult = presContext->IsDOMPaintEventPending();
        1032               0 :   return NS_OK;
        1033                 : }
        1034                 :
        1035                 : NS_IMETHODIMP
        1036               0 : nsDOMWindowUtils::ClearMozAfterPaintEvents()
        1037                 : {
        1038               0 :   nsPresContext* presContext = GetPresContext();
        1039               0 :   if (!presContext)
        1040               0 :     return NS_OK;
        1041               0 :   presContext->ClearMozAfterPaintEvents();
        1042               0 :   return NS_OK;
        1043                 : }
        1044                 :
        1045                 : NS_IMETHODIMP
        1046               0 : nsDOMWindowUtils::DisableNonTestMouseEvents(bool aDisable)
        1047                 : {
        1048               0 :   if (!IsUniversalXPConnectCapable()) {
        1049               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1050                 :   }
        1051                 :
        1052               0 :   NS_ENSURE_TRUE(mWindow, NS_ERROR_FAILURE);
        1053               0 :   nsIDocShell *docShell = mWindow->GetDocShell();
        1054               0 :   NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
        1055               0 :   nsCOMPtr<nsIPresShell> presShell;
        1056               0 :   docShell->GetPresShell(getter_AddRefs(presShell));
        1057               0 :   NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
        1058               0 :   presShell->DisableNonTestMouseEvents(aDisable);
        1059               0 :   return NS_OK;
        1060                 : }
        1061                 :
        1062                 : NS_IMETHODIMP
        1063               0 : nsDOMWindowUtils::SuppressEventHandling(bool aSuppress)
        1064                 : {
        1065               0 :   if (!IsUniversalXPConnectCapable()) {
        1066               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1067                 :   }
        1068                 :
        1069               0 :   nsCOMPtr<nsIDocument> doc(do_QueryInterface(mWindow->GetExtantDocument()));
        1070               0 :   NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
        1071                 :
        1072               0 :   if (aSuppress) {
        1073               0 :     doc->SuppressEventHandling();
        1074                 :   } else {
        1075               0 :     doc->UnsuppressEventHandlingAndFireEvents(true);
        1076                 :   }
        1077                 :
        1078               0 :   return NS_OK;
        1079                 : }
        1080                 :
        1081                 : NS_IMETHODIMP
        1082               0 : nsDOMWindowUtils::GetScrollXY(bool aFlushLayout, PRInt32* aScrollX, PRInt32* aScrollY)
        1083                 : {
        1084               0 :   nsCOMPtr<nsIDocument> doc(do_QueryInterface(mWindow->GetExtantDocument()));
        1085               0 :   NS_ENSURE_STATE(doc);
        1086                 :
        1087               0 :   if (aFlushLayout) {
        1088               0 :     doc->FlushPendingNotifications(Flush_Layout);
        1089                 :   }
        1090                 :
        1091               0 :   nsPoint scrollPos(0,0);
        1092               0 :   nsIPresShell *presShell = doc->GetShell();
        1093               0 :   if (presShell) {
        1094               0 :     nsIScrollableFrame* sf = presShell->GetRootScrollFrameAsScrollable();
        1095               0 :     if (sf) {
        1096               0 :       scrollPos = sf->GetScrollPosition();
        1097                 :     }
        1098                 :   }
        1099                 :
        1100               0 :   *aScrollX = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.x);
        1101               0 :   *aScrollY = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.y);
        1102                 :
        1103               0 :   return NS_OK;
        1104                 : }
        1105                 :
        1106                 : NS_IMETHODIMP
        1107               0 : nsDOMWindowUtils::GetIMEIsOpen(bool *aState)
        1108                 : {
        1109               0 :   NS_ENSURE_ARG_POINTER(aState);
        1110                 :
        1111               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1112               0 :   if (!widget)
        1113               0 :     return NS_ERROR_FAILURE;
        1114                 :
        1115                 :   // Open state should not be available when IME is not enabled.
        1116               0 :   InputContext context = widget->GetInputContext();
        1117               0 :   if (context.mIMEState.mEnabled != IMEState::ENABLED) {
        1118               0 :     return NS_ERROR_NOT_AVAILABLE;
        1119                 :   }
        1120                 :
        1121               0 :   if (context.mIMEState.mOpen == IMEState::OPEN_STATE_NOT_SUPPORTED) {
        1122               0 :     return NS_ERROR_NOT_IMPLEMENTED;
        1123                 :   }
        1124               0 :   *aState = (context.mIMEState.mOpen == IMEState::OPEN);
        1125               0 :   return NS_OK;
        1126                 : }
        1127                 :
        1128                 : NS_IMETHODIMP
        1129               0 : nsDOMWindowUtils::GetIMEStatus(PRUint32 *aState)
        1130                 : {
        1131               0 :   NS_ENSURE_ARG_POINTER(aState);
        1132                 :
        1133               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1134               0 :   if (!widget)
        1135               0 :     return NS_ERROR_FAILURE;
        1136                 :
        1137               0 :   InputContext context = widget->GetInputContext();
        1138               0 :   *aState = static_cast<PRUint32>(context.mIMEState.mEnabled);
        1139               0 :   return NS_OK;
        1140                 : }
        1141                 :
        1142                 : NS_IMETHODIMP
        1143               0 : nsDOMWindowUtils::GetFocusedInputType(char** aType)
        1144                 : {
        1145               0 :   NS_ENSURE_ARG_POINTER(aType);
        1146                 :
        1147               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1148               0 :   if (!widget) {
        1149               0 :     return NS_ERROR_FAILURE;
        1150                 :   }
        1151                 :
        1152               0 :   InputContext context = widget->GetInputContext();
        1153               0 :   *aType = ToNewCString(context.mHTMLInputType);
        1154               0 :   return NS_OK;
        1155                 : }
        1156                 :
        1157                 : NS_IMETHODIMP
        1158               0 : nsDOMWindowUtils::FindElementWithViewId(nsViewID aID,
        1159                 :                                         nsIDOMElement** aResult)
        1160                 : {
        1161               0 :   if (aID == FrameMetrics::ROOT_SCROLL_ID) {
        1162               0 :     nsPresContext* presContext = GetPresContext();
        1163               0 :     if (!presContext) {
        1164               0 :       return NS_ERROR_NOT_AVAILABLE;
        1165                 :     }
        1166                 :
        1167               0 :     nsIDocument* document = presContext->Document();
        1168               0 :     mozilla::dom::Element* rootElement = document->GetRootElement();
        1169               0 :     if (!rootElement) {
        1170               0 :       return NS_ERROR_NOT_AVAILABLE;
        1171                 :     }
        1172                 :
        1173               0 :     CallQueryInterface(rootElement, aResult);
        1174               0 :     return NS_OK;
        1175                 :   }
        1176                 :
        1177               0 :   nsRefPtr<nsIContent> content = nsLayoutUtils::FindContentFor(aID);
        1178               0 :   return content ? CallQueryInterface(content, aResult) : NS_OK;
        1179                 : }
        1180                 :
        1181                 : NS_IMETHODIMP
        1182               0 : nsDOMWindowUtils::GetScreenPixelsPerCSSPixel(float* aScreenPixels)
        1183                 : {
        1184               0 :   *aScreenPixels = 1;
        1185                 :
        1186               0 :   if (!nsContentUtils::IsCallerTrustedForRead())
        1187               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1188               0 :   nsPresContext* presContext = GetPresContext();
        1189               0 :   if (!presContext)
        1190               0 :     return NS_OK;
        1191                 :
        1192               0 :   *aScreenPixels = float(nsPresContext::AppUnitsPerCSSPixel())/
        1193               0 :       presContext->AppUnitsPerDevPixel();
        1194               0 :   return NS_OK;
        1195                 : }
        1196                 :
        1197                 : NS_IMETHODIMP
        1198               0 : nsDOMWindowUtils::DispatchDOMEventViaPresShell(nsIDOMNode* aTarget,
        1199                 :                                                nsIDOMEvent* aEvent,
        1200                 :                                                bool aTrusted,
        1201                 :                                                bool* aRetVal)
        1202                 : {
        1203               0 :   if (!nsContentUtils::IsCallerTrustedForRead()) {
        1204               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1205                 :   }
        1206                 :
        1207               0 :   nsPresContext* presContext = GetPresContext();
        1208               0 :   NS_ENSURE_STATE(presContext);
        1209               0 :   nsCOMPtr<nsIPresShell> shell = presContext->GetPresShell();
        1210               0 :   NS_ENSURE_STATE(shell);
        1211               0 :   nsCOMPtr<nsIPrivateDOMEvent> event = do_QueryInterface(aEvent);
        1212               0 :   NS_ENSURE_STATE(event);
        1213               0 :   event->SetTrusted(aTrusted);
        1214               0 :   nsEvent* internalEvent = event->GetInternalNSEvent();
        1215               0 :   NS_ENSURE_STATE(internalEvent);
        1216               0 :   nsCOMPtr<nsIContent> content = do_QueryInterface(aTarget);
        1217               0 :   NS_ENSURE_STATE(content);
        1218                 :
        1219               0 :   nsEventStatus status = nsEventStatus_eIgnore;
        1220               0 :   shell->HandleEventWithTarget(internalEvent, nsnull, content,
        1221               0 :                                &status);
        1222               0 :   *aRetVal = (status != nsEventStatus_eConsumeNoDefault);
        1223               0 :   return NS_OK;
        1224                 : }
        1225                 :
        1226                 : static void
        1227               0 : InitEvent(nsGUIEvent &aEvent, nsIntPoint *aPt = nsnull)
        1228                 : {
        1229               0 :   if (aPt) {
        1230               0 :     aEvent.refPoint = *aPt;
        1231                 :   }
        1232               0 :   aEvent.time = PR_IntervalNow();
        1233               0 : }
        1234                 :
        1235                 : NS_IMETHODIMP
        1236               0 : nsDOMWindowUtils::SendCompositionEvent(const nsAString& aType,
        1237                 :                                        const nsAString& aData,
        1238                 :                                        const nsAString& aLocale)
        1239                 : {
        1240               0 :   if (!IsUniversalXPConnectCapable()) {
        1241               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1242                 :   }
        1243                 :
        1244                 :   // get the widget to send the event to
        1245               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1246               0 :   if (!widget) {
        1247               0 :     return NS_ERROR_FAILURE;
        1248                 :   }
        1249                 :
        1250                 :   PRUint32 msg;
        1251               0 :   if (aType.EqualsLiteral("compositionstart")) {
        1252               0 :     msg = NS_COMPOSITION_START;
        1253               0 :   } else if (aType.EqualsLiteral("compositionend")) {
        1254               0 :     msg = NS_COMPOSITION_END;
        1255               0 :   } else if (aType.EqualsLiteral("compositionupdate")) {
        1256               0 :     msg = NS_COMPOSITION_UPDATE;
        1257                 :   } else {
        1258               0 :     return NS_ERROR_FAILURE;
        1259                 :   }
        1260                 :
        1261               0 :   nsCompositionEvent compositionEvent(true, msg, widget);
        1262               0 :   InitEvent(compositionEvent);
        1263               0 :   if (msg != NS_COMPOSITION_START) {
        1264               0 :     compositionEvent.data = aData;
        1265                 :   }
        1266                 :
        1267                 :   nsEventStatus status;
        1268               0 :   nsresult rv = widget->DispatchEvent(&compositionEvent, status);
        1269               0 :   NS_ENSURE_SUCCESS(rv, rv);
        1270                 :
        1271               0 :   return NS_OK;
        1272                 : }
        1273                 :
        1274                 : static void
        1275               0 : AppendClause(PRInt32 aClauseLength, PRUint32 aClauseAttr,
        1276                 :              nsTArray<nsTextRange>* aRanges)
        1277                 : {
        1278               0 :   NS_PRECONDITION(aRanges, "aRange is null");
        1279               0 :   if (aClauseLength == 0) {
        1280               0 :     return;
        1281                 :   }
        1282               0 :   nsTextRange range;
        1283               0 :   range.mStartOffset = aRanges->Length() == 0 ? 0 :
        1284               0 :     aRanges->ElementAt(aRanges->Length() - 1).mEndOffset + 1;
        1285               0 :   range.mEndOffset = range.mStartOffset + aClauseLength;
        1286               0 :   NS_ASSERTION(range.mStartOffset <= range.mEndOffset, "range is invalid");
        1287               0 :   NS_PRECONDITION(aClauseAttr == NS_TEXTRANGE_RAWINPUT ||
        1288                 :                   aClauseAttr == NS_TEXTRANGE_SELECTEDRAWTEXT ||
        1289                 :                   aClauseAttr == NS_TEXTRANGE_CONVERTEDTEXT ||
        1290                 :                   aClauseAttr == NS_TEXTRANGE_SELECTEDCONVERTEDTEXT,
        1291                 :                   "aClauseAttr is invalid value");
        1292               0 :   range.mRangeType = aClauseAttr;
        1293               0 :   aRanges->AppendElement(range);
        1294                 : }
        1295                 :
        1296                 : NS_IMETHODIMP
        1297               0 : nsDOMWindowUtils::SendTextEvent(const nsAString& aCompositionString,
        1298                 :                                 PRInt32 aFirstClauseLength,
        1299                 :                                 PRUint32 aFirstClauseAttr,
        1300                 :                                 PRInt32 aSecondClauseLength,
        1301                 :                                 PRUint32 aSecondClauseAttr,
        1302                 :                                 PRInt32 aThirdClauseLength,
        1303                 :                                 PRUint32 aThirdClauseAttr,
        1304                 :                                 PRInt32 aCaretStart,
        1305                 :                                 PRInt32 aCaretLength)
        1306                 : {
        1307               0 :   if (!IsUniversalXPConnectCapable()) {
        1308               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1309                 :   }
        1310                 :
        1311                 :   // get the widget to send the event to
        1312               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1313               0 :   if (!widget) {
        1314               0 :     return NS_ERROR_FAILURE;
        1315                 :   }
        1316                 :
        1317               0 :   nsTextEvent textEvent(true, NS_TEXT_TEXT, widget);
        1318               0 :   InitEvent(textEvent);
        1319                 :
        1320               0 :   nsAutoTArray<nsTextRange, 4> textRanges;
        1321               0 :   NS_ENSURE_TRUE(aFirstClauseLength >= 0,  NS_ERROR_INVALID_ARG);
        1322               0 :   NS_ENSURE_TRUE(aSecondClauseLength >= 0, NS_ERROR_INVALID_ARG);
        1323               0 :   NS_ENSURE_TRUE(aThirdClauseLength >= 0,  NS_ERROR_INVALID_ARG);
        1324               0 :   AppendClause(aFirstClauseLength,  aFirstClauseAttr, &textRanges);
        1325               0 :   AppendClause(aSecondClauseLength, aSecondClauseAttr, &textRanges);
        1326               0 :   AppendClause(aThirdClauseLength,  aThirdClauseAttr, &textRanges);
        1327               0 :   PRInt32 len = aFirstClauseLength + aSecondClauseLength + aThirdClauseLength;
        1328               0 :   NS_ENSURE_TRUE(len == 0 || PRUint32(len) == aCompositionString.Length(),
        1329                 :                  NS_ERROR_FAILURE);
        1330                 :
        1331               0 :   if (aCaretStart >= 0) {
        1332               0 :     nsTextRange range;
        1333               0 :     range.mStartOffset = aCaretStart;
        1334               0 :     range.mEndOffset = range.mStartOffset + aCaretLength;
        1335               0 :     range.mRangeType = NS_TEXTRANGE_CARETPOSITION;
        1336               0 :     textRanges.AppendElement(range);
        1337                 :   }
        1338                 :
        1339               0 :   textEvent.theText = aCompositionString;
        1340                 :
        1341               0 :   textEvent.rangeCount = textRanges.Length();
        1342               0 :   textEvent.rangeArray = textRanges.Elements();
        1343                 :
        1344                 :   nsEventStatus status;
        1345               0 :   nsresult rv = widget->DispatchEvent(&textEvent, status);
        1346               0 :   NS_ENSURE_SUCCESS(rv, rv);
        1347                 :
        1348               0 :   return NS_OK;
        1349                 : }
        1350                 :
        1351                 : NS_IMETHODIMP
        1352               0 : nsDOMWindowUtils::SendQueryContentEvent(PRUint32 aType,
        1353                 :                                         PRUint32 aOffset, PRUint32 aLength,
        1354                 :                                         PRInt32 aX, PRInt32 aY,
        1355                 :                                         nsIQueryContentEventResult **aResult)
        1356                 : {
        1357               0 :   *aResult = nsnull;
        1358                 :
        1359               0 :   if (!IsUniversalXPConnectCapable()) {
        1360               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1361                 :   }
        1362                 :
        1363               0 :   NS_ENSURE_TRUE(mWindow, NS_ERROR_FAILURE);
        1364                 :
        1365               0 :   nsIDocShell *docShell = mWindow->GetDocShell();
        1366               0 :   NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
        1367                 :
        1368               0 :   nsCOMPtr<nsIPresShell> presShell;
        1369               0 :   docShell->GetPresShell(getter_AddRefs(presShell));
        1370               0 :   NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
        1371                 :
        1372               0 :   nsPresContext* presContext = presShell->GetPresContext();
        1373               0 :   NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
        1374                 :
        1375                 :   // get the widget to send the event to
        1376               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1377               0 :   if (!widget) {
        1378               0 :     return NS_ERROR_FAILURE;
        1379                 :   }
        1380                 :
        1381               0 :   if (aType != NS_QUERY_SELECTED_TEXT &&
        1382                 :       aType != NS_QUERY_TEXT_CONTENT &&
        1383                 :       aType != NS_QUERY_CARET_RECT &&
        1384                 :       aType != NS_QUERY_TEXT_RECT &&
        1385                 :       aType != NS_QUERY_EDITOR_RECT &&
        1386                 :       aType != NS_QUERY_CHARACTER_AT_POINT) {
        1387               0 :     return NS_ERROR_INVALID_ARG;
        1388                 :   }
        1389                 :
        1390               0 :   nsCOMPtr<nsIWidget> targetWidget = widget;
        1391               0 :   nsIntPoint pt(aX, aY);
        1392                 :
        1393               0 :   if (aType == QUERY_CHARACTER_AT_POINT) {
        1394                 :     // Looking for the widget at the point.
        1395               0 :     nsQueryContentEvent dummyEvent(true, NS_QUERY_CONTENT_STATE, widget);
        1396               0 :     InitEvent(dummyEvent, &pt);
        1397                 :     nsIFrame* popupFrame =
        1398               0 :       nsLayoutUtils::GetPopupFrameForEventCoordinates(presContext->GetRootPresContext(), &dummyEvent);
        1399                 :
        1400               0 :     nsIntRect widgetBounds;
        1401               0 :     nsresult rv = widget->GetClientBounds(widgetBounds);
        1402               0 :     NS_ENSURE_SUCCESS(rv, rv);
        1403               0 :     widgetBounds.MoveTo(0, 0);
        1404                 :
        1405                 :     // There is no popup frame at the point and the point isn't in our widget,
        1406                 :     // we cannot process this request.
        1407               0 :     NS_ENSURE_TRUE(popupFrame || widgetBounds.Contains(pt),
        1408                 :                    NS_ERROR_FAILURE);
        1409                 :
        1410                 :     // Fire the event on the widget at the point
        1411               0 :     if (popupFrame) {
        1412               0 :       targetWidget = popupFrame->GetNearestWidget();
        1413                 :     }
        1414                 :   }
        1415                 :
        1416               0 :   pt += widget->WidgetToScreenOffset() - targetWidget->WidgetToScreenOffset();
        1417                 :
        1418               0 :   nsQueryContentEvent queryEvent(true, aType, targetWidget);
        1419               0 :   InitEvent(queryEvent, &pt);
        1420                 :
        1421               0 :   switch (aType) {
        1422                 :     case NS_QUERY_TEXT_CONTENT:
        1423               0 :       queryEvent.InitForQueryTextContent(aOffset, aLength);
        1424               0 :       break;
        1425                 :     case NS_QUERY_CARET_RECT:
        1426               0 :       queryEvent.InitForQueryCaretRect(aOffset);
        1427               0 :       break;
        1428                 :     case NS_QUERY_TEXT_RECT:
        1429               0 :       queryEvent.InitForQueryTextRect(aOffset, aLength);
        1430               0 :       break;
        1431                 :   }
        1432                 :
        1433                 :   nsEventStatus status;
        1434               0 :   nsresult rv = targetWidget->DispatchEvent(&queryEvent, status);
        1435               0 :   NS_ENSURE_SUCCESS(rv, rv);
        1436                 :
        1437               0 :   nsQueryContentEventResult* result = new nsQueryContentEventResult();
        1438               0 :   NS_ENSURE_TRUE(result, NS_ERROR_OUT_OF_MEMORY);
        1439               0 :   result->SetEventResult(widget, queryEvent);
        1440               0 :   NS_ADDREF(*aResult = result);
        1441               0 :   return NS_OK;
        1442                 : }
        1443                 :
        1444                 : NS_IMETHODIMP
        1445               0 : nsDOMWindowUtils::SendSelectionSetEvent(PRUint32 aOffset,
        1446                 :                                         PRUint32 aLength,
        1447                 :                                         bool aReverse,
        1448                 :                                         bool *aResult)
        1449                 : {
        1450               0 :   *aResult = false;
        1451                 :
        1452               0 :   if (!IsUniversalXPConnectCapable()) {
        1453               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1454                 :   }
        1455                 :
        1456                 :   // get the widget to send the event to
        1457               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1458               0 :   if (!widget) {
        1459               0 :     return NS_ERROR_FAILURE;
        1460                 :   }
        1461                 :
        1462               0 :   nsSelectionEvent selectionEvent(true, NS_SELECTION_SET, widget);
        1463               0 :   InitEvent(selectionEvent);
        1464                 :
        1465               0 :   selectionEvent.mOffset = aOffset;
        1466               0 :   selectionEvent.mLength = aLength;
        1467               0 :   selectionEvent.mReversed = aReverse;
        1468                 :
        1469                 :   nsEventStatus status;
        1470               0 :   nsresult rv = widget->DispatchEvent(&selectionEvent, status);
        1471               0 :   NS_ENSURE_SUCCESS(rv, rv);
        1472                 :
        1473               0 :   *aResult = selectionEvent.mSucceeded;
        1474               0 :   return NS_OK;
        1475                 : }
        1476                 :
        1477                 : NS_IMETHODIMP
        1478               0 : nsDOMWindowUtils::SendContentCommandEvent(const nsAString& aType,
        1479                 :                                           nsITransferable * aTransferable)
        1480                 : {
        1481               0 :   if (!IsUniversalXPConnectCapable()) {
        1482               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1483                 :   }
        1484                 :
        1485                 :   // get the widget to send the event to
        1486               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1487               0 :   if (!widget)
        1488               0 :     return NS_ERROR_FAILURE;
        1489                 :
        1490                 :   PRInt32 msg;
        1491               0 :   if (aType.EqualsLiteral("cut"))
        1492               0 :     msg = NS_CONTENT_COMMAND_CUT;
        1493               0 :   else if (aType.EqualsLiteral("copy"))
        1494               0 :     msg = NS_CONTENT_COMMAND_COPY;
        1495               0 :   else if (aType.EqualsLiteral("paste"))
        1496               0 :     msg = NS_CONTENT_COMMAND_PASTE;
        1497               0 :   else if (aType.EqualsLiteral("delete"))
        1498               0 :     msg = NS_CONTENT_COMMAND_DELETE;
        1499               0 :   else if (aType.EqualsLiteral("undo"))
        1500               0 :     msg = NS_CONTENT_COMMAND_UNDO;
        1501               0 :   else if (aType.EqualsLiteral("redo"))
        1502               0 :     msg = NS_CONTENT_COMMAND_REDO;
        1503               0 :   else if (aType.EqualsLiteral("pasteTransferable"))
        1504               0 :     msg = NS_CONTENT_COMMAND_PASTE_TRANSFERABLE;
        1505                 :   else
        1506               0 :     return NS_ERROR_FAILURE;
        1507                 :
        1508               0 :   nsContentCommandEvent event(true, msg, widget);
        1509               0 :   if (msg == NS_CONTENT_COMMAND_PASTE_TRANSFERABLE) {
        1510               0 :     event.mTransferable = aTransferable;
        1511                 :   }
        1512                 :
        1513                 :   nsEventStatus status;
        1514               0 :   return widget->DispatchEvent(&event, status);
        1515                 : }
        1516                 :
        1517                 : NS_IMETHODIMP
        1518               0 : nsDOMWindowUtils::GetClassName(const JS::Value& aObject, JSContext* aCx, char** aName)
        1519                 : {
        1520               0 :   if (!nsContentUtils::IsCallerTrustedForRead()) {
        1521               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1522                 :   }
        1523                 :
        1524                 :   // Our argument must be a non-null object.
        1525               0 :   if (JSVAL_IS_PRIMITIVE(aObject)) {
        1526               0 :     return NS_ERROR_XPC_BAD_CONVERT_JS;
        1527                 :   }
        1528                 :
        1529               0 :   *aName = NS_strdup(JS_GetClass(JSVAL_TO_OBJECT(aObject))->name);
        1530               0 :   NS_ABORT_IF_FALSE(*aName, "NS_strdup should be infallible.");
        1531               0 :   return NS_OK;
        1532                 : }
        1533                 :
        1534                 : NS_IMETHODIMP
        1535               0 : nsDOMWindowUtils::GetVisitedDependentComputedStyle(
        1536                 :                     nsIDOMElement *aElement, const nsAString& aPseudoElement,
        1537                 :                     const nsAString& aPropertyName, nsAString& aResult)
        1538                 : {
        1539               0 :   aResult.Truncate();
        1540                 :
        1541               0 :   if (!IsUniversalXPConnectCapable()) {
        1542               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1543                 :   }
        1544                 :
        1545               0 :   nsCOMPtr<nsIDOMCSSStyleDeclaration> decl;
        1546                 :   nsresult rv =
        1547               0 :     mWindow->GetComputedStyle(aElement, aPseudoElement, getter_AddRefs(decl));
        1548               0 :   NS_ENSURE_SUCCESS(rv, rv);
        1549                 :
        1550               0 :   static_cast<nsComputedDOMStyle*>(decl.get())->SetExposeVisitedStyle(true);
        1551               0 :   rv = decl->GetPropertyValue(aPropertyName, aResult);
        1552               0 :   static_cast<nsComputedDOMStyle*>(decl.get())->SetExposeVisitedStyle(false);
        1553                 :
        1554               0 :   return rv;
        1555                 : }
        1556                 :
        1557                 : NS_IMETHODIMP
        1558               0 : nsDOMWindowUtils::EnterModalState()
        1559                 : {
        1560               0 :   mWindow->EnterModalState();
        1561               0 :   return NS_OK;
        1562                 : }
        1563                 :
        1564                 : NS_IMETHODIMP
        1565               0 : nsDOMWindowUtils::LeaveModalState()
        1566                 : {
        1567               0 :   mWindow->LeaveModalState(nsnull);
        1568               0 :   return NS_OK;
        1569                 : }
        1570                 :
        1571                 : NS_IMETHODIMP
        1572               0 : nsDOMWindowUtils::EnterModalStateWithWindow(nsIDOMWindow **aWindow)
        1573                 : {
        1574               0 :   *aWindow = mWindow->EnterModalState();
        1575               0 :   NS_IF_ADDREF(*aWindow);
        1576               0 :   return NS_OK;
        1577                 : }
        1578                 :
        1579                 : NS_IMETHODIMP
        1580               0 : nsDOMWindowUtils::LeaveModalStateWithWindow(nsIDOMWindow *aWindow)
        1581                 : {
        1582               0 :   NS_ENSURE_ARG_POINTER(aWindow);
        1583               0 :   mWindow->LeaveModalState(aWindow);
        1584               0 :   return NS_OK;
        1585                 : }
        1586                 :
        1587                 : NS_IMETHODIMP
        1588               0 : nsDOMWindowUtils::IsInModalState(bool *retval)
        1589                 : {
        1590               0 :   *retval = mWindow->IsInModalState();
        1591               0 :   return NS_OK;
        1592                 : }
        1593                 :
        1594                 : NS_IMETHODIMP
        1595               0 : nsDOMWindowUtils::GetParent(const JS::Value& aObject,
        1596                 :                             JSContext* aCx,
        1597                 :                             JS::Value* aParent)
        1598                 : {
        1599                 :   // This wasn't privileged in the past, but better to expose less than more.
        1600               0 :   if (!IsUniversalXPConnectCapable()) {
        1601               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1602                 :   }
        1603                 :
        1604                 :   // First argument must be an object.
        1605               0 :   if (JSVAL_IS_PRIMITIVE(aObject)) {
        1606               0 :     return NS_ERROR_XPC_BAD_CONVERT_JS;
        1607                 :   }
        1608                 :
        1609               0 :   JSObject* parent = JS_GetParent(JSVAL_TO_OBJECT(aObject));
        1610               0 :   *aParent = OBJECT_TO_JSVAL(parent);
        1611                 :
        1612                 :   // Outerize if necessary.
        1613               0 :   if (parent) {
        1614               0 :     if (JSObjectOp outerize = js::GetObjectClass(parent)->ext.outerObject) {
        1615               0 :       *aParent = OBJECT_TO_JSVAL(outerize(aCx, parent));
        1616                 :     }
        1617                 :   }
        1618                 :
        1619               0 :   return NS_OK;
        1620                 : }
        1621                 :
        1622                 : NS_IMETHODIMP
        1623               0 : nsDOMWindowUtils::GetOuterWindowID(PRUint64 *aWindowID)
        1624                 : {
        1625               0 :   NS_ASSERTION(mWindow->IsOuterWindow(), "How did that happen?");
        1626               0 :   *aWindowID = mWindow->WindowID();
        1627               0 :   return NS_OK;
        1628                 : }
        1629                 :
        1630                 : NS_IMETHODIMP
        1631               0 : nsDOMWindowUtils::GetCurrentInnerWindowID(PRUint64 *aWindowID)
        1632                 : {
        1633               0 :   NS_ASSERTION(mWindow->IsOuterWindow(), "How did that happen?");
        1634               0 :   nsGlobalWindow* inner = mWindow->GetCurrentInnerWindowInternal();
        1635               0 :   if (!inner) {
        1636               0 :     return NS_ERROR_NOT_AVAILABLE;
        1637                 :   }
        1638               0 :   *aWindowID = inner->WindowID();
        1639               0 :   return NS_OK;
        1640                 : }
        1641                 :
        1642                 : NS_IMETHODIMP
        1643               0 : nsDOMWindowUtils::SuspendTimeouts()
        1644                 : {
        1645               0 :   if (!IsUniversalXPConnectCapable()) {
        1646               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1647                 :   }
        1648                 :
        1649               0 :   mWindow->SuspendTimeouts();
        1650                 :
        1651               0 :   return NS_OK;
        1652                 : }
        1653                 :
        1654                 : NS_IMETHODIMP
        1655               0 : nsDOMWindowUtils::ResumeTimeouts()
        1656                 : {
        1657               0 :   if (!IsUniversalXPConnectCapable()) {
        1658               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1659                 :   }
        1660                 :
        1661               0 :   mWindow->ResumeTimeouts();
        1662                 :
        1663               0 :   return NS_OK;
        1664                 : }
        1665                 :
        1666                 : NS_IMETHODIMP
        1667               0 : nsDOMWindowUtils::GetLayerManagerType(nsAString& aType)
        1668                 : {
        1669               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1670               0 :   if (!widget)
        1671               0 :     return NS_ERROR_FAILURE;
        1672                 :
        1673               0 :   LayerManager *mgr = widget->GetLayerManager();
        1674               0 :   if (!mgr)
        1675               0 :     return NS_ERROR_FAILURE;
        1676                 :
        1677               0 :   mgr->GetBackendName(aType);
        1678                 :
        1679               0 :   return NS_OK;
        1680                 : }
        1681                 :
        1682                 : NS_IMETHODIMP
        1683               0 : nsDOMWindowUtils::StartFrameTimeRecording()
        1684                 : {
        1685               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1686               0 :   if (!widget)
        1687               0 :     return NS_ERROR_FAILURE;
        1688                 :
        1689               0 :   LayerManager *mgr = widget->GetLayerManager();
        1690               0 :   if (!mgr)
        1691               0 :     return NS_ERROR_FAILURE;
        1692                 :
        1693               0 :   mgr->StartFrameTimeRecording();
        1694                 :
        1695               0 :   return NS_OK;
        1696                 : }
        1697                 :
        1698                 : NS_IMETHODIMP
        1699               0 : nsDOMWindowUtils::StopFrameTimeRecording(PRUint32 *frameCount NS_OUTPARAM, float **frames NS_OUTPARAM)
        1700                 : {
        1701               0 :   NS_ENSURE_ARG_POINTER(frameCount);
        1702               0 :   NS_ENSURE_ARG_POINTER(frames);
        1703                 :
        1704               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1705               0 :   if (!widget)
        1706               0 :     return NS_ERROR_FAILURE;
        1707                 :
        1708               0 :   LayerManager *mgr = widget->GetLayerManager();
        1709               0 :   if (!mgr)
        1710               0 :     return NS_ERROR_FAILURE;
        1711                 :
        1712               0 :   nsTArray<float> frameTimes = mgr->StopFrameTimeRecording();
        1713                 :
        1714               0 :   *frames = nsnull;
        1715               0 :   *frameCount = frameTimes.Length();
        1716                 :
        1717               0 :   if (*frameCount != 0) {
        1718               0 :     *frames = (float*)nsMemory::Alloc(*frameCount * sizeof(float*));
        1719               0 :     if (!*frames)
        1720               0 :       return NS_ERROR_OUT_OF_MEMORY;
        1721                 :
        1722                 :     /* copy over the frame times into the array we just allocated */
        1723               0 :     for (PRUint32 i = 0; i < *frameCount; i++) {
        1724               0 :       (*frames)[i] = frameTimes[i];
        1725                 :     }
        1726                 :   }
        1727                 :
        1728               0 :   return NS_OK;
        1729                 : }
        1730                 :
        1731                 : static bool
        1732               0 : ComputeAnimationValue(nsCSSProperty aProperty,
        1733                 :                       Element* aElement,
        1734                 :                       const nsAString& aInput,
        1735                 :                       nsStyleAnimation::Value& aOutput)
        1736                 : {
        1737                 :
        1738               0 :   if (!nsStyleAnimation::ComputeValue(aProperty, aElement, aInput,
        1739               0 :                                       false, aOutput)) {
        1740               0 :     return false;
        1741                 :   }
        1742                 :
        1743                 :   // This matches TransExtractComputedValue in nsTransitionManager.cpp.
        1744               0 :   if (aProperty == eCSSProperty_visibility) {
        1745               0 :     NS_ABORT_IF_FALSE(aOutput.GetUnit() == nsStyleAnimation::eUnit_Enumerated,
        1746                 :                       "unexpected unit");
        1747                 :     aOutput.SetIntValue(aOutput.GetIntValue(),
        1748               0 :                         nsStyleAnimation::eUnit_Visibility);
        1749                 :   }
        1750                 :
        1751               0 :   return true;
        1752                 : }
        1753                 :
        1754                 : NS_IMETHODIMP
        1755               0 : nsDOMWindowUtils::AdvanceTimeAndRefresh(PRInt64 aMilliseconds)
        1756                 : {
        1757               0 :   if (!IsUniversalXPConnectCapable()) {
        1758               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1759                 :   }
        1760                 :
        1761               0 :   GetPresContext()->RefreshDriver()->AdvanceTimeAndRefresh(aMilliseconds);
        1762                 :
        1763               0 :   return NS_OK;
        1764                 : }
        1765                 :
        1766                 : NS_IMETHODIMP
        1767               0 : nsDOMWindowUtils::RestoreNormalRefresh()
        1768                 : {
        1769               0 :   if (!IsUniversalXPConnectCapable()) {
        1770               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1771                 :   }
        1772                 :
        1773               0 :   GetPresContext()->RefreshDriver()->RestoreNormalRefresh();
        1774                 :
        1775               0 :   return NS_OK;
        1776                 : }
        1777                 :
        1778                 : NS_IMETHODIMP
        1779               0 : nsDOMWindowUtils::ComputeAnimationDistance(nsIDOMElement* aElement,
        1780                 :                                            const nsAString& aProperty,
        1781                 :                                            const nsAString& aValue1,
        1782                 :                                            const nsAString& aValue2,
        1783                 :                                            double* aResult)
        1784                 : {
        1785               0 :   if (!IsUniversalXPConnectCapable()) {
        1786               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1787                 :   }
        1788                 :
        1789                 :   nsresult rv;
        1790               0 :   nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
        1791               0 :   NS_ENSURE_SUCCESS(rv, rv);
        1792                 :
        1793                 :   // Convert direction-dependent properties as appropriate, e.g.,
        1794                 :   // border-left to border-left-value.
        1795               0 :   nsCSSProperty property = nsCSSProps::LookupProperty(aProperty);
        1796               0 :   if (property != eCSSProperty_UNKNOWN && nsCSSProps::IsShorthand(property)) {
        1797               0 :     nsCSSProperty subprop0 = *nsCSSProps::SubpropertyEntryFor(property);
        1798               0 :     if (nsCSSProps::PropHasFlags(subprop0, CSS_PROPERTY_REPORT_OTHER_NAME) &&
        1799               0 :         nsCSSProps::OtherNameFor(subprop0) == property) {
        1800               0 :       property = subprop0;
        1801                 :     } else {
        1802               0 :       property = eCSSProperty_UNKNOWN;
        1803                 :     }
        1804                 :   }
        1805                 :
        1806               0 :   NS_ABORT_IF_FALSE(property == eCSSProperty_UNKNOWN ||
        1807                 :                     !nsCSSProps::IsShorthand(property),
        1808                 :                     "should not have shorthand");
        1809                 :
        1810               0 :   nsStyleAnimation::Value v1, v2;
        1811               0 :   if (property == eCSSProperty_UNKNOWN ||
        1812               0 :       !ComputeAnimationValue(property, content->AsElement(), aValue1, v1) ||
        1813               0 :       !ComputeAnimationValue(property, content->AsElement(), aValue2, v2)) {
        1814               0 :     return NS_ERROR_ILLEGAL_VALUE;
        1815                 :   }
        1816                 :
        1817               0 :   if (!nsStyleAnimation::ComputeDistance(property, v1, v2, *aResult)) {
        1818               0 :     return NS_ERROR_FAILURE;
        1819                 :   }
        1820                 :
        1821               0 :   return NS_OK;
        1822                 : }
        1823                 :
        1824                 : nsresult
        1825               0 : nsDOMWindowUtils::RenderDocument(const nsRect& aRect,
        1826                 :                                  PRUint32 aFlags,
        1827                 :                                  nscolor aBackgroundColor,
        1828                 :                                  gfxContext* aThebesContext)
        1829                 : {
        1830                 :     // Get DOM Document
        1831                 :     nsresult rv;
        1832               0 :     nsCOMPtr<nsIDOMDocument> ddoc;
        1833               0 :     rv = mWindow->GetDocument(getter_AddRefs(ddoc));
        1834               0 :     NS_ENSURE_SUCCESS(rv, rv);
        1835                 :
        1836                 :     // Get Document
        1837               0 :     nsCOMPtr<nsIDocument> doc = do_QueryInterface(ddoc, &rv);
        1838               0 :     NS_ENSURE_SUCCESS(rv, rv);
        1839                 :
        1840                 :     // Get Primary Shell
        1841               0 :     nsCOMPtr<nsIPresShell> presShell = doc->GetShell();
        1842               0 :     NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
        1843                 :
        1844                 :     // Render Document
        1845               0 :     return presShell->RenderDocument(aRect, aFlags, aBackgroundColor, aThebesContext);
        1846                 : }
        1847                 :
        1848                 : NS_IMETHODIMP
        1849               0 : nsDOMWindowUtils::GetCursorType(PRInt16 *aCursor)
        1850                 : {
        1851               0 :   NS_ENSURE_ARG_POINTER(aCursor);
        1852                 :
        1853               0 :   bool isSameDoc = false;
        1854               0 :   nsCOMPtr<nsIDocument> doc(do_QueryInterface(mWindow->GetExtantDocument()));
        1855                 :
        1856               0 :   NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
        1857                 :
        1858               0 :   do {
        1859               0 :     if (nsEventStateManager::sMouseOverDocument == doc.get()) {
        1860               0 :       isSameDoc = true;
        1861               0 :       break;
        1862                 :     }
        1863               0 :   } while ((doc = doc->GetParentDocument()));
        1864                 :
        1865               0 :   if (!isSameDoc) {
        1866               0 :     *aCursor = eCursor_none;
        1867               0 :     return NS_OK;
        1868                 :   }
        1869                 :
        1870               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1871               0 :   if (!widget)
        1872               0 :     return NS_ERROR_FAILURE;
        1873                 :
        1874                 :   // fetch cursor value from window's widget
        1875               0 :   *aCursor = widget->GetCursor();
        1876                 :
        1877               0 :   return NS_OK;
        1878                 : }
        1879                 :
        1880                 : NS_IMETHODIMP
        1881               0 : nsDOMWindowUtils::GoOnline()
        1882                 : {
        1883                 :   // This is only allowed from about:neterror, which is unprivileged, so it
        1884                 :   // can't access the io-service itself.
        1885               0 :   NS_ENSURE_TRUE(mWindow, NS_ERROR_FAILURE);
        1886               0 :   nsCOMPtr<nsIDocument> doc(do_QueryInterface(mWindow->GetExtantDocument()));
        1887               0 :   NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
        1888               0 :   nsCOMPtr<nsIURI> documentURI;
        1889               0 :   documentURI = doc->GetDocumentURI();
        1890                 :
        1891               0 :   nsCAutoString spec;
        1892               0 :   documentURI->GetSpec(spec);
        1893               0 :   if (!StringBeginsWith(spec,  NS_LITERAL_CSTRING("about:neterror?")))
        1894               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1895                 :
        1896               0 :   nsCOMPtr<nsIIOService> ios = do_GetService("@mozilla.org/network/io-service;1");
        1897               0 :   if (ios) {
        1898               0 :     ios->SetOffline(false); // !offline
        1899               0 :     return NS_OK;
        1900                 :   }
        1901               0 :   return NS_ERROR_NOT_AVAILABLE;
        1902                 : }
        1903                 :
        1904                 : NS_IMETHODIMP
        1905               0 : nsDOMWindowUtils::GetDisplayDPI(float *aDPI)
        1906                 : {
        1907               0 :   nsCOMPtr<nsIWidget> widget = GetWidget();
        1908               0 :   if (!widget)
        1909               0 :     return NS_ERROR_FAILURE;
        1910                 :
        1911               0 :   *aDPI = widget->GetDPI();
        1912                 :
        1913               0 :   return NS_OK;
        1914                 : }
        1915                 :
        1916                 :
        1917                 : NS_IMETHODIMP
        1918               0 : nsDOMWindowUtils::GetOuterWindowWithId(PRUint64 aWindowID,
        1919                 :                                        nsIDOMWindow** aWindow)
        1920                 : {
        1921               0 :   if (!IsUniversalXPConnectCapable()) {
        1922               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1923                 :   }
        1924                 :
        1925               0 :   *aWindow = nsGlobalWindow::GetOuterWindowWithId(aWindowID);
        1926               0 :   NS_IF_ADDREF(*aWindow);
        1927               0 :   return NS_OK;
        1928                 : }
        1929                 :
        1930                 : NS_IMETHODIMP
        1931               0 : nsDOMWindowUtils::WrapDOMFile(nsIFile *aFile,
        1932                 :                               nsIDOMFile **aDOMFile) {
        1933               0 :   NS_ADDREF(*aDOMFile = new nsDOMFileFile(aFile));
        1934               0 :   return NS_OK;
        1935                 : }
        1936                 :
        1937                 : #ifdef DEBUG
        1938                 : static bool
        1939               0 : CheckLeafLayers(Layer* aLayer, const nsIntPoint& aOffset, nsIntRegion* aCoveredRegion)
        1940                 : {
        1941               0 :   gfxMatrix transform;
        1942               0 :   if (!aLayer->GetTransform().Is2D(&transform) ||
        1943               0 :       transform.HasNonIntegerTranslation())
        1944               0 :     return false;
        1945               0 :   transform.NudgeToIntegers();
        1946               0 :   nsIntPoint offset = aOffset + nsIntPoint(transform.x0, transform.y0);
        1947                 :
        1948               0 :   Layer* child = aLayer->GetFirstChild();
        1949               0 :   if (child) {
        1950               0 :     while (child) {
        1951               0 :       if (!CheckLeafLayers(child, offset, aCoveredRegion))
        1952               0 :         return false;
        1953               0 :       child = child->GetNextSibling();
        1954                 :     }
        1955                 :   } else {
        1956               0 :     nsIntRegion rgn = aLayer->GetVisibleRegion();
        1957               0 :     rgn.MoveBy(offset);
        1958               0 :     nsIntRegion tmp;
        1959               0 :     tmp.And(rgn, *aCoveredRegion);
        1960               0 :     if (!tmp.IsEmpty())
        1961               0 :       return false;
        1962               0 :     aCoveredRegion->Or(*aCoveredRegion, rgn);
        1963                 :   }
        1964                 :
        1965               0 :   return true;
        1966                 : }
        1967                 : #endif
        1968                 :
        1969                 : NS_IMETHODIMP
        1970               0 : nsDOMWindowUtils::LeafLayersPartitionWindow(bool* aResult)
        1971                 : {
        1972               0 :   if (!IsUniversalXPConnectCapable()) {
        1973               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        1974                 :   }
        1975                 :
        1976               0 :   *aResult = true;
        1977                 : #ifdef DEBUG
        1978               0 :   nsIWidget* widget = GetWidget();
        1979               0 :   if (!widget)
        1980               0 :     return NS_ERROR_FAILURE;
        1981               0 :   LayerManager* manager = widget->GetLayerManager();
        1982               0 :   if (!manager)
        1983               0 :     return NS_ERROR_FAILURE;
        1984               0 :   nsPresContext* presContext = GetPresContext();
        1985               0 :   if (!presContext)
        1986               0 :     return NS_ERROR_FAILURE;
        1987               0 :   Layer* root = manager->GetRoot();
        1988               0 :   if (!root)
        1989               0 :     return NS_ERROR_FAILURE;
        1990                 :
        1991               0 :   nsIntPoint offset(0, 0);
        1992               0 :   nsIntRegion coveredRegion;
        1993               0 :   if (!CheckLeafLayers(root, offset, &coveredRegion)) {
        1994               0 :     *aResult = false;
        1995                 :   }
        1996               0 :   if (!coveredRegion.IsEqual(root->GetVisibleRegion())) {
        1997               0 :     *aResult = false;
        1998                 :   }
        1999                 : #endif
        2000               0 :   return NS_OK;
        2001                 : }
        2002                 :
        2003                 : NS_IMETHODIMP
        2004               0 : nsDOMWindowUtils::GetMayHaveTouchEventListeners(bool* aResult)
        2005                 : {
        2006               0 :   if (!IsUniversalXPConnectCapable()) {
        2007               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        2008                 :   }
        2009                 :
        2010               0 :   nsPIDOMWindow* innerWindow = mWindow->GetCurrentInnerWindow();
        2011               0 :   *aResult = innerWindow ? innerWindow->HasTouchEventListeners() : false;
        2012               0 :   return NS_OK;
        2013                 : }
        2014                 :
        2015                 : NS_IMETHODIMP
        2016               0 : nsDOMWindowUtils::CheckAndClearPaintedState(nsIDOMElement* aElement, bool* aResult)
        2017                 : {
        2018               0 :   if (!aElement) {
        2019               0 :     return NS_ERROR_INVALID_ARG;
        2020                 :   }
        2021                 :
        2022                 :   nsresult rv;
        2023               0 :   nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
        2024               0 :   NS_ENSURE_SUCCESS(rv, rv);
        2025                 :
        2026               0 :   nsIFrame* frame = content->GetPrimaryFrame();
        2027                 :
        2028               0 :   if (!frame) {
        2029               0 :     *aResult = false;
        2030               0 :     return NS_OK;
        2031                 :   }
        2032                 :
        2033               0 :   *aResult = frame->CheckAndClearPaintedState();
        2034               0 :   return NS_OK;
        2035                 : }
        2036                 :
        2037                 : NS_IMETHODIMP
        2038               0 : nsDOMWindowUtils::GetFileId(nsIDOMBlob* aBlob, PRInt64* aResult)
        2039                 : {
        2040               0 :   if (!IsUniversalXPConnectCapable()) {
        2041               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        2042                 :   }
        2043                 :
        2044               0 :   *aResult = aBlob->GetFileId();
        2045               0 :   return NS_OK;
        2046                 : }
        2047                 :
        2048                 : NS_IMETHODIMP
        2049               0 : nsDOMWindowUtils::GetFileReferences(const nsAString& aDatabaseName,
        2050                 :                                     PRInt64 aId, PRInt32* aRefCnt,
        2051                 :                                     PRInt32* aDBRefCnt, PRInt32* aSliceRefCnt,
        2052                 :                                     bool* aResult)
        2053                 : {
        2054               0 :   if (!IsUniversalXPConnectCapable()) {
        2055               0 :     return NS_ERROR_DOM_SECURITY_ERR;
        2056                 :   }
        2057                 :
        2058               0 :   NS_ENSURE_TRUE(mWindow, NS_ERROR_FAILURE);
        2059                 :
        2060               0 :   nsCString origin;
        2061                 :   nsresult rv = indexedDB::IndexedDatabaseManager::GetASCIIOriginFromWindow(
        2062               0 :     mWindow, origin);
        2063               0 :   NS_ENSURE_SUCCESS(rv, rv);
        2064                 :
        2065                 :   nsRefPtr<indexedDB::IndexedDatabaseManager> mgr =
        2066               0 :     indexedDB::IndexedDatabaseManager::Get();
        2067                 :
        2068               0 :   if (mgr) {
        2069                 :     nsRefPtr<indexedDB::FileManager> fileManager =
        2070               0 :       mgr->GetFileManager(origin, aDatabaseName);
        2071                 :
        2072               0 :     if (fileManager) {
        2073               0 :       nsRefPtr<indexedDB::FileInfo> fileInfo = fileManager->GetFileInfo(aId);
        2074                 :
        2075               0 :       if (fileInfo) {
        2076               0 :         fileInfo->GetReferences(aRefCnt, aDBRefCnt, aSliceRefCnt);
        2077                 :
        2078               0 :         if (*aRefCnt != -1) {
        2079                 :           // We added an extra temp ref, so account for that accordingly.
        2080               0 :           (*aRefCnt)--;
        2081                 :         }
        2082                 :
        2083               0 :         *aResult = true;
        2084               0 :         return NS_OK;
        2085                 :       }
        2086                 :     }
        2087                 :   }
        2088                 :
        2089               0 :   *aRefCnt = *aDBRefCnt = *aSliceRefCnt = -1;
        2090               0 :   *aResult = false;
        2091               0 :   return NS_OK;
        2092                 : }
        2093                 :
        2094                 : NS_IMETHODIMP
        2095               0 : nsDOMWindowUtils::IsIncrementalGCEnabled(JSContext* cx, bool* aResult)
        2096                 : {
        2097               0 :   *aResult = js::IsIncrementalGCEnabled(JS_GetRuntime(cx));
        2098               0 :   return NS_OK;
        2099                 : }
        2100                 :
        2101                 : NS_IMETHODIMP
        2102               0 : nsDOMWindowUtils::StartPCCountProfiling(JSContext* cx)
        2103                 : {
        2104               0 :   js::StartPCCountProfiling(cx);
        2105               0 :   return NS_OK;
        2106                 : }
        2107                 :
        2108                 : NS_IMETHODIMP
        2109               0 : nsDOMWindowUtils::StopPCCountProfiling(JSContext* cx)
        2110                 : {
        2111               0 :   js::StopPCCountProfiling(cx);
        2112               0 :   return NS_OK;
        2113                 : }
        2114                 :
        2115                 : NS_IMETHODIMP
        2116               0 : nsDOMWindowUtils::PurgePCCounts(JSContext* cx)
        2117                 : {
        2118               0 :   js::PurgePCCounts(cx);
        2119               0 :   return NS_OK;
        2120                 : }
        2121                 :
        2122                 : NS_IMETHODIMP
        2123               0 : nsDOMWindowUtils::GetPCCountScriptCount(JSContext* cx, PRInt32 *result)
        2124                 : {
        2125               0 :   *result = js::GetPCCountScriptCount(cx);
        2126               0 :   return NS_OK;
        2127                 : }
        2128                 :
        2129                 : NS_IMETHODIMP
        2130               0 : nsDOMWindowUtils::GetPCCountScriptSummary(PRInt32 script, JSContext* cx, nsAString& result)
        2131                 : {
        2132               0 :   JSString *text = js::GetPCCountScriptSummary(cx, script);
        2133               0 :   if (!text)
        2134               0 :     return NS_ERROR_FAILURE;
        2135                 :
        2136               0 :   nsDependentJSString str;
        2137               0 :   if (!str.init(cx, text))
        2138               0 :     return NS_ERROR_FAILURE;
        2139                 :
        2140               0 :   result = str;
        2141               0 :   return NS_OK;
        2142                 : }
        2143                 :
        2144                 : NS_IMETHODIMP
        2145               0 : nsDOMWindowUtils::GetPCCountScriptContents(PRInt32 script, JSContext* cx, nsAString& result)
        2146                 : {
        2147               0 :   JSString *text = js::GetPCCountScriptContents(cx, script);
        2148               0 :   if (!text)
        2149               0 :     return NS_ERROR_FAILURE;
        2150                 :
        2151               0 :   nsDependentJSString str;
        2152               0 :   if (!str.init(cx, text))
        2153               0 :     return NS_ERROR_FAILURE;
        2154                 :
        2155               0 :   result = str;
        2156               0 :   return NS_OK;
        2157                 : }
        2158                 :
        2159                 : NS_IMETHODIMP
        2160               0 : nsDOMWindowUtils::GetPaintingSuppressed(bool *aPaintingSuppressed)
        2161                 : {
        2162               0 :   NS_ENSURE_TRUE(mWindow, NS_ERROR_FAILURE);
        2163               0 :   nsIDocShell *docShell = mWindow->GetDocShell();
        2164               0 :   NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
        2165                 :
        2166               0 :   nsCOMPtr<nsIPresShell> presShell;
        2167               0 :   docShell->GetPresShell(getter_AddRefs(presShell));
        2168               0 :   NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
        2169                 :
        2170               0 :   *aPaintingSuppressed = presShell->IsPaintingSuppressed();
        2171               0 :   return NS_OK;
        2172            4188 : }
        2173                 :

Generated by: LCOV version 1.7