Remove UserGestureUtilizedCallback, it's unused outside of tests

third_party/WebKit/Source/platform/UserGestureIndicator.h

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 15 matching lines @@
 #ifndef UserGestureIndicator_h
 #define UserGestureIndicator_h
 
 #include "platform/PlatformExport.h"
 #include "platform/wtf/Noncopyable.h"
 #include "platform/wtf/RefCounted.h"
 #include "platform/wtf/RefPtr.h"
 
 namespace blink {
 
-// Callback to be invoked when the state of a UserGestureIndicator is
-// used (only during the scope of a UserGestureIndicator, does
-// not flow with the UserGestureToken).  It's the responsibility of the
-// caller to ensure the UserGestureUtilizedCallback is kept alive as long
-// as the UserGestureIndicator it's used in.
-// Note that this doesn't currently track EVERY way in which the
-// state of a UserGesture can be read (sometimes it's just propagated
-// elsewhere, or otherwise read in a way that's hard to know if it will
-// actually be used), but should include the primary use cases.  Therefore
-// this is suitable mainly for diagnostics and measurement purposes.
-class PLATFORM_EXPORT UserGestureUtilizedCallback {
- public:
-  virtual ~UserGestureUtilizedCallback() = default;
-  virtual void UserGestureUtilized() = 0;
-};
-
 // A UserGestureToken represents a user gesture. It can be referenced and saved
 // for later (see, e.g., DOMTimer, which propagates user gestures to the timer
 // fire in certain situations). Passing it to a UserGestureIndicator will cause
 // it to be considered as currently being processed.
 class PLATFORM_EXPORT UserGestureToken : public RefCounted<UserGestureToken> {
   WTF_MAKE_NONCOPYABLE(UserGestureToken);
 
  public:
   enum Status { kNewGesture, kPossiblyExistingGesture };
   enum TimeoutPolicy { kDefault, kOutOfProcess, kHasPaused };
 
   ~UserGestureToken() {}
   bool HasGestures() const;
   void TransferGestureTo(UserGestureToken*);
   bool ConsumeGesture();
   void SetTimeoutPolicy(TimeoutPolicy);
   void ResetTimestamp();
 
-  // If this UserGestureToken is wrapped in a UserGestureIndicator, and the
-  // UserGestureIndicator is the lowest on the callstack (and therefore this
-  // UserGestureToken is UserGestureIndicator::s_rootToken), then the callback
-  // provided here will be called when this UserGestureToken is utilized.
-  // Calling setUserGestureUtilizedCallback() on a UserGestureToken that is not
-  // UserGestureIndicator::s_rootToken would be unsafe and never result in a
-  // callback, so it will fail a CHECK() instead.
-  void SetUserGestureUtilizedCallback(UserGestureUtilizedCallback*);
-  void UserGestureUtilized();
-
  protected:
   UserGestureToken(Status);
 
  private:
   bool HasTimedOut() const;
 
   size_t consumable_gestures_;
   double timestamp_;
   TimeoutPolicy timeout_policy_;
-  UserGestureUtilizedCallback* usage_callback_;
 };
 
 class PLATFORM_EXPORT UserGestureIndicator final {
   USING_FAST_MALLOC(UserGestureIndicator);
   WTF_MAKE_NONCOPYABLE(UserGestureIndicator);
 
  public:
   // Note: All *ThreadSafe methods are safe to call from any thread. Their
   // non-suffixed counterparts *must* be called on the main thread. Consider
   // always using the non-suffixed one unless the code really
   // needs to be thread-safe
 
   // Returns whether a user gesture is currently in progress.
-  // Does not invoke the UserGestureUtilizedCallback.  Consider calling
-  // utilizeUserGesture instead if you know for sure that the return value
-  // will have an effect.
   static bool ProcessingUserGesture();
   static bool ProcessingUserGestureThreadSafe();
 
-  // Indicates that a user gesture (if any) is being used, without preventing it
-  // from being used again.  Returns whether a user gesture is currently in
-  // progress.  If true, invokes (and then clears) any
-  // UserGestureUtilizedCallback.
-  static bool UtilizeUserGesture();
-
   // Mark the current user gesture (if any) as having been used, such that
   // it cannot be used again.  This is done only for very security-sensitive
   // operations like creating a new process.
-  // Like utilizeUserGesture, may invoke/clear any UserGestureUtilizedCallback.
   static bool ConsumeUserGesture();
   static bool ConsumeUserGestureThreadSafe();
 
   static UserGestureToken* CurrentToken();
   static UserGestureToken* CurrentTokenThreadSafe();
 
   explicit UserGestureIndicator(PassRefPtr<UserGestureToken>);
   ~UserGestureIndicator();
 
  private:
   static UserGestureToken* root_token_;
 
   RefPtr<UserGestureToken> token_;
 };
 
 }  // namespace blink
 
 #endif