Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/exported

third_party/WebKit/Source/platform/exported/WebHTTPBody.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 35 matching lines @@
 }
 
 void WebHTTPBody::Assign(const WebHTTPBody& other) {
   WebHTTPBodyPrivate* p = const_cast<WebHTTPBodyPrivate*>(other.private_);
   if (p)
     p->Ref();
   Assign(p);
 }
 
 size_t WebHTTPBody::ElementCount() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   return private_->Elements().size();
 }
 
 bool WebHTTPBody::ElementAt(size_t index, Element& result) const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
 
   if (index >= private_->Elements().size())
     return false;
 
   const FormDataElement& element = private_->Elements()[index];
 
   result.data.Reset();
   result.file_path.Reset();
   result.file_start = 0;
   result.file_length = 0;
@@ skipping 17 matching lines @@
       result.blob_uuid = element.blob_uuid_;
       break;
     case FormDataElement::kEncodedFileSystemURL:
       result.type = Element::kTypeFileSystemURL;
       result.file_system_url = element.file_system_url_;
       result.file_start = element.file_start_;
       result.file_length = element.file_length_;
       result.modification_time = element.expected_file_modification_time_;
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return false;
   }
 
   return true;
 }
 
 void WebHTTPBody::AppendData(const WebData& data) {
   EnsureMutable();
   // FIXME: FormDataElement::m_data should be a SharedBuffer<char>.  Then we
   // could avoid this buffer copy.
@@ skipping 12 matching lines @@
   EnsureMutable();
   private_->AppendFileRange(file_path, file_start, file_length,
                             modification_time);
 }
 
 void WebHTTPBody::AppendFileSystemURLRange(const WebURL& url,
                                            long long start,
                                            long long length,
                                            double modification_time) {
   // Currently we only support filesystem URL.
-  ASSERT(KURL(url).ProtocolIs("filesystem"));
+  DCHECK(KURL(url).ProtocolIs("filesystem"));
   EnsureMutable();
   private_->AppendFileSystemURLRange(url, start, length, modification_time);
 }
 
 void WebHTTPBody::AppendBlob(const WebString& uuid) {
   EnsureMutable();
   private_->AppendBlob(uuid, nullptr);
 }
 
 long long WebHTTPBody::Identifier() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   return private_->Identifier();
 }
 
 void WebHTTPBody::SetIdentifier(long long identifier) {
   EnsureMutable();
   return private_->SetIdentifier(identifier);
 }
 
 bool WebHTTPBody::ContainsPasswordData() const {
   return private_->ContainsPasswordData();
 }
 
 void WebHTTPBody::SetContainsPasswordData(bool contains_password_data) {
   private_->SetContainsPasswordData(contains_password_data);
 }
 
 WebHTTPBody::WebHTTPBody(PassRefPtr<EncodedFormData> data)
     : private_(static_cast<WebHTTPBodyPrivate*>(data.LeakRef())) {}
 
 WebHTTPBody& WebHTTPBody::operator=(PassRefPtr<EncodedFormData> data) {
-  Assign(static_cast<WebHTTPBodyPrivate*>(data.LeakRef()));
+  DCHECK(static_cast<WebHTTPBodyPrivate*>(data.LeakRef()));

[dcheng1, 2017/07/11 03:15:06]

Just a friendly reminder to be careful with refactoring CLs. This was an
incorrect change (that's being fixed in
https://chromium-review.googlesource.com/c/565077/); luckily, it seems no code
was using this so nothing broke.

   return *this;
 }
 
 WebHTTPBody::operator PassRefPtr<EncodedFormData>() const {
   return private_;
 }
 
 void WebHTTPBody::Assign(WebHTTPBodyPrivate* p) {
   // p is already ref'd for us by the caller
   if (private_)
     private_->Deref();
   private_ = p;
 }
 
 void WebHTTPBody::EnsureMutable() {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (!private_->HasOneRef())
     Assign(static_cast<WebHTTPBodyPrivate*>(private_->Copy().LeakRef()));
 }
 
 }  // namespace blink