Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp

 /*
  * Copyright (C) 2011, 2012 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 68 matching lines @@
 static const char fileSystemAgentEnabled[] = "fileSystemAgentEnabled";
 }
 
 namespace {
 
 template<typename BaseCallback, typename Handler, typename Argument>
 class GC_PLUGIN_IGNORE("crbug.com/513077") CallbackDispatcher final : public BaseCallback {
 public:
     typedef bool (Handler::*HandlingMethod)(Argument);
 
-    static CallbackDispatcher* create(PassRefPtrWillBeRawPtr<Handler> handler, HandlingMethod handlingMethod)
+    static CallbackDispatcher* create(RawPtr<Handler> handler, HandlingMethod handlingMethod)
     {
         return new CallbackDispatcher(handler, handlingMethod);
     }
 
     void handleEvent(Argument argument) override
     {
         (m_handler.get()->*m_handlingMethod)(argument);
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_handler);
         BaseCallback::trace(visitor);
     }
 
 private:
-    CallbackDispatcher(PassRefPtrWillBeRawPtr<Handler> handler, HandlingMethod handlingMethod)
+    CallbackDispatcher(RawPtr<Handler> handler, HandlingMethod handlingMethod)
         : m_handler(handler)
         , m_handlingMethod(handlingMethod) { }
 
-    RefPtrWillBeMember<Handler> m_handler;
+    Member<Handler> m_handler;
     HandlingMethod m_handlingMethod;
 };
 
 template<typename BaseCallback>
 class CallbackDispatcherFactory {
 public:
     template<typename Handler, typename Argument>
     static CallbackDispatcher<BaseCallback, Handler, Argument>* create(Handler* handler, bool (Handler::*handlingMethod)(Argument))
     {
-        return CallbackDispatcher<BaseCallback, Handler, Argument>::create(PassRefPtrWillBeRawPtr<Handler>(handler), handlingMethod);
+        return CallbackDispatcher<BaseCallback, Handler, Argument>::create(RawPtr<Handler>(handler), handlingMethod);
     }
 };
 
-class FileSystemRootRequest final : public RefCountedWillBeGarbageCollectedFinalized<FileSystemRootRequest> {
+class FileSystemRootRequest final : public GarbageCollectedFinalized<FileSystemRootRequest> {
     WTF_MAKE_NONCOPYABLE(FileSystemRootRequest);
 public:
-    static PassRefPtrWillBeRawPtr<FileSystemRootRequest> create(PassRefPtr<RequestFileSystemRootCallback> requestCallback, const String& type)
+    static RawPtr<FileSystemRootRequest> create(PassRefPtr<RequestFileSystemRootCallback> requestCallback, const String& type)
     {
-        return adoptRefWillBeNoop(new FileSystemRootRequest(requestCallback, type));
+        return (new FileSystemRootRequest(requestCallback, type));
     }
 
     void start(ExecutionContext*);
 
     DEFINE_INLINE_TRACE()
     {
     }
 
 private:
     bool didHitError(FileError* error)
@@ skipping 43 matching lines @@
 bool FileSystemRootRequest::didGetEntry(Entry* entry)
 {
     RefPtr<TypeBuilder::FileSystem::Entry> result = TypeBuilder::FileSystem::Entry::create()
         .setUrl(entry->toURL())
         .setName("/")
         .setIsDirectory(true);
     reportResult(static_cast<FileError::ErrorCode>(0), result);
     return true;
 }
 
-class DirectoryContentRequest final : public RefCountedWillBeGarbageCollectedFinalized<DirectoryContentRequest> {
+class DirectoryContentRequest final : public GarbageCollectedFinalized<DirectoryContentRequest> {
     WTF_MAKE_NONCOPYABLE(DirectoryContentRequest);
 public:
-    static PassRefPtrWillBeRawPtr<DirectoryContentRequest> create(PassRefPtr<RequestDirectoryContentCallback> requestCallback, const String& url)
+    static RawPtr<DirectoryContentRequest> create(PassRefPtr<RequestDirectoryContentCallback> requestCallback, const String& url)
     {
-        return adoptRefWillBeNoop(new DirectoryContentRequest(requestCallback, url));
+        return (new DirectoryContentRequest(requestCallback, url));
     }
 
     ~DirectoryContentRequest()
     {
     }
 
     void start(ExecutionContext*);
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
@@ skipping 17 matching lines @@
 
     DirectoryContentRequest(PassRefPtr<RequestDirectoryContentCallback> requestCallback, const String& url)
         : m_requestCallback(requestCallback)
         , m_url(ParsedURLString, url) { }
 
     void readDirectoryEntries();
 
     RefPtr<RequestDirectoryContentCallback> m_requestCallback;
     KURL m_url;
     RefPtr<Array<TypeBuilder::FileSystem::Entry>> m_entries;
-    PersistentWillBeMember<DirectoryReader> m_directoryReader;
+    Member<DirectoryReader> m_directoryReader;
 };
 
 void DirectoryContentRequest::start(ExecutionContext* executionContext)
 {
     ASSERT(executionContext);
 
     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DirectoryContentRequest::didHitError);
     EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &DirectoryContentRequest::didGetEntry);
 
     OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
@@ skipping 64 matching lines @@
             entryForFrontend->setMimeType(mimeType);
             entryForFrontend->setResourceType(resourceType);
         }
 
         m_entries->addItem(entryForFrontend);
     }
     readDirectoryEntries();
     return true;
 }
 
-class MetadataRequest final : public RefCountedWillBeGarbageCollectedFinalized<MetadataRequest> {
+class MetadataRequest final : public GarbageCollectedFinalized<MetadataRequest> {
     WTF_MAKE_NONCOPYABLE(MetadataRequest);
 public:
-    static PassRefPtrWillBeRawPtr<MetadataRequest> create(PassRefPtr<RequestMetadataCallback> requestCallback, const String& url)
+    static RawPtr<MetadataRequest> create(PassRefPtr<RequestMetadataCallback> requestCallback, const String& url)
     {
-        return adoptRefWillBeNoop(new MetadataRequest(requestCallback, url));
+        return (new MetadataRequest(requestCallback, url));
     }
 
     ~MetadataRequest()
     {
     }
 
     void start(ExecutionContext*);
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
@@ skipping 53 matching lines @@
     RefPtr<Metadata> result = Metadata::create()
         .setModificationTime(metadata->modificationTime())
         .setSize(metadata->size());
     reportResult(static_cast<FileError::ErrorCode>(0), result);
     return true;
 }
 
 class FileContentRequest final : public EventListener {
     WTF_MAKE_NONCOPYABLE(FileContentRequest);
 public:
-    static PassRefPtrWillBeRawPtr<FileContentRequest> create(PassRefPtr<RequestFileContentCallback> requestCallback, const String& url, bool readAsText, long long start, long long end, const String& charset)
+    static RawPtr<FileContentRequest> create(PassRefPtr<RequestFileContentCallback> requestCallback, const String& url, bool readAsText, long long start, long long end, const String& charset)
     {
-        return adoptRefWillBeNoop(new FileContentRequest(requestCallback, url, readAsText, start, end, charset));
+        return (new FileContentRequest(requestCallback, url, readAsText, start, end, charset));
     }
 
     ~FileContentRequest() override
     {
     }
 
     void start(ExecutionContext*);
 
     bool operator==(const EventListener& other) const override
     {
@@ skipping 40 matching lines @@
         , m_charset(charset) { }
 
     RefPtr<RequestFileContentCallback> m_requestCallback;
     KURL m_url;
     bool m_readAsText;
     int m_start;
     long long m_end;
     String m_mimeType;
     String m_charset;
 
-    PersistentWillBeMember<FileReader> m_reader;
+    Member<FileReader> m_reader;
 };
 
 void FileContentRequest::start(ExecutionContext* executionContext)
 {
     ASSERT(executionContext);
 
     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &FileContentRequest::didHitError);
     EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &FileContentRequest::didGetEntry);
 
     OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
@@ skipping 44 matching lines @@
         return;
     }
 
     OwnPtr<TextResourceDecoder> decoder = TextResourceDecoder::create(m_mimeType, m_charset, true);
     String result = decoder->decode(static_cast<char*>(buffer->data()), buffer->byteLength());
     result = result + decoder->flush();
     m_charset = decoder->encoding().name();
     reportResult(static_cast<FileError::ErrorCode>(0), &result, &m_charset);
 }
 
-class DeleteEntryRequest final : public RefCountedWillBeGarbageCollectedFinalized<DeleteEntryRequest> {
+class DeleteEntryRequest final : public GarbageCollectedFinalized<DeleteEntryRequest> {
 public:
-    static PassRefPtrWillBeRawPtr<DeleteEntryRequest> create(PassRefPtr<DeleteEntryCallback> requestCallback, const KURL& url)
+    static RawPtr<DeleteEntryRequest> create(PassRefPtr<DeleteEntryCallback> requestCallback, const KURL& url)
     {
-        return adoptRefWillBeNoop(new DeleteEntryRequest(requestCallback, url));
+        return (new DeleteEntryRequest(requestCallback, url));
     }
 
     ~DeleteEntryRequest()
     {
     }
 
     void start(ExecutionContext*);
 
     DEFINE_INLINE_TRACE()
     {
     }
 
 private:
     // CallbackDispatcherFactory doesn't handle 0-arg handleEvent methods
     class VoidCallbackImpl final : public VoidCallback {
     public:
-        explicit VoidCallbackImpl(PassRefPtrWillBeRawPtr<DeleteEntryRequest> handler)
+        explicit VoidCallbackImpl(RawPtr<DeleteEntryRequest> handler)
             : m_handler(handler)
         {
         }
 
         void handleEvent() override
         {
             m_handler->didDeleteEntry();
         }
 
         DEFINE_INLINE_VIRTUAL_TRACE()
         {
             visitor->trace(m_handler);
             VoidCallback::trace(visitor);
         }
 
     private:
-        RefPtrWillBeMember<DeleteEntryRequest> m_handler;
+        Member<DeleteEntryRequest> m_handler;
     };
 
     bool didHitError(FileError* error)
     {
         reportResult(error->code());
         return true;
     }
 
     bool didGetEntry(Entry*);
     bool didDeleteEntry();
@@ skipping 50 matching lines @@
 
 bool DeleteEntryRequest::didDeleteEntry()
 {
     reportResult(static_cast<FileError::ErrorCode>(0));
     return true;
 }
 
 } // anonymous namespace
 
 // static
-PassOwnPtrWillBeRawPtr<InspectorFileSystemAgent> InspectorFileSystemAgent::create(InspectedFrames* inspectedFrames)
+RawPtr<InspectorFileSystemAgent> InspectorFileSystemAgent::create(InspectedFrames* inspectedFrames)
 {
-    return adoptPtrWillBeNoop(new InspectorFileSystemAgent(inspectedFrames));
+    return (new InspectorFileSystemAgent(inspectedFrames));
 }
 
 InspectorFileSystemAgent::~InspectorFileSystemAgent()
 {
 }
 
 void InspectorFileSystemAgent::enable(ErrorString*)
 {
     if (m_enabled)
         return;
@@ skipping 106 matching lines @@
     return 0;
 }
 
 DEFINE_TRACE(InspectorFileSystemAgent)
 {
     visitor->trace(m_inspectedFrames);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink