Replace ASSERT with DCHECK in platform/

third_party/WebKit/Source/platform/weborigin/SecurityOrigin.cpp

 /*
  * Copyright (C) 2007 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 175 matching lines @@
   }
 
   if (ShouldUseInnerURL(url))
     return AdoptRef(new SecurityOrigin(ExtractInnerURL(url)));
 
   return AdoptRef(new SecurityOrigin(url));
 }
 
 PassRefPtr<SecurityOrigin> SecurityOrigin::CreateUnique() {
   RefPtr<SecurityOrigin> origin = AdoptRef(new SecurityOrigin());
-  ASSERT(origin->IsUnique());
+  DCHECK(origin->IsUnique());
   return origin.Release();
 }
 
 PassRefPtr<SecurityOrigin> SecurityOrigin::IsolatedCopy() const {
   return AdoptRef(new SecurityOrigin(this));
 }
 
 void SecurityOrigin::SetDomainFromDOM(const String& new_domain) {
   domain_was_set_in_dom_ = true;
   domain_ = new_domain;
@@ skipping 155 matching lines @@
   // obtain the privilege by injecting script into the documents that have
   // been granted the privilege.
   can_load_local_resources_ = true;
 }
 
 void SecurityOrigin::GrantUniversalAccess() {
   universal_access_ = true;
 }
 
 void SecurityOrigin::AddSuborigin(const Suborigin& suborigin) {
-  ASSERT(RuntimeEnabledFeatures::suboriginsEnabled());
+  DCHECK(RuntimeEnabledFeatures::suboriginsEnabled());
   // Changing suborigins midstream is bad. Very bad. It should not happen.
   // This is, in fact,  one of the very basic invariants that makes
   // suborigins an effective security tool.
   RELEASE_ASSERT(suborigin_.GetName().IsNull() ||
                  (suborigin_.GetName() == suborigin.GetName()));
   suborigin_.SetTo(suborigin);
 }
 
 void SecurityOrigin::BlockLocalAccessFromLocalOrigin() {
-  ASSERT(IsLocal());
+  DCHECK(IsLocal());
   block_local_access_from_local_origin_ = true;
 }
 
 bool SecurityOrigin::IsLocal() const {
   return SchemeRegistry::ShouldTreatURLSchemeAsLocal(protocol_);
 }
 
 bool SecurityOrigin::IsLocalhost() const {
   // Note: net::isLocalhost has looser checks which allow uppercase hosts, as
   // well as hosts like "a.localhost". The net code is also less optimized and
@@ skipping 175 matching lines @@
   return IsSameSchemeHostPort(other) && same_suborigins;
 }
 
 bool SecurityOrigin::AreSameSchemeHostPort(const KURL& a, const KURL& b) {
   RefPtr<SecurityOrigin> origin_a = SecurityOrigin::Create(a);
   RefPtr<SecurityOrigin> origin_b = SecurityOrigin::Create(b);
   return origin_b->IsSameSchemeHostPort(origin_a.Get());
 }
 
 const KURL& SecurityOrigin::UrlWithUniqueSecurityOrigin() {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   DEFINE_STATIC_LOCAL(const KURL, unique_security_origin_url,
                       (kParsedURLString, "data:,"));
   return unique_security_origin_url;
 }
 
 std::unique_ptr<SecurityOrigin::PrivilegeData>
 SecurityOrigin::CreatePrivilegeData() const {
   std::unique_ptr<PrivilegeData> privilege_data =
       WTF::WrapUnique(new PrivilegeData);
   privilege_data->universal_access_ = universal_access_;
@@ skipping 28 matching lines @@
                               &canon_output, &out_host);
   } else {
     *success = url::CanonicalizeHost(host.Characters16(),
                                      url::Component(0, host.length()),
                                      &canon_output, &out_host);
   }
   return String::FromUTF8(canon_output.data(), canon_output.length());
 }
 
 }  // namespace blink