The Tor Browser: widget/windows/WinMouseScrollHandler.h@ac0c01689b40 (annotated)

widget/windows/WinMouseScrollHandler.h@ac0c01689b40 (annotated)

widget/windows/WinMouseScrollHandler.h

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* 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 mozilla_widget_WinMouseScrollHandler_h__
 #define mozilla_widget_WinMouseScrollHandler_h__
 #include "nscore.h"
 #include "nsDebug.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/EventForwards.h"
 #include "mozilla/TimeStamp.h"
 #include <windows.h>
 class nsWindowBase;
 struct nsIntPoint;
 namespace mozilla {
 namespace widget {
 class ModifierKeyState;
 struct MSGResult;
 class MouseScrollHandler {
 public:
   static MouseScrollHandler* GetInstance();
   static void Initialize();
   static void Shutdown();
   static bool NeedsMessage(UINT aMsg);
   static bool ProcessMessage(nsWindowBase* aWidget,
                              UINT msg,
                              WPARAM wParam,
                              LPARAM lParam,
                              MSGResult& aResult);
   /**
    * See nsIWidget::SynthesizeNativeMouseScrollEvent() for the detail about
    * this method.
    */
   static nsresult SynthesizeNativeMouseScrollEvent(nsWindowBase* aWidget,
                                                    const nsIntPoint& aPoint,
                                                    uint32_t aNativeMessage,
                                                    int32_t aDelta,
                                                    uint32_t aModifierFlags,
                                                    uint32_t aAdditionalFlags);
   /**
    * IsWaitingInternalMessage() returns true if MouseScrollHandler posted
    * an internal message for a native mouse wheel message and has not
    * received it. Otherwise, false.
    */
   static bool IsWaitingInternalMessage()
   {
     return sInstance && sInstance->mIsWaitingInternalMessage;
   }
 private:
   MouseScrollHandler();
   ~MouseScrollHandler();
   bool mIsWaitingInternalMessage;
   static MouseScrollHandler* sInstance;
   /**
    * DispatchEvent() dispatches aEvent on aWidget.
    *
    * @return TRUE if the event was consumed.  Otherwise, FALSE.
    */
   static bool DispatchEvent(nsWindowBase* aWidget, WidgetGUIEvent& aEvent);
   /**
    * InitEvent() initializes the aEvent.  If aPoint is null, the result of
    * GetCurrentMessagePos() will be used.
    */
   static void InitEvent(nsWindowBase* aWidget,
                         WidgetGUIEvent& aEvent,
                         nsIntPoint* aPoint = nullptr);
   /**
    * GetModifierKeyState() returns current modifier key state.
    * Note that some devices need some hack for the modifier key state.
    * This method does it automatically.
    *
    * @param aMessage    Handling message.
    */
   static ModifierKeyState GetModifierKeyState(UINT aMessage);
   /**
    * MozGetMessagePos() returns the mouse cursor position when GetMessage()
    * was called last time.  However, if we're sending a native message,
    * this returns the specified cursor position by
    * SynthesizeNativeMouseScrollEvent().
    */
   static POINTS GetCurrentMessagePos();
   /**
    * ProcessNativeMouseWheelMessage() processes WM_MOUSEWHEEL and
    * WM_MOUSEHWHEEL.  Additionally, processes WM_VSCROLL and WM_HSCROLL if they
    * should be processed as mouse wheel message.
    * This method posts MOZ_WM_MOUSEVWHEEL, MOZ_WM_MOUSEHWHEEL,
    * MOZ_WM_VSCROLL or MOZ_WM_HSCROLL if we need to dispatch mouse scroll
    * events.  That avoids deadlock with plugin process.
    *
    * @param aWidget     A window which receives the message.
    * @param aMessage    WM_MOUSEWHEEL, WM_MOUSEHWHEEL, WM_VSCROLL or
    *                    WM_HSCROLL.
    * @param aWParam     The wParam value of the message.
    * @param aLParam     The lParam value of the message.
    */
   void ProcessNativeMouseWheelMessage(nsWindowBase* aWidget,
                                       UINT aMessage,
                                       WPARAM aWParam,
                                       LPARAM aLParam);
   /**
    * ProcessNativeScrollMessage() processes WM_VSCROLL and WM_HSCROLL.
    * This method just call ProcessMouseWheelMessage() if the message should be
    * processed as mouse wheel message.  Otherwise, dispatches a content
    * command event.
    *
    * @param aWidget     A window which receives the message.
    * @param aMessage    WM_VSCROLL or WM_HSCROLL.
    * @param aWParam     The wParam value of the message.
    * @param aLParam     The lParam value of the message.
    * @return            TRUE if the message is processed.  Otherwise, FALSE.
    */
   bool ProcessNativeScrollMessage(nsWindowBase* aWidget,
                                   UINT aMessage,
                                   WPARAM aWParam,
                                   LPARAM aLParam);
   /**
    * HandleMouseWheelMessage() processes MOZ_WM_MOUSEVWHEEL and
    * MOZ_WM_MOUSEHWHEEL which are posted when one of our windows received
    * WM_MOUSEWHEEL or WM_MOUSEHWHEEL for avoiding deadlock with OOPP.
    *
    * @param aWidget     A window which receives the wheel message.
    * @param aMessage    MOZ_WM_MOUSEWHEEL or MOZ_WM_MOUSEHWHEEL.
    * @param aWParam     The wParam value of the original message.
    * @param aLParam     The lParam value of the original message.
    */
   void HandleMouseWheelMessage(nsWindowBase* aWidget,
                                UINT aMessage,
                                WPARAM aWParam,
                                LPARAM aLParam);
   /**
    * HandleScrollMessageAsMouseWheelMessage() processes the MOZ_WM_VSCROLL and
    * MOZ_WM_HSCROLL which are posted when one of mouse windows received
    * WM_VSCROLL or WM_HSCROLL and user wants them to emulate mouse wheel
    * message's behavior.
    *
    * @param aWidget     A window which receives the scroll message.
    * @param aMessage    MOZ_WM_VSCROLL or MOZ_WM_HSCROLL.
    * @param aWParam     The wParam value of the original message.
    * @param aLParam     The lParam value of the original message.
    */
   void HandleScrollMessageAsMouseWheelMessage(nsWindowBase* aWidget,
                                               UINT aMessage,
                                               WPARAM aWParam,
                                               LPARAM aLParam);
   /**
    * ComputeMessagePos() computes the cursor position when the message was
    * added to the queue.
    *
    * @param aMessage    Handling message.
    * @param aWParam     Handling message's wParam.
    * @param aLParam     Handling message's lParam.
    * @return            Mouse cursor position when the message is added to
    *                    the queue or current cursor position if the result of
    *                    ::GetMessagePos() is broken.
    */
   POINT ComputeMessagePos(UINT aMessage,
                           WPARAM aWParam,
                           LPARAM aLParam);
   class EventInfo {
   public:
     /**
      * @param aWidget   An nsWindow which is handling the event.
      * @param aMessage  Must be WM_MOUSEWHEEL or WM_MOUSEHWHEEL.
      */
     EventInfo(nsWindowBase* aWidget, UINT aMessage, WPARAM aWParam, LPARAM aLParam);
     bool CanDispatchWheelEvent() const;
     int32_t GetNativeDelta() const { return mDelta; }
     HWND GetWindowHandle() const { return mWnd; }
     const TimeStamp& GetTimeStamp() const { return mTimeStamp; }
     bool IsVertical() const { return mIsVertical; }
     bool IsPositive() const { return (mDelta > 0); }
     bool IsPage() const { return mIsPage; }
     /**
      * @return          Number of lines or pages scrolled per WHEEL_DELTA.
      */
     int32_t GetScrollAmount() const;
   protected:
     EventInfo() :
       mIsVertical(false), mIsPage(false), mDelta(0), mWnd(nullptr)
     {
     }
     // TRUE if event is for vertical scroll.  Otherwise, FALSE.
     bool mIsVertical;
     // TRUE if event scrolls per page, otherwise, FALSE.
     bool mIsPage;
     // The native delta value.
     int32_t mDelta;
     // The window handle which is handling the event.
     HWND mWnd;
     // Timestamp of the event.
     TimeStamp mTimeStamp;
   };
   class LastEventInfo : public EventInfo {
   public:
     LastEventInfo() :
       EventInfo(), mAccumulatedDelta(0)
     {
     }
     /**
      * CanContinueTransaction() checks whether the new event can continue the
      * last transaction or not.  Note that if there is no transaction, this
      * returns true.
      */
     bool CanContinueTransaction(const EventInfo& aNewEvent);
     /**
      * ResetTransaction() resets the transaction, i.e., the instance forgets
      * the last event information.
      */
     void ResetTransaction();
     /**
      * RecordEvent() saves the information of new event.
      */
     void RecordEvent(const EventInfo& aEvent);
     /**
      * InitWheelEvent() initializes NS_WHEEL_WHEEL event and
      * recomputes the remaning detla for the event.
      * This must be called only once during handling a message and after
      * RecordEvent() is called.
      *
      * @param aWidget           A window which will dispatch the event.
      * @param aWheelEvent       An NS_WHEEL_WHEEL event, this will be
      *                          initialized.
      * @param aModKeyState      Current modifier key state.
      * @return                  TRUE if the event is ready to dispatch.
      *                          Otherwise, FALSE.
      */
     bool InitWheelEvent(nsWindowBase* aWidget,
                         WidgetWheelEvent& aWheelEvent,
                         const ModifierKeyState& aModKeyState);
   private:
     static int32_t RoundDelta(double aDelta);
     int32_t mAccumulatedDelta;
   };
   LastEventInfo mLastEventInfo;
   class SystemSettings {
   public:
     SystemSettings() : mInitialized(false) {}
     void Init();
     void MarkDirty();
     void NotifyUserPrefsMayOverrideSystemSettings();
     int32_t GetScrollAmount(bool aForVertical) const
     {
       MOZ_ASSERT(mInitialized, "SystemSettings must be initialized");
       return aForVertical ? mScrollLines : mScrollChars;
     }
     bool IsPageScroll(bool aForVertical) const
     {
       MOZ_ASSERT(mInitialized, "SystemSettings must be initialized");
       return aForVertical ? (mScrollLines == WHEEL_PAGESCROLL) :
                             (mScrollChars == WHEEL_PAGESCROLL);
     }
   private:
     bool mInitialized;
     int32_t mScrollLines;
     int32_t mScrollChars;
   };
   SystemSettings mSystemSettings;
   class UserPrefs {
   public:
     UserPrefs();
     ~UserPrefs();
     void MarkDirty();
     bool IsScrollMessageHandledAsWheelMessage()
     {
       Init();
       return mScrollMessageHandledAsWheelMessage;
     }
     int32_t GetOverriddenVerticalScrollAmout()
     {
       Init();
       return mOverriddenVerticalScrollAmount;
     }
     int32_t GetOverriddenHorizontalScrollAmout()
     {
       Init();
       return mOverriddenHorizontalScrollAmount;
     }
     int32_t GetMouseScrollTransactionTimeout()
     {
       Init();
       return mMouseScrollTransactionTimeout;
     }
   private:
     void Init();
     static void OnChange(const char* aPrefName, void* aClosure)
     {
       static_cast<UserPrefs*>(aClosure)->MarkDirty();
     }
     bool mInitialized;
     bool mScrollMessageHandledAsWheelMessage;
     int32_t mOverriddenVerticalScrollAmount;
     int32_t mOverriddenHorizontalScrollAmount;
     int32_t mMouseScrollTransactionTimeout;
   };
   UserPrefs mUserPrefs;
   class SynthesizingEvent {
   public:
     SynthesizingEvent() :
       mWnd(nullptr), mMessage(0), mWParam(0), mLParam(0),
       mStatus(NOT_SYNTHESIZING)
     {
     }
     ~SynthesizingEvent() {}
     static bool IsSynthesizing();
     nsresult Synthesize(const POINTS& aCursorPoint, HWND aWnd,
                         UINT aMessage, WPARAM aWParam, LPARAM aLParam,
                         const BYTE (&aKeyStates)[256]);
     void NativeMessageReceived(nsWindowBase* aWidget, UINT aMessage,
                                WPARAM aWParam, LPARAM aLParam);
     void NotifyNativeMessageHandlingFinished();
     void NotifyInternalMessageHandlingFinished();
     const POINTS& GetCursorPoint() const { return mCursorPoint; }
   private:
     POINTS mCursorPoint;
     HWND mWnd;
     UINT mMessage;
     WPARAM mWParam;
     LPARAM mLParam;
     BYTE mKeyState[256];
     BYTE mOriginalKeyState[256];
     enum Status {
       NOT_SYNTHESIZING,
       SENDING_MESSAGE,
       NATIVE_MESSAGE_RECEIVED,
       INTERNAL_MESSAGE_POSTED,
     };
     Status mStatus;
 #ifdef PR_LOGGING
     const char* GetStatusName()
     {
       switch (mStatus) {
         case NOT_SYNTHESIZING:
           return "NOT_SYNTHESIZING";
         case SENDING_MESSAGE:
           return "SENDING_MESSAGE";
         case NATIVE_MESSAGE_RECEIVED:
           return "NATIVE_MESSAGE_RECEIVED";
         case INTERNAL_MESSAGE_POSTED:
           return "INTERNAL_MESSAGE_POSTED";
         default:
           return "Unknown";
       }
     }
 #endif
     void Finish();
   }; // SynthesizingEvent
   SynthesizingEvent* mSynthesizingEvent;
 public:
   class Device {
   public:
     class Elantech {
     public:
       /**
        * GetDriverMajorVersion() returns the installed driver's major version.
        * If Elantech's driver was installed, returns 0.
        */
       static int32_t GetDriverMajorVersion();
       /**
        * IsHelperWindow() checks whether aWnd is a helper window of Elantech's
        * touchpad.  Returns TRUE if so.  Otherwise, FALSE.
        */
       static bool IsHelperWindow(HWND aWnd);
       /**
        * Key message handler for Elantech's hack.  Returns TRUE if the message
        * is consumed by this handler.  Otherwise, FALSE.
        */
       static bool HandleKeyMessage(nsWindowBase* aWidget,
                                    UINT aMsg,
                                    WPARAM aWParam);
       static void UpdateZoomUntil();
       static bool IsZooming();
       static void Init();
       static bool IsPinchHackNeeded() { return sUsePinchHack; }
     private:
       // Whether to enable the Elantech swipe gesture hack.
       static bool sUseSwipeHack;
       // Whether to enable the Elantech pinch-to-zoom gesture hack.
       static bool sUsePinchHack;
       static DWORD sZoomUntil;
     }; // class Elantech
     class TrackPoint {
     public:
       /**
        * IsDriverInstalled() returns TRUE if TrackPoint's driver is installed.
        * Otherwise, returns FALSE.
        */
       static bool IsDriverInstalled();
     }; // class TrackPoint
     class UltraNav {
     public:
       /**
        * IsObsoleteDriverInstalled() checks whether obsoleted UltraNav
        * is installed on the environment.
        * Returns TRUE if it was installed.  Otherwise, FALSE.
        */
       static bool IsObsoleteDriverInstalled();
     }; // class UltraNav
     class SetPoint {
     public:
       /**
        * SetPoint, Logitech's mouse driver, may report wrong cursor position
        * for WM_MOUSEHWHEEL message.  See comment in the implementation for
        * the detail.
        */
       static bool IsGetMessagePosResponseValid(UINT aMessage,
                                                WPARAM aWParam,
                                                LPARAM aLParam);
     private:
       static bool sMightBeUsing;
     };
     static void Init();
     static bool IsFakeScrollableWindowNeeded()
     {
       return sFakeScrollableWindowNeeded;
     }
   private:
     /**
      * Gets the bool value of aPrefName used to enable or disable an input
      * workaround (like the Trackpoint hack).  The pref can take values 0 (for
      * disabled), 1 (for enabled) or -1 (to automatically detect whether to
      * enable the workaround).
      *
      * @param aPrefName The name of the pref.
      * @param aValueIfAutomatic Whether the given input workaround should be
      *                          enabled by default.
      */
     static bool GetWorkaroundPref(const char* aPrefName,
                                   bool aValueIfAutomatic);
     static bool sFakeScrollableWindowNeeded;
   }; // class Device
 };
 } // namespace widget
 } // namespace mozilla
 #endif // mozilla_widget_WinMouseScrollHandler_h__

The Tor Browser / annotate

widget/windows/WinMouseScrollHandler.h@ac0c01689b40 (annotated)

widget/windows/WinMouseScrollHandler.h