Use scoped_refptr in blink::WebString

WebString no longer needs to use WebPrivatePtr.
This CL replaces it with scoped_refptr for cleaner impls.

Bug: 781741
Change-Id: Icacecc2e2a35b59c1d16780625643844b76cbbfb
Reviewed-on: https://chromium-review.googlesource.com/762971
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#515916}

content/renderer/render_frame_impl.cc

@@ -4457,7 +4457,7 @@ bool RenderFrameImpl::RunModalPromptDialog(
                                 default_value.Utf16(),
                                 frame_->GetDocument().Url(), &result);
   if (ok)
-    actual_value->Assign(WebString::FromUTF16(result));
+    *actual_value = WebString::FromUTF16(result);
   return ok;
 }
 

content/renderer/service_worker/service_worker_context_client.cc

@@ -1680,7 +1680,7 @@ void ServiceWorkerContextClient::DispatchPushEvent(
   // Only set data to be a valid string if the payload had decrypted data.
   blink::WebString data;
   if (!payload.is_null)
-    data.Assign(blink::WebString::FromUTF8(payload.data));
+    data = blink::WebString::FromUTF8(payload.data);
   proxy_->DispatchPushEvent(request_id, data);
 }
 

third_party/WebKit/Source/modules/indexeddb/WebIDBCallbacksImpl.h

@@ -31,6 +31,8 @@
 
 #include <memory>
 
