UserGestureIndicator: remove many unnecessary calls to isMainThread

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 76 matching lines @@
   double m_timestamp;
   TimeoutPolicy m_timeoutPolicy;
   UserGestureUtilizedCallback* m_usageCallback;
 };
 
 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.

[kinuko, 2016/12/12 14:51:26]

Let's add: "Consider always using the non-suffixed one unless the code really
needs to be thread-safe" or something like that

[Charlie Harrison, 2016/12/12 15:20:47]

Done.

+
   // 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();

[kinuko, 2016/12/12 04:45:12]

We don't need this and currentTokenThreadSafe other than in
processingUserGestureThreadSafe?

If so I started to think we should probably just keep the non-thread-safe
versions but add a thread-safety check at the callsites for these two.  (Sorry
for saying opposite to my previous comments)

[Charlie Harrison, 2016/12/12 13:10:09]

We use currentTokenThreadSafe in DOMTimer, and we use this and
currentTokenThreadSafe in the WebUserGestureIndicator. These are few enough
locations that we can make the isMainThread() call at the callsites if you
prefer though.

[Charlie Harrison, 2016/12/12 15:20:47]

I don't think this comment was properly resolved. Is your L-G contingent on
removing these ThreadSafes and moving the isMainThread() check to callsites, or
are these enough places where having the ThreadSafe API makes sense?

[kinuko, 2016/12/12 15:37:49]

Sorry I hadn't explicitly responded to this one. I had forgotten the use case in
DOMTimer so I thought it probably gives a reason to have the thread-safe version
for this one-- but then I looked the code site again and now I have another
comment :)

 
   static UserGestureToken* currentToken();
+  static UserGestureToken* currentTokenThreadSafe();
 
   explicit UserGestureIndicator(PassRefPtr<UserGestureToken>);
   ~UserGestureIndicator();
 
  private:
   static UserGestureToken* s_rootToken;
 
   RefPtr<UserGestureToken> m_token;
 };
 
 }  // namespace blink
 
 #endif