author Erica Wright <ewright@mozilla.com>
Fri, 28 Dec 2018 04:26:00 +0000
changeset 512272 7e75579b27d017c48a83e04db1588f7232cc750a
parent 508163 6f3709b3878117466168c40affa7bca0b60cf75b
child 512431 f0a91d36587266d7454a450c6044d573664fbed5
permissions -rw-r--r--
Bug 1512166 - Show blocked labels by default, hide when there's an exception. r=nhnt11 In the control panel, show the blocking category labels for tracking protection and cookie restrictions. Hide the label if the user has set an exception for that page. Differential Revision: https://phabricator.services.mozilla.com/D15212

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsBaseDragService_h__
#define nsBaseDragService_h__

#include "nsIDragService.h"
#include "nsIDragSession.h"
#include "nsITransferable.h"
#include "nsCOMPtr.h"
#include "nsRect.h"
#include "nsPoint.h"
#include "nsString.h"
#include "mozilla/RefPtr.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/HTMLCanvasElement.h"
#include "nsTArray.h"
#include "nsRegion.h"
#include "Units.h"

// translucency level for drag images

class nsIContent;
class nsIDocument;
class nsINode;
class nsPresContext;
class nsIImageLoadingContent;

namespace mozilla {
namespace gfx {
class SourceSurface;
}  // namespace gfx

namespace dom {
class DataTransfer;
class Selection;
}  // namespace dom
}  // namespace mozilla

 * XP DragService wrapper base class

class nsBaseDragService : public nsIDragService, public nsIDragSession {
  typedef mozilla::gfx::SourceSurface SourceSurface;


  // nsISupports

  // nsIDragSession and nsIDragService

  void SetDragEndPoint(nsIntPoint aEndDragPoint) {
    mEndDragPoint =
  void SetDragEndPoint(mozilla::LayoutDeviceIntPoint aEndDragPoint) {
    mEndDragPoint = aEndDragPoint;

  uint16_t GetInputSource() { return mInputSource; }

  int32_t TakeChildProcessDragAction();

  virtual ~nsBaseDragService();

   * Called from nsBaseDragService to initiate a platform drag from a source
   * in this process.  This is expected to ensure that StartDragSession() and
   * EndDragSession() get called if the platform drag is successfully invoked.
  virtual nsresult InvokeDragSessionImpl(
      nsIArray* aTransferableArray,
      const mozilla::Maybe<mozilla::CSSIntRegion>& aRegion,
      uint32_t aActionType) = 0;

   * Draw the drag image, if any, to a surface and return it. The drag image
   * is constructed from mImage if specified, or aDOMNode if mImage is null.
   * aRegion may be used to draw only a subset of the element. This region
   * should be supplied using x and y coordinates measured in css pixels
   * that are relative to the upper-left corner of the window.
   * aScreenPosition should be the screen coordinates of the mouse click
   * for the drag. These are in CSS pixels.
   * On return, aScreenDragRect will contain the screen coordinates of the
   * area being dragged. This is used by the platform-specific part of the
   * drag service to determine the drag feedback. This rect will be in the
   * device pixels of the presContext.
   * If there is no drag image, the returned surface will be null, but
   * aScreenDragRect will still be set to the drag area.
   * aPresContext will be set to the nsPresContext used determined from
   * whichever of mImage or aDOMNode is used.
  nsresult DrawDrag(nsINode* aDOMNode,
                    const mozilla::Maybe<mozilla::CSSIntRegion>& aRegion,
                    mozilla::CSSIntPoint aScreenPosition,
                    mozilla::LayoutDeviceIntRect* aScreenDragRect,
                    RefPtr<SourceSurface>* aSurface,
                    nsPresContext** aPresContext);

   * Draw a drag image for an image node specified by aImageLoader or aCanvas.
   * This is called by DrawDrag.
  nsresult DrawDragForImage(nsPresContext* aPresContext,
                            nsIImageLoadingContent* aImageLoader,
                            mozilla::dom::HTMLCanvasElement* aCanvas,
                            mozilla::LayoutDeviceIntRect* aScreenDragRect,
                            RefPtr<SourceSurface>* aSurface);

   * Convert aScreenPosition from CSS pixels into unscaled device pixels.
  mozilla::LayoutDeviceIntPoint ConvertToUnscaledDevPixels(
      nsPresContext* aPresContext, mozilla::CSSIntPoint aScreenPosition);

   * If the drag image is a popup, open the popup when the drag begins.
  void OpenDragPopup();

   * Free resources contained in DataTransferItems that aren't needed by JS.
  void DiscardInternalTransferData();

  // Returns true if a drag event was dispatched to a child process after
  // the previous TakeDragEventDispatchedToChildProcess() call.
  bool TakeDragEventDispatchedToChildProcess() {
    bool retval = mDragEventDispatchedToChildProcess;
    mDragEventDispatchedToChildProcess = false;
    return retval;

  bool mCanDrop;
  bool mOnlyChromeDrop;
  bool mDoingDrag;
  // true if mImage should be used to set a drag image
  bool mHasImage;
  // true if the user cancelled the drag operation
  bool mUserCancelled;

  bool mDragEventDispatchedToChildProcess;

  uint32_t mDragAction;
  uint32_t mDragActionFromChildProcess;

  nsCOMPtr<nsINode> mSourceNode;
  nsCString mTriggeringPrincipalURISpec;
      mSourceDocument;  // the document at the drag source. will be null
                        //  if it came from outside the app.
      mContentPolicyType;  // the contentpolicy type passed to the channel
                           // when initiating the drag session
  RefPtr<mozilla::dom::DataTransfer> mDataTransfer;

  // used to determine the image to appear on the cursor while dragging
  nsCOMPtr<nsINode> mImage;
  // offset of cursor within the image
  mozilla::CSSIntPoint mImageOffset;

  // set if a selection is being dragged
  RefPtr<mozilla::dom::Selection> mSelection;

  // set if the image in mImage is a popup. If this case, the popup will be
  // opened and moved instead of using a drag image.
  nsCOMPtr<nsIContent> mDragPopup;

  // the screen position where drag gesture occurred, used for positioning the
  // drag image.
  mozilla::CSSIntPoint mScreenPosition;

  // the screen position where the drag ended
  mozilla::LayoutDeviceIntPoint mEndDragPoint;

  uint32_t mSuppressLevel;

  // The input source of the drag event. Possible values are from MouseEvent.
  uint16_t mInputSource;

  nsTArray<RefPtr<mozilla::dom::ContentParent>> mChildProcesses;

  // Sub-region for tree-selections.
  mozilla::Maybe<mozilla::CSSIntRegion> mRegion;

#endif  // nsBaseDragService_h__