Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.h

 /*
  * Copyright (C) 2009 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 125 matching lines @@
         if (!m_readFramebufferBinding && m_drawingBuffer)
             m_drawingBuffer->restoreFramebufferBindings();
     }
 
 private:
     DrawingBuffer* m_drawingBuffer;
     Member<WebGLFramebuffer> m_readFramebufferBinding;
 };
 
 class MODULES_EXPORT WebGLRenderingContextBase : public CanvasRenderingContext, public Page::MultisamplingChangedObserver {
-    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(WebGLRenderingContextBase);
+    USING_GARBAGE_COLLECTED_MIXIN(WebGLRenderingContextBase);
 public:
     ~WebGLRenderingContextBase() override;
 
     virtual unsigned version() const = 0;
     virtual String contextName() const = 0;
     virtual void registerContextExtensions() = 0;
 
     virtual void initializeNewContext();
 
     static unsigned getWebGLVersion(const CanvasRenderingContext*);
@@ skipping 130 matching lines @@
         GLenum format, GLenum type, DOMArrayBufferView*);
     void texImage2D(GLenum target, GLint level, GLint internalformat,
         GLenum format, GLenum type, ImageData*);
     void texImage2D(GLenum target, GLint level, GLint internalformat,
         GLenum format, GLenum type, HTMLImageElement*, ExceptionState&);
     void texImage2D(GLenum target, GLint level, GLint internalformat,
         GLenum format, GLenum type, HTMLCanvasElement*, ExceptionState&);
     void texImage2D(GLenum target, GLint level, GLint internalformat,
         GLenum format, GLenum type, HTMLVideoElement*, ExceptionState&);
     void texImage2D(GLenum target, GLint level, GLint internalformat,
-        GLenum format, GLenum type, PassRefPtrWillBeRawPtr<ImageBitmap>, ExceptionState&);
+        GLenum format, GLenum type, RawPtr<ImageBitmap>, ExceptionState&);
 
     void texParameterf(GLenum target, GLenum pname, GLfloat param);
     void texParameteri(GLenum target, GLenum pname, GLint param);
 
     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
         GLsizei width, GLsizei height,
         GLenum format, GLenum type, DOMArrayBufferView*);
     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
         GLenum format, GLenum type, ImageData*);
     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
         GLenum format, GLenum type, HTMLImageElement*, ExceptionState&);
     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
         GLenum format, GLenum type, HTMLCanvasElement*, ExceptionState&);
     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
         GLenum format, GLenum type, HTMLVideoElement*, ExceptionState&);
     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
-        GLenum format, GLenum type, PassRefPtrWillBeRawPtr<ImageBitmap>, ExceptionState&);
+        GLenum format, GLenum type, RawPtr<ImageBitmap>, ExceptionState&);
 
     void uniform1f(const WebGLUniformLocation*, GLfloat x);
     void uniform1fv(const WebGLUniformLocation*, const FlexibleFloat32ArrayView&);
     void uniform1fv(const WebGLUniformLocation*, Vector<GLfloat>&);
     void uniform1i(const WebGLUniformLocation*, GLint x);
     void uniform1iv(const WebGLUniformLocation*, const FlexibleInt32ArrayView&);
     void uniform1iv(const WebGLUniformLocation*, Vector<GLint>&);
     void uniform2f(const WebGLUniformLocation*, GLfloat x, GLfloat y);
     void uniform2fv(const WebGLUniformLocation*, const FlexibleFloat32ArrayView&);
     void uniform2fv(const WebGLUniformLocation*, Vector<GLfloat>&);
@@ skipping 193 matching lines @@
     HeapHashSet<WeakMember<WebGLContextObject>> m_contextObjects;
 #else
     // The hash set isn't traced, hence the references are effectively
     // weakly kept. Each WebGLContextObject is responsible for detaching
     // itself upon finalization if the WebGLRenderingContextBase hasn't been
     // finalized already and detached them via detachAndRemoveAllObjects().
     // See http://crbug.com/534524 for the details.
     HashSet<UntracedMember<WebGLContextObject>> m_contextObjects;
 #endif
 
-    PersistentWillBeMember<WebGLRenderingContextErrorMessageCallback> m_errorMessageCallbackAdapter;
+    Member<WebGLRenderingContextErrorMessageCallback> m_errorMessageCallbackAdapter;
 
     // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
-    PersistentWillBeMember<WebGLBuffer> m_boundArrayBuffer;
+    Member<WebGLBuffer> m_boundArrayBuffer;
 
-    PersistentWillBeMember<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
-    PersistentWillBeMember<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
+    Member<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
+    Member<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
     bool m_preservedDefaultVAOObjectWrapper;
     void setBoundVertexArrayObject(ScriptState*, WebGLVertexArrayObjectBase*);
 
     enum VertexAttribValueType {
         Float32ArrayType,
         Int32ArrayType,
         Uint32ArrayType,
     };
 
     Vector<VertexAttribValueType> m_vertexAttribType;
     unsigned m_maxVertexAttribs;
     void setVertexAttribType(GLuint index, VertexAttribValueType);
 
-    PersistentWillBeMember<WebGLProgram> m_currentProgram;
-    PersistentWillBeMember<WebGLFramebuffer> m_framebufferBinding;
-    PersistentWillBeMember<WebGLRenderbuffer> m_renderbufferBinding;
-    PersistentWillBeMember<CHROMIUMValuebuffer> m_valuebufferBinding;
+    Member<WebGLProgram> m_currentProgram;
+    Member<WebGLFramebuffer> m_framebufferBinding;
+    Member<WebGLRenderbuffer> m_renderbufferBinding;
+    Member<CHROMIUMValuebuffer> m_valuebufferBinding;
 
-    PersistentHeapVectorWillBeHeapVector<TextureUnitState> m_textureUnits;
+    HeapVector<TextureUnitState> m_textureUnits;
     unsigned long m_activeTextureUnit;
 
     Vector<GLenum> m_compressedTextureFormats;
 
     // Fixed-size cache of reusable image buffers for video texImage2D calls.
     class LRUImageBufferCache {
     public:
         LRUImageBufferCache(int capacity);
         // The pointer returned is owned by the image buffer map.
         ImageBuffer* imageBuffer(const IntSize&);
@@ skipping 83 matching lines @@
         DEFINE_INLINE_VIRTUAL_TRACE() { }
 
     private:
         bool m_draft;
         const char* const* m_prefixes;
     };
 
     template <typename T>
     class TypedExtensionTracker final : public ExtensionTracker {
     public:
-        static TypedExtensionTracker<T>* create(PersistentWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
+        static TypedExtensionTracker<T>* create(Member<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
         {
             return new TypedExtensionTracker<T>(extensionField, flags, prefixes);
         }
 
         WebGLExtension* getExtension(WebGLRenderingContextBase* context) override
         {
             if (!m_extension) {
                 m_extension = T::create(context);
                 m_extensionField = m_extension;
             }
@@ skipping 20 matching lines @@
             }
         }
 
         DEFINE_INLINE_VIRTUAL_TRACE()
         {
             visitor->trace(m_extension);
             ExtensionTracker::trace(visitor);
         }
 
     private:
-        TypedExtensionTracker(PersistentWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
+        TypedExtensionTracker(Member<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
             : ExtensionTracker(flags, prefixes)
             , m_extensionField(extensionField)
         {
         }
 
         GC_PLUGIN_IGNORE("http://crbug.com/519953")
-        PersistentWillBeMember<T>& m_extensionField;
+        Member<T>& m_extensionField;
         // ExtensionTracker holds it's own reference to the extension to ensure
         // that it is not deleted before this object's destructor is called
         Member<T> m_extension;
     };
 
     bool m_extensionEnabled[WebGLExtensionNameCount];
-    PersistentHeapVectorWillBeHeapVector<Member<ExtensionTracker>> m_extensions;
+    HeapVector<Member<ExtensionTracker>> m_extensions;
 
     template <typename T>
-    void registerExtension(PersistentWillBeMember<T>& extensionPtr, ExtensionFlags flags = ApprovedExtension, const char* const* prefixes = nullptr)
+    void registerExtension(Member<T>& extensionPtr, ExtensionFlags flags = ApprovedExtension, const char* const* prefixes = nullptr)
     {
         m_extensions.append(TypedExtensionTracker<T>::create(extensionPtr, flags, prefixes));
     }
 
     bool extensionSupportedAndAllowed(const ExtensionTracker*);
 
     inline bool extensionEnabled(WebGLExtensionName name)
     {
         return m_extensionEnabled[name];
     }
@@ skipping 377 matching lines @@
 #endif
 };
 
 DEFINE_TYPE_CASTS(WebGLRenderingContextBase, CanvasRenderingContext, context, context->is3d(), context.is3d());
 
 } // namespace blink
 
 WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(blink::WebGLRenderingContextBase::TextureUnitState);
 
 #endif // WebGLRenderingContextBase_h