[OBSOLETE] Remove WebURLResponse::initialize()

third_party/WebKit/Source/platform/exported/WebURLResponse.cpp

 /*
  * Copyright (C) 2009 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 21 matching lines @@
 
 #include "platform/exported/WebURLResponsePrivate.h"
 #include "platform/network/ResourceLoadTiming.h"
 #include "platform/network/ResourceResponse.h"
 #include "public/platform/WebHTTPHeaderVisitor.h"
 #include "public/platform/WebHTTPLoadInfo.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLLoadTiming.h"
 #include "wtf/Allocator.h"
+#include "wtf/Assertions.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 class ExtraDataContainer : public ResourceResponse::ExtraData {
 public:
@@ skipping 17 matching lines @@
 // The standard implementation of WebURLResponsePrivate, which maintains
 // ownership of a ResourceResponse instance.
 class WebURLResponsePrivateImpl final : public WebURLResponsePrivate {
     USING_FAST_MALLOC(WebURLResponsePrivateImpl);
 public:
     WebURLResponsePrivateImpl()
     {
         m_resourceResponse = &m_resourceResponseAllocation;
     }
 
-    WebURLResponsePrivateImpl(const WebURLResponsePrivate* p)
-        : m_resourceResponseAllocation(*p->m_resourceResponse)
+    WebURLResponsePrivateImpl(const WebURLResponsePrivate& p)
+        : m_resourceResponseAllocation(*p.m_resourceResponse)
     {
         m_resourceResponse = &m_resourceResponseAllocation;
     }
 
     virtual void dispose() { delete this; }
 
 private:
     virtual ~WebURLResponsePrivateImpl() { }
 
     ResourceResponse m_resourceResponseAllocation;
 };
 
-void WebURLResponse::initialize()
+WebURLResponse::~WebURLResponse()
 {
-    assign(new WebURLResponsePrivateImpl());
+    m_private->dispose();
 }
 
-void WebURLResponse::reset()
+WebURLResponse::WebURLResponse()
+    : m_private(new WebURLResponsePrivateImpl())
 {
-    assign(0);
+}
+WebURLResponse::WebURLResponse(const WebURLResponse& r)
+    : m_private(new WebURLResponsePrivateImpl(*r.m_private))
+{
 }
 
-void WebURLResponse::assign(const WebURLResponse& r)
+WebURLResponse::WebURLResponse(const WebURL& url)
+    : WebURLResponse()
+{
+    setURL(url);
+}
+
+WebURLResponse& WebURLResponse::operator=(const WebURLResponse& r)
 {
     if (&r != this)
-        assign(r.m_private ? new WebURLResponsePrivateImpl(r.m_private) : 0);
+        assign(new WebURLResponsePrivateImpl(*r.m_private));
+    return *this;
 }
 
 bool WebURLResponse::isNull() const
 {
-    return !m_private || m_private->m_resourceResponse->isNull();
+    return m_private->m_resourceResponse->isNull();
 }
 
 WebURL WebURLResponse::url() const
 {
     return m_private->m_resourceResponse->url();
 }
 
 void WebURLResponse::setURL(const WebURL& url)
 {
     m_private->m_resourceResponse->setURL(url);
@@ skipping 209 matching lines @@
         webSecurityDetails.cipher,
         webSecurityDetails.mac,
         webSecurityDetails.certId,
         webSecurityDetails.numUnknownScts,
         webSecurityDetails.numInvalidScts,
         webSecurityDetails.numValidScts);
 }
 
 ResourceResponse& WebURLResponse::toMutableResourceResponse()
 {
-    ASSERT(m_private);
-    ASSERT(m_private->m_resourceResponse);
+    DCHECK(m_private);

[kinuko, 2016/07/05 14:59:44]

This DCHECK seems redundant now (here and below)

+    DCHECK(m_private->m_resourceResponse);
 
     return *m_private->m_resourceResponse;
 }
 
 const ResourceResponse& WebURLResponse::toResourceResponse() const
 {
-    ASSERT(m_private);
-    ASSERT(m_private->m_resourceResponse);
+    DCHECK(m_private);
+    DCHECK(m_private->m_resourceResponse);
 
     return *m_private->m_resourceResponse;
 }
 
 bool WebURLResponse::wasCached() const
 {
     return m_private->m_resourceResponse->wasCached();
 }
 
 void WebURLResponse::setWasCached(bool value)
@@ skipping 139 matching lines @@
     if (!data)
         return 0;
     return static_cast<ExtraDataContainer*>(data.get())->getExtraData();
 }
 
 void WebURLResponse::setExtraData(WebURLResponse::ExtraData* extraData)
 {
     m_private->m_resourceResponse->setExtraData(ExtraDataContainer::create(extraData));
 }
 
+WebURLResponse::WebURLResponse(WebURLResponsePrivate* p)
+    : m_private(p)
+{
+    DCHECK(p);
+}
+
 void WebURLResponse::assign(WebURLResponsePrivate* p)

[kinuko, 2016/07/05 14:59:44]

At this point I don't feel having this method's very helpful.  In this class's
assignment operator calling dispose() and reallocating WebURLResponsePrivateImpl
isn't probably really necessary either.

I feel WebURLResponsePrivate doesn't need to have m_resourceResponse in its base
class, it's very confusing actually.  It can just expose pure virtual setter and
getter methods and WebURLResponse::operator= and WrappedResourceResponse::bind
can directly call the setter?

 {
-    // Subclasses may call this directly so a self-assignment check is needed
-    // here as well as in the public assign method.
+    DCHECK(p);
+    // Subclasses may perform self-assignment.
     if (m_private == p)
         return;
-    if (m_private)
-        m_private->dispose();
+    m_private->dispose();
     m_private = p;
 }
 
 } // namespace blink