Move ResourceOwner on to the oilpan heap.

third_party/WebKit/Source/core/loader/DocumentThreadableLoader.h

 /*
  * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013, Intel Corporation
  *
  * 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.
@@ skipping 35 matching lines @@
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class Document;
 class KURL;
 class ResourceRequest;
 class SecurityOrigin;
 class ThreadableLoaderClient;
 
-class CORE_EXPORT DocumentThreadableLoader final : public ThreadableLoader, private ResourceOwner<RawResource>  {
+class CORE_EXPORT DocumentThreadableLoader final : public ThreadableLoader, private RawResourceClient {
     USING_FAST_MALLOC(DocumentThreadableLoader);
     public:
         static void loadResourceSynchronously(Document&, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&, const ResourceLoaderOptions&);
         static PassRefPtr<DocumentThreadableLoader> create(Document&, ThreadableLoaderClient*, const ResourceRequest&, const ThreadableLoaderOptions&, const ResourceLoaderOptions&);
         ~DocumentThreadableLoader() override;
 
         void overrideTimeout(unsigned long timeout) override;
 
         // |this| may be dead after calling this method in async mode.
         void cancel() override;
@@ skipping 72 matching lines @@
         void handleError(const ResourceError&);
 
         void loadRequest(const ResourceRequest&, ResourceLoaderOptions);
         bool isAllowedRedirect(const KURL&) const;
         bool isAllowedByContentSecurityPolicy(const KURL&, ContentSecurityPolicy::RedirectStatus) const;
         // Returns DoNotAllowStoredCredentials
         // if m_forceDoNotAllowStoredCredentials is set. Otherwise, just
         // returns allowCredentials value of m_resourceLoaderOptions.
         StoredCredentials effectiveAllowCredentials() const;
 
+        // TODO(oilpan): DocumentThreadableLoader used to be a ResourceOwner,
+        // but ResourceOwner was moved onto the oilpan heap before
+        // DocumentThreadableLoader was ready. When DocumentThreadableLoader

[haraken, 2016/01/12 00:22:52]

Just help me understand: In what sense is it not ready?

[yhirano, 2016/01/12 07:54:49]

Making ThreadableLoader on-heap means making WorkerThreadableLoader on-heap. I'm
planning to propose a mechanism that mitigates cross-thread oilpan programming
difficulties and I would be happy if the class remains off-heap for a certain
time.

+        // moves onto the oilpan heap, make it a ResourceOwner again and remove
+        // this re-implementation of ResourceOwner.
+        RawResource* resource() const { return m_resource.get(); }
+        void clearResource() { setResource(nullptr); }
+        void setResource(const ResourcePtr<RawResource>& newResource)
+        {
+            if (newResource == m_resource)
+                return;
+
+            if (ResourcePtr<RawResource> oldResource = m_resource) {
+                m_resource.clear();
+                oldResource->removeClient(this);
+            }
+
+            if (newResource) {
+                m_resource = newResource;
+                m_resource->addClient(this);
+            }
+        }
+        ResourcePtr<RawResource> m_resource;
+        // End of ResourceOwner re-implementation, see above.
+
         SecurityOrigin* securityOrigin() const;
         Document& document() const;
 
         ThreadableLoaderClient* m_client;
         RawPtrWillBeWeakPersistent<Document> m_document;
 
         const ThreadableLoaderOptions m_options;
         // Some items may be overridden by m_forceDoNotAllowStoredCredentials
         // and m_securityOrigin. In such a case, build a ResourceLoaderOptions
         // with up-to-date values from them and this variable, and use it.
@@ skipping 37 matching lines @@
         // But this value is not the max number of total redirects allowed,
         // because same-origin redirects are not counted here.
         int m_corsRedirectLimit;
 
         const WebURLRequest::FetchRedirectMode m_redirectMode;
     };
 
 } // namespace blink
 
 #endif // DocumentThreadableLoader_h