+#include "platform/heap/Persistent.h"
+#include "platform/wtf/Allocator.h"
 #include "public/platform/modules/indexeddb/WebIDBCallbacks.h"
 
 namespace blink {

third_party/WebKit/Source/modules/serviceworkers/NavigationPreloadCallbacks.h

@@ -5,6 +5,7 @@
 #ifndef NavigationPreloadCallbacks_h
 #define NavigationPreloadCallbacks_h
 
+#include "platform/heap/Persistent.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerRegistration.h"
 
 namespace blink {

third_party/WebKit/Source/platform/WebScheduler.cpp

@@ -6,6 +6,7 @@
 
 #include "platform/WebFrameScheduler.h"
 #include "platform/wtf/Assertions.h"
+#include "platform/wtf/Noncopyable.h"
 #include "public/platform/WebTraceLocation.h"
 
 namespace blink {

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

@@ -171,10 +171,10 @@ bool WebCORSPreflightResultCacheItem::AllowsCrossOriginMethod(
   if (!credentials_ && methods_.find("*") != methods_.end())
     return true;
 
-  error_description.Assign(WebString::FromASCII("Method " + method.Ascii() +
-                                                " is not allowed by "
-                                                "Access-Control-Allow-Methods "
-                                                "in preflight response."));
+  error_description = WebString::FromASCII("Method " + method.Ascii() +
+                                           " is not allowed by "
+                                           "Access-Control-Allow-Methods "
+                                           "in preflight response.");
 
   return false;
 }
@@ -189,10 +189,10 @@ bool WebCORSPreflightResultCacheItem::AllowsCrossOriginHeaders(
     if (headers_.find(header.key.Ascii().data()) == headers_.end() &&
         !FetchUtils::IsCORSSafelistedHeader(header.key, header.value) &&
         !FetchUtils::IsForbiddenHeaderName(header.key)) {
-      error_description.Assign(
-          String::Format("Request header field %s is not allowed by "
-                         "Access-Control-Allow-Headers in preflight response.",
-                         header.key.GetString().Utf8().data()));
+      error_description = String::Format(
+          "Request header field %s is not allowed by "
+          "Access-Control-Allow-Headers in preflight response.",
+          header.key.GetString().Utf8().data());
       return false;
     }
   }

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

@@ -50,36 +50,38 @@ STATIC_ASSERT_ENUM(
 
 namespace blink {
 
-void WebString::Reset() {
-  private_.Reset();
-}
+WebString::~WebString() = default;
+WebString::WebString() = default;
+WebString::WebString(const WebString&) = default;
+WebString::WebString(WebString&&) = default;
+WebString& WebString::operator=(const WebString&) = default;
+WebString& WebString::operator=(WebString&&) = default;
 
-void WebString::Assign(const WebString& other) {
-  Assign(other.private_.Get());
-}
+WebString::WebString(const WebUChar* data, size_t len)
+    : impl_(StringImpl::Create8BitIfPossible(data, len)) {}
 
-void WebString::Assign(const WebUChar* data, size_t length) {
-  Assign(StringImpl::Create8BitIfPossible(data, length).get());
+void WebString::Reset() {
+  impl_ = nullptr;
 }
 
 size_t WebString::length() const {
-  return private_.IsNull() ? 0 : private_->length();
+  return impl_ ? impl_->length() : 0;
 }
 
 bool WebString::Is8Bit() const {
-  return private_->Is8Bit();
+  return impl_->Is8Bit();
 }
 
 const WebLChar* WebString::Data8() const {
-  return !private_.IsNull() && Is8Bit() ? private_->Characters8() : nullptr;
+  return impl_ && Is8Bit() ? impl_->Characters8() : nullptr;
 }
 
 const WebUChar* WebString::Data16() const {
-  return !private_.IsNull() && !Is8Bit() ? private_->Characters16() : nullptr;
+  return impl_ && !Is8Bit() ? impl_->Characters16() : nullptr;
 }
 
 std::string WebString::Utf8(UTF8ConversionMode mode) const {
-  StringUTF8Adaptor utf8(private_.Get(),
+  StringUTF8Adaptor utf8(impl_.get(),
                          static_cast<WTF::UTF8ConversionMode>(mode));
   return std::string(utf8.Data(), utf8.length());
 }
@@ -89,31 +91,23 @@ WebString WebString::FromUTF8(const char* data, size_t length) {
 }
 
 WebString WebString::FromUTF16(const base::string16& s) {
-  WebString string;
-  string.Assign(s.data(), s.length());
-  return string;
+  return WebString(s.data(), s.length());
 }
 
 WebString WebString::FromUTF16(const base::NullableString16& s) {
-  WebString string;
   if (s.is_null())
-    string.Reset();
-  else
-    string.Assign(s.string().data(), s.string().length());
-  return string;
+    return WebString();
+  return WebString(s.string().data(), s.string().length());
 }
 
 WebString WebString::FromUTF16(const base::Optional<base::string16>& s) {
-  WebString string;
-  if (!s)
-    string.Reset();
-  else
-    string.Assign(s->data(), s->length());
-  return string;
+  if (!s.has_value())
+    return WebString();
+  return WebString(s->data(), s->length());
 }
 
 std::string WebString::Latin1() const {
-  String string(private_.Get());
+  String string(impl_);
 
   if (string.IsEmpty())
     return std::string();
@@ -136,17 +130,17 @@ std::string WebString::Ascii() const {
   if (IsEmpty())
     return std::string();
 
-  if (private_->Is8Bit()) {
-    return std::string(reinterpret_cast<const char*>(private_->Characters8()),
-                       private_->length());
+  if (impl_->Is8Bit()) {
+    return std::string(reinterpret_cast<const char*>(impl_->Characters8()),
+                       impl_->length());
   }
 
-  return std::string(private_->Characters16(),
-                     private_->Characters16() + private_->length());
+  return std::string(impl_->Characters16(),
+                     impl_->Characters16() + impl_->length());
 }
 
 bool WebString::ContainsOnlyASCII() const {
-  return String(private_.Get()).ContainsOnlyASCII();
+  return String(impl_).ContainsOnlyASCII();
 }
 
 WebString WebString::FromASCII(const std::string& s) {
@@ -155,43 +149,39 @@ WebString WebString::FromASCII(const std::string& s) {
 }
 
 bool WebString::Equals(const WebString& s) const {
-  return Equal(private_.Get(), s.private_.Get());
+  return Equal(impl_.get(), s.impl_.get());
 }
 
 bool WebString::Equals(const char* characters, size_t length) const {
-  return Equal(private_.Get(), characters, length);
+  return Equal(impl_.get(), characters, length);
 }
 
-WebString::WebString(const WTF::String& s) : private_(s.Impl()) {}
+WebString::WebString(const WTF::String& s) : impl_(s.Impl()) {}
 
 WebString& WebString::operator=(const WTF::String& s) {
-  Assign(s.Impl());
+  impl_ = s.Impl();
   return *this;
 }
 
 WebString::operator WTF::String() const {
-  return private_.Get();
+  return impl_.get();
 }
 
 WebString::operator WTF::StringView() const {
-  return StringView(private_.Get());
+  return StringView(impl_.get());
 }
 
 WebString::WebString(const WTF::AtomicString& s) {
-  Assign(s.GetString());
+  impl_ = s.Impl();
 }
 
 WebString& WebString::operator=(const WTF::AtomicString& s) {
-  Assign(s.GetString());
+  impl_ = s.Impl();
   return *this;
 }
 
 WebString::operator WTF::AtomicString() const {
-  return WTF::AtomicString(private_.Get());
-}
-
-void WebString::Assign(WTF::StringImpl* p) {
-  private_ = p;
+  return WTF::AtomicString(impl_);
 }
 
 }  // namespace blink

third_party/WebKit/Source/platform/testing/WebLayerTreeViewImplForTesting.h

@@ -5,11 +5,12 @@
 #ifndef WebLayerTreeViewImplForTesting_h
 #define WebLayerTreeViewImplForTesting_h
 
+#include <memory>
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_single_thread_client.h"
+#include "platform/wtf/Noncopyable.h"
 #include "public/platform/WebLayerTreeView.h"
-#include <memory>
 
 namespace cc {
 class AnimationHost;

third_party/WebKit/public/platform/WebBlobInfo.h

@@ -6,6 +6,7 @@
 #define WebBlobInfo_h
 
 #include "WebCommon.h"
+#include "WebPrivatePtr.h"
 #include "WebString.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 

third_party/WebKit/public/platform/WebRTCRtpReceiver.h

@@ -5,6 +5,7 @@
 #ifndef WebRTCRtpReceiver_h
 #define WebRTCRtpReceiver_h
 
+#include <memory>
 #include "WebCommon.h"
 #include "WebString.h"
 #include "WebVector.h"

third_party/WebKit/public/platform/WebString.h

@@ -33,7 +33,7 @@
 
 #include <string>
 #include "WebCommon.h"
-#include "WebPrivatePtr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/optional.h"
 #include "base/strings/latin1_string_conversions.h"
 #include "base/strings/nullable_string16.h"
@@ -97,22 +97,17 @@ class WebString {
     kStrictReplacingErrorsWithFFFD,
   };
 
-  ~WebString() { Reset(); }
+  BLINK_PLATFORM_EXPORT ~WebString();
+  BLINK_PLATFORM_EXPORT WebString();
+  BLINK_PLATFORM_EXPORT WebString(const WebUChar* data, size_t len);
 
-  WebString() {}
+  BLINK_PLATFORM_EXPORT WebString(const WebString&);
+  BLINK_PLATFORM_EXPORT WebString(WebString&&);
 
-  WebString(const WebUChar* data, size_t len) { Assign(data, len); }
-
-  WebString(const WebString& s) { Assign(s); }
-
-  WebString& operator=(const WebString& s) {
-    Assign(s);
-    return *this;
-  }
+  BLINK_PLATFORM_EXPORT WebString& operator=(const WebString&);
+  BLINK_PLATFORM_EXPORT WebString& operator=(WebString&&);
 
   BLINK_PLATFORM_EXPORT void Reset();
-  BLINK_PLATFORM_EXPORT void Assign(const WebString&);
-  BLINK_PLATFORM_EXPORT void Assign(const WebUChar* data, size_t len);
 
   BLINK_PLATFORM_EXPORT bool Equals(const WebString&) const;
   BLINK_PLATFORM_EXPORT bool Equals(const char* characters, size_t len) const;
@@ -123,7 +118,7 @@ class WebString {
   BLINK_PLATFORM_EXPORT size_t length() const;
 
   bool IsEmpty() const { return !length(); }
-  bool IsNull() const { return private_.IsNull(); }
+  bool IsNull() const { return !impl_; }
 
   BLINK_PLATFORM_EXPORT std::string Utf8(
       UTF8ConversionMode = UTF8ConversionMode::kLenient) const;
@@ -139,10 +134,8 @@ class WebString {
   }
 
   BLINK_PLATFORM_EXPORT static WebString FromUTF16(const base::string16&);
-
   BLINK_PLATFORM_EXPORT static WebString FromUTF16(
       const base::NullableString16&);
-
   BLINK_PLATFORM_EXPORT static WebString FromUTF16(
       const base::Optional<base::string16>&);
 
@@ -175,13 +168,11 @@ class WebString {
   BLINK_PLATFORM_EXPORT static WebString FromASCII(const std::string&);
 
   template <int N>
-  WebString(const char (&data)[N]) {
-    Assign(FromUTF8(data, N - 1));
-  }
+  WebString(const char (&data)[N]) : WebString(FromUTF8(data, N - 1)) {}
 
   template <int N>
   WebString& operator=(const char (&data)[N]) {
-    Assign(FromUTF8(data, N - 1));
+    *this = FromUTF8(data, N - 1);
     return *this;
   }
 
@@ -202,9 +193,7 @@ class WebString {
   BLINK_PLATFORM_EXPORT const WebLChar* Data8() const;
   BLINK_PLATFORM_EXPORT const WebUChar* Data16() const;
 
-  BLINK_PLATFORM_EXPORT void Assign(WTF::StringImpl*);
-
-  WebPrivatePtr<WTF::StringImpl> private_;
+  scoped_refptr<WTF::StringImpl> impl_;
 };
 
 inline bool operator==(const WebString& a, const char* b) {